shape2sas plugin models

src/sas/qtgui/Calculators/Shape2SAS/DesignWindow.py

@@ -17,7 +17,6 @@
 
 from sas.qtgui.Calculators.Shape2SAS.ButtonOptions import ButtonOptions
 from sas.qtgui.Calculators.Shape2SAS.Constraints import Constraints, logger
-from sas.qtgui.Calculators.Shape2SAS.genPlugin import generatePlugin
 from sas.qtgui.Calculators.Shape2SAS.PlotAspects.plotAspects import Canvas, ViewerPlotDesign
 from sas.qtgui.Calculators.Shape2SAS.Tables.subunitTable import OptionLayout, SubunitTable
 from sas.qtgui.Calculators.Shape2SAS.UI.DesignWindowUI import Ui_Shape2SAS
@@ -28,6 +27,7 @@
 
 # Local SasView
 from sas.qtgui.Utilities.ModelEditors.TabbedEditor.TabbedModelEditor import TabbedModelEditor
+from sas.sascalc.shape2sas.PluginGenerator import generate_plugin
 from sas.sascalc.shape2sas.Shape2SAS import (
     ModelProfile,
     ModelSystem,
@@ -91,9 +91,8 @@ def __init__(self, parent=None):
         self.plugin.setEnabled(False)
         self.modelTabButtonOptions.horizontalLayout_5.insertWidget(1, self.plugin)
 
-        # TODO: Remove these lines to enable the plugin model generation window - hidden for v6.1.0
-        self.line2.setHidden(True)
         self.plugin.setHidden(True)
+        self.line2.setHidden(True)
 
         #connect buttons
         self.modelTabButtonOptions.reset.clicked.connect(self.onSubunitTableReset)
@@ -103,7 +102,7 @@ def __init__(self, parent=None):
 
         #create layout for build model tab
         self.viewerModel = ViewerModel()
-        self.subunitTable = SubunitTable()
+        self.subunitTable = SubunitTable(self.onClickingPlot)
 
         modelVbox = QVBoxLayout()
         modelHbox = QHBoxLayout()
@@ -164,7 +163,8 @@ def __init__(self, parent=None):
         #TODO: implement in a future project
 
         ###Building Constraint window
-        self.constraint = Constraints()
+        self.constraint = Constraints(parent=self)
+        self.constraint.setWindowFlags(Qt.Window | Qt.Tool)
         self.subunitTable.add.clicked.connect(self.addToVariableTable)
         self.subunitTable.deleteButton.clicked.connect(self.deleteFromVariableTable)
         self.subunitTable.table.clicked.connect(self.updateDeleteButton)
@@ -181,6 +181,8 @@ def __init__(self, parent=None):
     def showConstraintWindow(self):
         """Get the Constraint window"""
 
+        self.constraint.setScreen(self.screen())
+        self.constraint.move(self.pos().x()+50, self.pos().y()+50)
         self.constraint.show()
 
     def checkedVariables(self):
@@ -255,21 +257,21 @@ def checkStateOfConstraints(self, fitPar: list[str], modelPars: list[list[str]],
 
         #Has anything been written to the text editor
         if constraintsStr:
-            #TODO: print to GUI output texteditor
-            return self.constraint.getConstraints(constraintsStr, fitPar, modelPars, modelVals, checkedPars)
+            self.constraint.log_embedded("Parsing constraints...")
+            return self.constraint.parseConstraintsText(constraintsStr, fitPar, modelPars, modelVals, checkedPars)
 
         #Did the user only check parameters and click generate plugin
         elif fitPar:
             #Get default constraints
             fitParLists = self.getConstraintsToTextEditor()
             defaultConstraintsStr = self.constraint.getConstraintText(fitParLists)
-            #TODO: print to GUI output texteditor
+            self.constraint.log_embedded("No constraints text found. Creating unconstrained model")
             return self.constraint.getConstraints(defaultConstraintsStr, fitPar, modelPars, modelVals, checkedPars)
 
         #If not, return empty
         else:
             #all parameters are constant
-            #TODO: print to GUI output texteditor
+            self.constraint.log_embedded("Creating unconstrained model.")
             return "", "", "", checkedPars
 
     def enableButtons(self, toggle: bool):
@@ -487,6 +489,8 @@ def onClickingPlot(self):
         self.plugin.setEnabled(columns > 0)
 
         if not self.subunitTable.model.item(1, columns - 1):
+            self.viewerModel.setClearScatteringPlot()
+            self.viewerModel.setClearModelPlot()
             return
 
         modelProfile = self.getModelProfile(self.ifEmptyValue)
@@ -637,20 +641,30 @@ def getPluginModel(self):
         #get chosen fit parameters
         fitPar = self.getFitParameters()
 
-        logger.info("Retrieving and verifying constraints. . .")
+        logger.info("Retrieving and verifying constraints.")
         #get parameters constraints
-        importStatement, parameters, translation, checkedPars = self.checkStateOfConstraints(fitPar, parNames, parVals, checkedPars)
+        usertext, checkedPars = self.checkStateOfConstraints(fitPar, parNames, parVals, checkedPars)
 
-        logger.info("Retrieving Model. . .")
+        logger.info("Retrieving Model.")
         #conditional subunit table parameters
         modelProfile = self.getModelProfile(self.ifFitPar, conditionBool=checkedPars, conditionFitPar=parNames)
 
-        model_str, full_path = generatePlugin(modelProfile, [importStatement, parameters, translation], fitPar, Npoints, prPoints, modelName)
+        model_str, full_path = generate_plugin(
+            modelProfile,
+            [parNames, parVals],
+            usertext,
+            fitPar,
+            Npoints,
+            prPoints,
+            modelName
+        )
 
         #Write file to plugin model folder
         TabbedModelEditor.writeFile(full_path, model_str)
         self.communicator.customModelDirectoryChanged.emit()
         logger.info(f"Successfully generated model {modelName}!")
+        self.constraint.log_embedded(f"Plugin model {modelName} has been generated and is now available in the Fit panel.")
+        self.constraint.createPlugin.setEnabled(False)
 
     def onCheckingInput(self, input: str, default: str) -> str:
         """Check if the input not None. Otherwise, return default value"""
@@ -699,13 +713,20 @@ def getSimulatedSAXSData(self):
 
         Distr = getPointDistribution(Profile, N)
 
-        Theo_calc = TheoreticalScatteringCalculation(System=ModelSystem(PointDistribution=Distr,
-                                                                        Stype=Stype, par=par,
-                                                                        polydispersity=polydispersity,
-                                                                        conc=conc,
-                                                                        sigma_r=sigma_r),
-                                                                        Calculation=Sim_par)
-        Theo_I = getTheoreticalScattering(Theo_calc)
+        model = ModelSystem(
+            PointDistribution=Distr,
+            Stype=Stype, par=par,
+            polydispersity=polydispersity,
+            conc=conc,
+            sigma_r=sigma_r
+        )
+
+        Theo_I = getTheoreticalScattering(
+            TheoreticalScatteringCalculation(
+                System=model,
+                Calculation=Sim_par
+            )
+        )
         Sim_calc = SimulateScattering(q=Theo_I.q, I0=Theo_I.I0, I=Theo_I.I, exposure=exposure)
         Sim_SAXS = getSimulatedScattering(Sim_calc)
 

src/sas/qtgui/Calculators/Shape2SAS/Tables/subunitTable.py

@@ -333,11 +333,12 @@ class CustomStandardItem(QStandardItem):
     """Custom QStandardItem to set initial values, roles
     and take care of subunit and colour case"""
 
-    def __init__(self, prefix="", unit="", tooltip="", default_value=None):
+    def __init__(self, prefix="", unit="", tooltip="", default_value=None, plot_callback=None):
         super().__init__(str(default_value))
         self.prefix = prefix
         self.tooltip = tooltip
         self.unit = unit
+        self.plot_callback = plot_callback
 
         self.setData(default_value, Qt.EditRole)
 
@@ -350,7 +351,6 @@ def data(self, role=Qt.DisplayRole):
             return f"{self.prefix}{value}{self.unit}"
         elif role == Qt.ToolTipRole:
             return self.tooltip
-
         return value
 
 
@@ -366,6 +366,8 @@ def setData(self, value, role=Qt.EditRole):
             super().setData(value, Qt.DisplayRole)
         else:
             super().setData(value, role)
+        if self.plot_callback:
+            self.plot_callback()
 
 
 class CustomDelegate(QStyledItemDelegate):
@@ -433,13 +435,14 @@ def __init__(self, parent=None):
 class SubunitTable(QWidget, Ui_SubunitTableController):
     """Subunit table functionality and design for the model tab"""
 
-    def __init__(self):
+    def __init__(self, updatePlotCallback=None):
         super(SubunitTable, self).__init__()
         self.setupUi(self)
 
         self.columnEyeKeeper = []
         self.restrictedRowsPos = []
 
+        self.updatePlotCallback = updatePlotCallback
         self.initializeModel()
         self.initializeSignals()
         self.setSubunitOptions()
@@ -508,8 +511,11 @@ def onAdding(self):
                 #if row is contained in the subunit
                 if row in subunitName.keys():
                     paintedName = subunitName[row] + f"{to_column_name}" + " = "
-                    item = CustomStandardItem(paintedName, subunitUnits[row],
-                                            subunitTooltip[row], subunitDefault_value[row])
+                    item = CustomStandardItem(
+                        paintedName, subunitUnits[row],
+                        subunitTooltip[row], subunitDefault_value[row],
+                        plot_callback=self.updatePlotCallback
+                    )
                 else:
                     #no input for this row
                     item = CustomStandardItem("", "", "", "")
@@ -529,8 +535,11 @@ def onAdding(self):
                 attr = getattr(OptionLayout, row.value)
                 method = MethodType(attr, OptionLayout)
                 name, defaultVal, units, tooltip, _, _ = method()
-                item = CustomStandardItem(name[row] + f"{to_column_name}" + " = ", units[row],
-                                          tooltip[row], defaultVal[row])
+                item = CustomStandardItem(
+                    name[row] + f"{to_column_name}" + " = ", units[row],
+                    tooltip[row], defaultVal[row],
+                    plot_callback=self.updatePlotCallback
+                )
 
             items.append(item)
 
@@ -539,6 +548,7 @@ def onAdding(self):
         self.setSubunitRestriction(subunitName.keys())
         self.table.resizeColumnsToContents()
         self.setButtonSpinboxBounds()
+        self.updatePlotCallback() # Update the plot after adding a subunit
 
 
     def onDeleting(self):
@@ -554,6 +564,7 @@ def onDeleting(self):
         #clear the table if no columns are left
         if not self.model.columnCount():
             self.onClearSubunitTable()
+        self.updatePlotCallback() # Update the plot after removing a subunit
 
 
     def setButtonSpinboxBounds(self):

src/sas/qtgui/Calculators/Shape2SAS/Tables/variableTable.py

@@ -58,6 +58,7 @@ def __init__(self):
 
         self.initializeVariableModel()
         self.setDefaultLayout()
+        self.on_item_changed_callback = None
 
 
     def initializeVariableModel(self):
@@ -99,8 +100,13 @@ def setVariableTableData(self, names: list[str], column: int):
         itemNum.setTextAlignment(Qt.AlignCenter)
         itemNum.setFont(font)
         self.variableModel.insertRow(numrow, [itemName, itemNum])
+        self.variableModel.itemChanged.connect(self.onItemChanged)
         itemNum.setFlags(itemNum.flags() & ~Qt.ItemIsSelectable & ~Qt.ItemIsEditable)
 
+    def onItemChanged(self, item):
+        """Handle item changes in the variable table"""
+        if self.on_item_changed_callback:
+            self.on_item_changed_callback(item)
 
     def removeTableData(self, row):
         """Remove data from table"""

src/sas/qtgui/Calculators/Shape2SAS/ViewerModel.py

@@ -10,7 +10,8 @@
 
 # Local Perspectives
 from sas.qtgui.Calculators.Shape2SAS.ViewerAllOptions import ViewerButtons, ViewerModelRadius
-from sas.sascalc.shape2sas.Shape2SAS import ModelPointDistribution, TheoreticalScattering
+from sas.sascalc.shape2sas.Models import ModelPointDistribution
+from sas.sascalc.shape2sas.TheoreticalScattering import TheoreticalScattering
 
 
 class ViewerModel(QWidget):
@@ -22,6 +23,9 @@ def __init__(self, parent=None):
         ###3D plot view of model
         self.scatter = Q3DScatter()
 
+        # remove shadows
+        self.scatter.setShadowQuality(Q3DScatter.ShadowQuality.ShadowQualityNone)
+
         """
         NOTE: Orignal intend was to create
         QScatter3DSeries() in setPlot() method. However,
@@ -143,13 +147,24 @@ def initialiseAxis(self):
         self.scatter.setAxisZ(self.Z_ax)
 
     def setAxis(self, x_range: (float, float), y_range: (float, float), z_range: (float, float)):
-        """Set axis for the model"""
-
-        #FIXME: even if min and max are the same for X, Y, Z, a sphere still looks like an ellipsoid
-        #Tried with global min and max, and by centering the model, but no success.
-        self.X_ax.setRange(*x_range)
-        self.Y_ax.setRange(*y_range)
-        self.Z_ax.setRange(*z_range)
+        """Set axis for the model with equal aspect ratio"""
+
+        # Calculate the overall range to ensure equal aspect ratio
+        x_min, x_max = x_range
+        y_min, y_max = y_range
+        z_min, z_max = z_range
+        x_center = (x_min + x_max) / 2
+        y_center = (y_min + y_max) / 2
+        z_center = (z_min + z_max) / 2
+        max_range = max(x_max - x_min, y_max - y_min, z_max - z_min)
+
+        # Add some padding
+        half_range = (max_range*1.1) / 2
+
+        # Set equal ranges for all axes centered on their respective centers
+        self.X_ax.setRange(x_center - half_range, x_center + half_range)
+        self.Y_ax.setRange(y_center - half_range, y_center + half_range)
+        self.Z_ax.setRange(z_center - half_range, z_center + half_range)
 
         self.scatter.setAxisX(self.X_ax)
         self.scatter.setAxisY(self.Y_ax)