NepTrainKit 2.2.1__tar.gz → 2.2.2.dev23__tar.gz

{neptrainkit-2.2.1 → neptrainkit-2.2.2.dev23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NepTrainKit
-Version: 2.2.1
+Version: 2.2.2.dev23
 Summary: NepTrainKit is a Python package for visualizing and manipulating training datasets for NEP.
 Author: Chen Cheng bing
 Author-email: Chen Cheng bing <1747193328@qq.com>

{neptrainkit-2.2.1 → neptrainkit-2.2.2.dev23}/src/NepTrainKit/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.2.1'
-__version_tuple__ = version_tuple = (2, 2, 1)
+__version__ = version = '2.2.2.dev23'
+__version_tuple__ = version_tuple = (2, 2, 2, 'dev23')

{neptrainkit-2.2.1 → neptrainkit-2.2.2.dev23}/src/NepTrainKit/core/canvas/base/canvas.py

@@ -156,6 +156,16 @@ class CanvasLayoutBase(CanvasBase):
             self.nep_result_data.select(structure_index)
 
             self.update_scatter_color(structure_index, Brushes.Selected)
+
+    def inverse_select(self):
+        if self.nep_result_data is None:
+            return
+
+        active_indices = set(self.nep_result_data.structure.now_indices.tolist())
+        selected = set(self.nep_result_data.select_index)
+
+        self.select_index(list(selected), True)
+        self.select_index(list(active_indices - selected), False)
 class VispyCanvasLayoutBase(CanvasLayoutBase,QObject,metaclass=CombinedMeta):
     def __init__(self,*args,**kwargs):
         QObject.__init__(self)

{neptrainkit-2.2.1 → neptrainkit-2.2.2.dev23}/src/NepTrainKit/core/custom_widget/__init__.py

@@ -9,6 +9,8 @@ from .completer import CompleterModel, JoinDelegate, ConfigCompleter
 from .dialog import (
     GetIntMessageBox,
     SparseMessageBox,
+    IndexSelectMessageBox,
+    ShiftEnergyMessageBox,
     ProgressDialog,
     PeriodicTableDialog,
 )
@@ -33,6 +35,8 @@ __all__ = [
     "ConfigCompleter",
     "GetIntMessageBox",
     "SparseMessageBox",
+    "IndexSelectMessageBox",
+    "ShiftEnergyMessageBox",
     "ProgressDialog",
     "PeriodicTableDialog",
     "SpinBoxUnitInputFrame",

{neptrainkit-2.2.1 → neptrainkit-2.2.2.dev23}/src/NepTrainKit/core/custom_widget/completer.py

@@ -33,7 +33,7 @@ class CompleterModel(QAbstractListModel):
     def data(self, index, role=Qt.ItemDataRole.DisplayRole):
 
         if not index.isValid():
-            print("index")
+
             return None
         # print(role)
         # Qt.ItemDataRole.DisplayRole
@@ -44,7 +44,7 @@ class CompleterModel(QAbstractListModel):
             if role == Qt.ItemDataRole.DisplayRole or role == Qt.ItemDataRole.EditRole:
                 return word
             elif role == CountRole:
-                print(count)
+
                 return str(count)
 
 

{neptrainkit-2.2.1 → neptrainkit-2.2.2.dev23}/src/NepTrainKit/core/custom_widget/dialog.py

@@ -4,14 +4,16 @@
 # @Author  : 兵
 # @email    : 1747193328@qq.com
 from PySide6.QtGui import QIcon
-from PySide6.QtWidgets import QVBoxLayout, QFrame, QGridLayout, QPushButton
+from PySide6.QtWidgets import QVBoxLayout, QFrame, QGridLayout, QPushButton, QLineEdit
 from PySide6.QtCore import Signal, Qt
 from qfluentwidgets import (
     MessageBoxBase,
     SpinBox,
     CaptionLabel,
     DoubleSpinBox,
+    CheckBox,
     ProgressBar,
+    ComboBox,
     FluentStyleSheet,
     FluentTitleBar,
     TitleLabel
@@ -73,6 +75,78 @@ class SparseMessageBox(MessageBoxBase):
 
         self.widget.setMinimumWidth(200)
 
+
+class IndexSelectMessageBox(MessageBoxBase):
+    """Dialog for selecting structures by index."""
+
+    def __init__(self, parent=None, tip="Specify index or slice"):
+        super().__init__(parent)
+        self.titleLabel = CaptionLabel(tip, self)
+        self.titleLabel.setWordWrap(True)
+        self.indexEdit = QLineEdit(self)
+        self.checkBox = CheckBox("Use original indices", self)
+        self.checkBox.setChecked(True)
+
+        self.viewLayout.addWidget(self.titleLabel)
+        self.viewLayout.addWidget(self.indexEdit)
+        self.viewLayout.addWidget(self.checkBox)
+
+        self.yesButton.setText('Ok')
+        self.cancelButton.setText('Cancel')
+        self.widget.setMinimumWidth(200)
+
+
+class ShiftEnergyMessageBox(MessageBoxBase):
+    """Dialog for energy baseline shift parameters."""
+
+    def __init__(self, parent=None, tip="Group regex patterns (comma separated)"):
+        super().__init__(parent)
+        self.titleLabel = CaptionLabel(tip, self)
+        self.titleLabel.setWordWrap(True)
+        self.groupEdit = QLineEdit(self)
+
+        self._frame = QFrame(self)
+        self.frame_layout = QGridLayout(self._frame)
+        self.frame_layout.setContentsMargins(0, 0, 0, 0)
+        self.frame_layout.setSpacing(2)
+
+        self.genSpinBox = SpinBox(self)
+        self.genSpinBox.setMaximum(100000000)
+        self.sizeSpinBox = SpinBox(self)
+        self.sizeSpinBox.setMaximum(999999)
+        self.tolSpinBox = DoubleSpinBox(self)
+        self.tolSpinBox.setDecimals(8)
+        self.tolSpinBox.setMinimum(0)
+        self.modeCombo = ComboBox(self)
+        self.modeCombo.addItems([
+            "REF_GROUP_ALIGNMENT",
+            "ZERO_BASELINE_ALIGNMENT",
+            "DFT_TO_NEP_ALIGNMENT",
+        ])
+        self.modeCombo.setCurrentText("DFT_TO_NEP_ALIGNMENT")
+
+
+        self.frame_layout.addWidget(CaptionLabel("Max generations", self), 0, 0)
+        self.frame_layout.addWidget(self.genSpinBox, 0, 1)
+        self.frame_layout.addWidget(CaptionLabel("Population size", self), 1, 0)
+        self.frame_layout.addWidget(self.sizeSpinBox, 1, 1)
+        self.frame_layout.addWidget(CaptionLabel("Convergence tol", self), 2, 0)
+        self.frame_layout.addWidget(self.tolSpinBox, 2, 1)
+        self.frame_layout.addWidget(CaptionLabel("Mode", self), 3, 0)
+        self.frame_layout.addWidget(self.modeCombo, 3, 1)
+
+
+        self.viewLayout.addWidget(self.titleLabel)
+        self.viewLayout.addWidget(self.groupEdit)
+        self.viewLayout.addWidget(self._frame)
+
+        self.yesButton.setText('Ok')
+        self.cancelButton.setText('Cancel')
+        self.widget.setMinimumWidth(250)
+
+
+
+
 class ProgressDialog(FramelessDialog):
     """进度条弹窗"""
     def __init__(self,parent=None,title=""):

neptrainkit-2.2.2.dev23/src/NepTrainKit/core/energy_shift.py

@@ -0,0 +1,216 @@
+"""Utilities for shifting structure energies using atomic baselines.
+抄的陈博的代码(已允许)
+url: https://github.com/brucefan1983/GPUMD/tree/master/tools/Analysis_and_Processing/energy-reference-aligner
+Zherui Chen Email: <chenzherui0124@foxmail.com>
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from collections import Counter
+from typing import List, Dict
+import re
+from NepTrainKit import utils
+from .structure import Structure
+from .calculator import NepCalculator
+
+REF_GROUP_ALIGNMENT = "REF_GROUP_ALIGNMENT"
+ZERO_BASELINE_ALIGNMENT = "ZERO_BASELINE_ALIGNMENT"
+DFT_TO_NEP_ALIGNMENT = "DFT_TO_NEP_ALIGNMENT"
+
+def longest_common_prefix(strs: List[str]) -> str:
+    if not strs:
+        return ""
+    s1, s2 = min(strs), max(strs)
+    for i, c in enumerate(s1):
+        if c != s2[i]:
+            return s1[:i]
+    return s1
+
+
+def suggest_group_patterns(config_types: List[str], min_group_size: int = 2, min_prefix_len: int = 3) -> List[str]:
+    """Group strings by common prefix without relying on delimiters, and output regex patterns."""
+    unused = set(config_types)
+    patterns = []
+
+    while unused:
+        base = unused.pop()
+        group = [base]
+        to_remove = []
+
+        for other in unused:
+            prefix = longest_common_prefix([base, other])
+            if len(prefix) >= min_prefix_len:
+                group.append(other)
+                to_remove.append(other)
+
+        for item in to_remove:
+            unused.remove(item)
+
+        if len(group) >= min_group_size:
+            prefix = longest_common_prefix(group)
+            patterns.append(re.escape(prefix) + '.*')
+        else:
+            patterns.extend(re.escape(g) for g in group)
+
+    return sorted(patterns)
+def atomic_baseline_cost(param_population: np.ndarray,
+                         energies: np.ndarray,
+                         element_counts: np.ndarray,
+                         target_energies: np.ndarray) -> np.ndarray:
+    """Vectorized MSE cost for atomic reference baseline."""
+    shifted = energies[None, :] - np.dot(param_population, element_counts.T)
+    cost = np.mean((shifted - target_energies[None, :]) ** 2, axis=1)
+    return cost.reshape(-1, 1)
+
+@utils.timeit
+def nes_optimize_atomic_baseline(num_variables: int,
+                                 max_generations: int,
+                                 energies: np.ndarray,
+                                 element_counts: np.ndarray,
+                                 targets: np.ndarray,
+                                 pop_size: int = 40,
+                                 tol: float = 1e-8,
+                                 seed: int = 42,
+                                 print_every: int = 100) -> np.ndarray:
+    """NES optimizer for atomic reference energies."""
+    np.random.seed(seed)
+
+    best_fitness = np.ones((max_generations, 1))
+    elite = np.zeros((max_generations, num_variables))
+    mean = -1 * np.random.rand(1, num_variables)
+    stddev = 0.1 * np.ones((1, num_variables))
+    lr_mean = 1.0
+    lr_std = (3 + np.log(num_variables)) / (5 * np.sqrt(num_variables)) / 2
+    weights = np.maximum(0, np.log(pop_size / 2 + 1) - np.log(np.arange(1, pop_size + 1)))
+    weights = weights / np.sum(weights) - 1 / pop_size
+
+    for gen in range(max_generations):
+        z = np.random.randn(pop_size, num_variables)
+        pop = mean + stddev * z
+        fitness = atomic_baseline_cost(pop, energies, element_counts, targets)
+        idx = np.argsort(fitness.flatten())
+        fitness = fitness[idx]
+        z = z[idx, :]
+        pop = pop[idx, :]
+        best_fitness[gen] = fitness[0]
+        elite[gen, :] = pop[0, :]
+        mean += lr_mean * stddev * (weights @ z)
+        stddev *= np.exp(lr_std * (weights @ (z ** 2 - 1)))
+        if gen > 0 and abs(best_fitness[gen] - best_fitness[gen - 1]) < tol:
+            best_fitness = best_fitness[:gen + 1]
+            elite = elite[:gen + 1]
+            break
+    return elite[-1]
+
+
+
+def shift_dataset_energy(
+        structures: List[Structure],
+        reference_structures: List[Structure] | None,
+        max_generations: int = 100000,
+        population_size: int = 40,
+        convergence_tol: float = 1e-8,
+        random_seed: int = 42,
+        group_patterns: List[str] | None = None,
+        alignment_mode: str = REF_GROUP_ALIGNMENT,
+        nep_energy_array: np.array | None = None):
+    """Shift structure energies using different alignment strategies.
+
+    Parameters
+    ----------
+    structures
+        Structures whose energies will be shifted.
+    reference_structures
+        Structures used to compute the reference mean energy when
+        ``alignment_mode`` is ``REF_GROUP_ALIGNMENT``.
+    alignment_mode
+        One of ``REF_GROUP_ALIGNMENT``, ``ZERO_BASELINE_ALIGNMENT`` or
+        ``DFT_TO_NEP_ALIGNMENT``.
+    nep_energy_array
+        nep energy array when ``alignment_mode`` is
+        ``DFT_TO_NEP_ALIGNMENT``.
+    """
+    frames = []
+    for s in structures:
+        energy = float(s.energy)
+        config_type = str(s.additional_fields.get("Config_type", ""))
+        elem_counts = Counter(s.elements)
+
+        frames.append({"energy": energy, "config_type": config_type, "elem_counts": elem_counts})
+
+    all_elements = sorted({e for f in frames for e in f["elem_counts"]})
+    num_elements = len(all_elements)
+
+
+    ref_mean = None
+    if alignment_mode == REF_GROUP_ALIGNMENT:
+        if not len(reference_structures):
+            raise ValueError("reference_structures is required for REF_GROUP_ALIGNMENT")
+        ref_energies = np.array([f.energy for f in reference_structures])
+        ref_mean = np.mean(ref_energies)
+
+    if alignment_mode == DFT_TO_NEP_ALIGNMENT:
+        if nep_energy_array is None:
+            raise ValueError("nep_energy_array is required for DFT_TO_NEP_ALIGNMENT")
+
+        for f, e in zip(frames, nep_energy_array):
+            f["nep_energy"] = e * f["elem_counts"].total()
+
+    all_config_types = {f["config_type"] for f in frames}
+
+    # build mapping from config_type to regex group name
+    config_to_group: Dict[str, str] = {}
+    if group_patterns:
+        for pat in group_patterns:
+            try:
+                regex = re.compile(pat)
+            except re.error:
+                continue
+            for ct in all_config_types:
+                if ct not in config_to_group and regex.match(ct):
+                    config_to_group[ct] = pat
+    for ct in all_config_types:
+        config_to_group.setdefault(ct, ct)
+
+    shift_groups = sorted(set(config_to_group.values()))
+
+    group_to_atomic_ref = {}
+    for group in shift_groups:
+
+        grp_frames = [f for f in frames if config_to_group[f["config_type"]] == group]
+        if not grp_frames:
+            continue
+        energies = np.array([f["energy"] for f in grp_frames])
+        counts = np.array([[f["elem_counts"].get(e, 0) for e in all_elements] for f in grp_frames], dtype=float)
+
+        if alignment_mode == REF_GROUP_ALIGNMENT:
+            targets = np.full_like(energies, ref_mean)
+        elif alignment_mode == ZERO_BASELINE_ALIGNMENT:
+            targets = np.zeros_like(energies)
+        else:  # DFT_TO_NEP_ALIGNMENT
+            targets = np.array([f["nep_energy"] for f in grp_frames])
+        atomic_ref = nes_optimize_atomic_baseline(
+            num_elements,
+            max_generations,
+            energies,
+            counts,
+            targets,
+            pop_size=population_size,
+            tol=convergence_tol,
+            seed=random_seed,
+            print_every=100,
+        )
+        group_to_atomic_ref[group] = atomic_ref
+        #这里是为了更新ui信号
+        yield 1
+
+    # apply shift
+    for s, frame in zip(structures, frames):
+        group = config_to_group[frame["config_type"]]
+        if group in group_to_atomic_ref:
+            count_vec = np.array([frame["elem_counts"].get(e, 0) for e in all_elements], dtype=float)
+            shift = np.dot(count_vec, group_to_atomic_ref[group])
+            new_energy = frame["energy"] - shift
+            s.energy = new_energy
+    # return group_to_atomic_ref

{neptrainkit-2.2.1 → neptrainkit-2.2.2.dev23}/src/NepTrainKit/core/io/base.py

@@ -111,6 +111,9 @@ class NepData:
         """
         return self.data.now_data
     @property
+    def now_indices(self):
+        return self.data.now_indices
+    @property
     def all_data(self):
         return self.data.all_data
 

{neptrainkit-2.2.1 → neptrainkit-2.2.2.dev23}/src/NepTrainKit/core/io/nep.py

@@ -155,6 +155,17 @@ class ResultData(QObject):
                 self.select_index.remove(i)
 
         self.updateInfoSignal.emit()
+
+    def inverse_select(self):
+        """Invert the current selection state of all active structures"""
+        active_indices = set(self.structure.data.now_indices.tolist())
+        selected_indices = set(self.select_index)
+        unselect = list(selected_indices)
+        select = list(active_indices - selected_indices)
+        if unselect:
+            self.uncheck(unselect)
+        if select:
+            self.select(select)
     def export_selected_xyz(self,save_file_path):
         """
         导出当前选中的结构

{neptrainkit-2.2.1 → neptrainkit-2.2.2.dev23}/src/NepTrainKit/core/structure.py

@@ -116,8 +116,13 @@ class Structure:
 
     @property
     def per_atom_energy(self):
-        return self.additional_fields["energy"]/self.num_atoms
-
+        return self.energy/self.num_atoms
+    @property
+    def energy(self):
+        return self.additional_fields["energy"]
+    @energy.setter
+    def energy(self,new_energy):
+        self.additional_fields["energy"] = new_energy
     @property
     def forces(self):
         return self.structure_info[self.force_label]

{neptrainkit-2.2.1 → neptrainkit-2.2.2.dev23}/src/NepTrainKit/core/update.py

@@ -72,9 +72,7 @@ class UpdateWoker( QObject):
         if version_info['tag_name'][1:] == __version__:
             MessageManager.send_success_message("You are already using the latest version!")
             return
-        if not is_nuitka_compiled:
-            MessageManager.send_info_message("You can update via pip install NepTrainKit -U")
-            return
+
         box = MessageBox("New version detected:" + version_info["name"] + version_info["tag_name"],
                          version_info["body"],
                          self._parent
@@ -92,6 +90,9 @@ class UpdateWoker( QObject):
         MessageManager.send_warning_message("No update package available for your system. Please download it manually!")
 
     def check_update(self):
+        if not is_nuitka_compiled:
+            MessageManager.send_info_message("You can update via pip install NepTrainKit -U --pre")
+            return
         self.update_thread.start_work(self._check_update)
 
 

{neptrainkit-2.2.1 → neptrainkit-2.2.2.dev23}/src/NepTrainKit/core/views/nep.py

@@ -3,17 +3,28 @@
 # @Time    : 2024/10/20 22:22
 # @Author  : 兵
 # @email    : 1747193328@qq.com
+import os
 import time
+import traceback
+
+from loguru import logger
+
 start=time.time()
 import numpy as np
 from PySide6.QtWidgets import QHBoxLayout, QWidget, QProgressDialog
 
 
-from NepTrainKit import utils
+from NepTrainKit import utils, module_path
 from NepTrainKit.core import MessageManager, Config
-from NepTrainKit.core.custom_widget import GetIntMessageBox, SparseMessageBox
+from NepTrainKit.core.custom_widget import (
+    GetIntMessageBox,
+    SparseMessageBox,
+    IndexSelectMessageBox,
+    ShiftEnergyMessageBox,
+)
 from NepTrainKit.core.io.select import farthest_point_sampling
 from NepTrainKit.core.views.toolbar import NepDisplayGraphicsToolBar
+from NepTrainKit.core.energy_shift import shift_dataset_energy, suggest_group_patterns
 
 
 class NepResultPlotWidget(QWidget):
@@ -63,6 +74,9 @@ class NepResultPlotWidget(QWidget):
         self.tool_bar.findMaxSignal.connect(self.find_max_error_point)
         self.tool_bar.discoverySignal.connect(self.find_non_physical_structures)
         self.tool_bar.sparseSignal.connect(self.sparse_point)
+        self.tool_bar.shiftEnergySignal.connect(self.shift_energy_baseline)
+        self.tool_bar.inverseSignal.connect(self.inverse_select)
+        self.tool_bar.selectIndexSignal.connect(self.select_by_index)
         self.canvas.tool_bar=self.tool_bar
 
 
@@ -142,11 +156,11 @@ class NepResultPlotWidget(QWidget):
         remaining_indices = farthest_point_sampling(dataset.now_data,n_samples=n_samples,min_dist=distance)
 
         # 获取所有索引（从 0 到 len(arr)-1）
-        all_indices = np.arange(dataset.now_data.shape[0])
+        # all_indices = np.arange(dataset.now_data.shape[0])
 
         # 使用 setdiff1d 获取不在 indices_to_remove 中的索引
-        remove_indices = np.setdiff1d(all_indices, remaining_indices)
-        structures = dataset.group_array[remove_indices]
+        # remove_indices = np.setdiff1d(all_indices, remaining_indices)
+        structures = dataset.group_array[remaining_indices]
         self.canvas.select_index(structures.tolist(),False)
 
     def export_descriptor_data(self):
@@ -175,6 +189,92 @@ class NepResultPlotWidget(QWidget):
         with open(path, "w") as f:
             np.savetxt(f,descriptor_data,fmt='%.6g',delimiter='\t')
 
+
+    def shift_energy_baseline(self):
+        data = self.canvas.nep_result_data
+        if data is None:
+            return
+        ref_index = list(data.select_index)
+        # if len(ref_index) == 0:
+        #     MessageManager.send_info_message("No data selected!")
+        #     return
+
+        max_generations = Config.getint("widget","max_generation_value",100000)
+        population_size =  Config.getint("widget","population_size",40)
+        convergence_tol = Config.getfloat("widget","convergence_tol", 1e-8)
+        config_set = set(data.structure.get_all_config())
+        suggested = suggest_group_patterns(list(config_set))
+        box = ShiftEnergyMessageBox(
+            self._parent,
+            "Specify regex groups for Config_type (comma separated)"
+        )
+        box.groupEdit.setText(";".join(suggested))
+        box.genSpinBox.setValue(max_generations)
+        box.sizeSpinBox.setValue(population_size)
+        box.tolSpinBox.setValue(convergence_tol)
+
+
+        if not box.exec():
+            return
+
+        pattern_text = box.groupEdit.text().strip()
+        group_patterns = [p.strip() for p in pattern_text.split(';') if p.strip()]
+
+        alignment_mode = box.modeCombo.currentText()
+
+
+        max_generations = box.genSpinBox.value()
+        population_size = box.sizeSpinBox.value()
+        convergence_tol = box.tolSpinBox.value()
+        Config.set("widget","max_generation_value",max_generations)
+        Config.set("widget","population_size",population_size)
+        Config.set("widget","convergence_tol",convergence_tol)
+        config_set = set(data.structure.get_all_config())
+        progress_diag = QProgressDialog(f"", "Cancel", 0, len(config_set), self._parent)
+        thread = utils.LoadingThread(self._parent, show_tip=False)
+        progress_diag.setFixedSize(300, 100)
+        progress_diag.setWindowTitle("Shift energies")
+        thread.progressSignal.connect(progress_diag.setValue)
+        thread.finished.connect(progress_diag.accept)
+        progress_diag.canceled.connect(thread.stop_work)  # 用户取消时终止线程
+        thread.start_work(
+            shift_dataset_energy,
+            structures=data.structure.now_data,
+            reference_structures=data.structure.all_data[ref_index],
+            max_generations=max_generations,
+            population_size=population_size,
+            convergence_tol=convergence_tol,
+            group_patterns=group_patterns,
+            alignment_mode=alignment_mode,
+            nep_energy_array=data.energy.y,
+        )
+        progress_diag.exec()
+        if hasattr(data, "energy") and data.energy.num != 0:
+            for i, s in enumerate(data.structure.all_data):
+                # print(s.per_atom_energy)
+                data.energy.data._data[i, 1] = s.per_atom_energy
+        self.canvas.plot_nep_result()
+
+    def inverse_select(self):
+        self.canvas.inverse_select()
+
+    def select_by_index(self):
+        if self.canvas.nep_result_data is None:
+            return
+        box = IndexSelectMessageBox(self._parent, "Select structures by index")
+        if not box.exec():
+            return
+        text = box.indexEdit.text().strip()
+        use_origin = box.checkBox.isChecked()
+        data = self.canvas.nep_result_data.structure
+        total = data.all_data.shape[0] if use_origin else data.now_data.shape[0]
+        indices = utils.parse_index_string(text, total)
+        if not indices:
+            return
+        if not use_origin:
+            indices = data.group_array.now_data[indices].tolist()
+        self.canvas.select_index(indices, False)
+
     def set_dataset(self,dataset):
 
         if self.last_figure_num !=len(dataset.dataset):

{neptrainkit-2.2.1 → neptrainkit-2.2.2.dev23}/src/NepTrainKit/core/views/toolbar.py

@@ -42,6 +42,9 @@ class NepDisplayGraphicsToolBar(KitToolBarBase):
     deleteSignal=Signal()
     revokeSignal=Signal()
     exportSignal=Signal()
+    shiftEnergySignal=Signal()
+    inverseSignal=Signal()
+    selectIndexSignal=Signal()
 
     def init_actions(self):
         self.addButton("Reset View",QIcon(":/images/src/images/init.svg"),self.resetSignal)
@@ -50,6 +53,9 @@ class NepDisplayGraphicsToolBar(KitToolBarBase):
                                    self.pan,
                                    True
                                    )
+        self.addButton("Select by Index",
+                       QIcon(":/images/src/images/index.svg"),
+                       self.selectIndexSignal)
         find_max_action = self.addButton("Find Max Error Point",
                                         QIcon(":/images/src/images/find_max.svg"),
                                         self.findMaxSignal)
@@ -58,6 +64,8 @@ class NepDisplayGraphicsToolBar(KitToolBarBase):
                                     self.sparseSignal)
 
 
+
+
         pen_action=self.addButton("Mouse Selection",
                                    QIcon(":/images/src/images/pen.svg"),
                                    self.pen,
@@ -71,6 +79,9 @@ class NepDisplayGraphicsToolBar(KitToolBarBase):
         discovery_action = self.addButton("Finding non-physical structures",
                                         QIcon(":/images/src/images/discovery.svg"),
                                         self.discoverySignal)
+        inverse_action = self.addButton("Inverse Selection",
+                                     QIcon(":/images/src/images/inverse.svg"),
+                                     self.inverseSignal)
         revoke_action = self.addButton("Undo",
                                      QIcon(":/images/src/images/revoke.svg"),
                                      self.revokeSignal)
@@ -78,10 +89,15 @@ class NepDisplayGraphicsToolBar(KitToolBarBase):
         delete_action = self.addButton("Delete Selected Items",
                                      QIcon(":/images/src/images/delete.svg"),
                                      self.deleteSignal)
+
         self.addSeparator()
         export_action = self.addButton("Export structure descriptor",
                                      QIcon(":/images/src/images/export.svg"),
                                      self.exportSignal)
+        self.addSeparator()
+        self.addButton("Energy Baseline Shift",
+                       QIcon(":/images/src/images/alignment.svg"),
+                       self.shiftEnergySignal)
 
     def reset(self):
         if self.action_group.checkedAction():