# sas.qtgui.Perspectives.Fitting package

## Subpackages

- sas.qtgui.Perspectives.Fitting.UI package
  - Submodules
  - sas.qtgui.Perspectives.Fitting.UI.ComplexConstraintUI module
    - `Ui_ComplexConstraintUI`
      - `Ui_ComplexConstraintUI.retranslateUi()`
      - `Ui_ComplexConstraintUI.setupUi()`
  - sas.qtgui.Perspectives.Fitting.UI.ConstraintWidgetUI module
    - `Ui_ConstraintWidgetUI`
      - `Ui_ConstraintWidgetUI.retranslateUi()`
      - `Ui_ConstraintWidgetUI.setupUi()`
  - sas.qtgui.Perspectives.Fitting.UI.FittingOptionsUI module
    - `Ui_FittingOptions`
      - `Ui_FittingOptions.retranslateUi()`
      - `Ui_FittingOptions.setupUi()`
  - sas.qtgui.Perspectives.Fitting.UI.FittingWidgetUI module
    - `Ui_FittingWidgetUI`
      - `Ui_FittingWidgetUI.retranslateUi()`
      - `Ui_FittingWidgetUI.setupUi()`
  - sas.qtgui.Perspectives.Fitting.UI.GPUOptionsUI module
    - `Ui_GPUOptions`
      - `Ui_GPUOptions.retranslateUi()`
      - `Ui_GPUOptions.setupUi()`
  - sas.qtgui.Perspectives.Fitting.UI.GPUTestResultsUI module
    - `Ui_GPUTestResults`
      - `Ui_GPUTestResults.retranslateUi()`
      - `Ui_GPUTestResults.setupUi()`
  - sas.qtgui.Perspectives.Fitting.UI.MagnetismWidget module
    - `Ui_MagnetismWidgetUI`
      - `Ui_MagnetismWidgetUI.retranslateUi()`
      - `Ui_MagnetismWidgetUI.setupUi()`
  - sas.qtgui.Perspectives.Fitting.UI.MultiConstraintUI module
    - `Ui_MultiConstraintUI`
      - `Ui_MultiConstraintUI.retranslateUi()`
      - `Ui_MultiConstraintUI.setupUi()`
  - sas.qtgui.Perspectives.Fitting.UI.OptionsWidgetUI module
    - `Ui_tabOptions`
      - `Ui_tabOptions.retranslateUi()`
      - `Ui_tabOptions.setupUi()`
  - sas.qtgui.Perspectives.Fitting.UI.OrderWidgetUI module
    - `Ui_OrderWidgetUI`
      - `Ui_OrderWidgetUI.retranslateUi()`
      - `Ui_OrderWidgetUI.setupUi()`
  - sas.qtgui.Perspectives.Fitting.UI.PolydispersityWidget module
    - `Ui_PolydispersityWidgetUI`
      - `Ui_PolydispersityWidgetUI.retranslateUi()`
      - `Ui_PolydispersityWidgetUI.setupUi()`
  - sas.qtgui.Perspectives.Fitting.UI.SmearingWidgetUI module
    - `Ui_SmearingWidgetUI`
      - `Ui_SmearingWidgetUI.retranslateUi()`
      - `Ui_SmearingWidgetUI.setupUi()`
  - Module contents
- sas.qtgui.Perspectives.Fitting.plugin_models package
  - Submodules
  - sas.qtgui.Perspectives.Fitting.plugin_models.plugin_structure_template module
    - Definition
    - Validation
    - References
    - Authorship and Verification
    - `Iq()`
  - sas.qtgui.Perspectives.Fitting.plugin_models.plugin_template module
    - Definition
    - Validation
    - References
    - Authorship and Verification
    - `Iq()`
  - Module contents

## Submodules

## sas.qtgui.Perspectives.Fitting.AssociatedComboBox module

class sas.qtgui.Perspectives.Fitting.AssociatedComboBox.AssociatedComboBox(item: QStandardItem, idx_as_value: bool = False, parent: QWidget = None)

  Bases: `QComboBox`

  Just a regular combo box, but associated with a particular QStandardItem so that it can be used to display and select an item’s current text and a restricted list of other possible text.

  When the combo box’s current text is changed, the change is immediately reflected in the associated item; either the text itself is set as the item’s data, or the current index is used; see constructor.

  item: QStandardItem = None
  staticMetaObject = PySide6.QtCore.QMetaObject("AssociatedComboBox" inherits "QComboBox": )

## sas.qtgui.Perspectives.Fitting.ComplexConstraint module

Widget for multi-model constraints.

class sas.qtgui.Perspectives.Fitting.ComplexConstraint.ComplexConstraint(parent=None, tabs=None)

  Bases: `QDialog`, `Ui_ComplexConstraintUI`

  applyAcrossTabs(tabs, param, expr)

    Apply constraints across tabs, e.g. all scale parameters constrained to an expression. tabs is a list of active fit tabs for which the parameter string param will be constrained to the expr string.

  constraint()

    Return the generated constraint

  constraintIsRedefined(cons_tuple)

    Warn the user when a constraint is being redefined

  constraintReadySignal
  onApply()

    Respond to Add constraint action. Send a signal that the constraint is ready to be applied

  onHelp()

    Display related help section

  onModelIndexChange(index)

    Respond to mode combo box changes

  onOperatorChange(index)

    Respond to operator combo box changes

  onParamIndexChange(index)

    Respond to parameter combo box changes

  onSetAll()

    Set constraints on all identically named parameters between two fitpages

  setupData()

    Digs into self.tabs and pulls out relevant info

  setupMenu()
  setupParamWidgets()

    Fill out comboboxes and set labels with non-constrained parameters

  setupSignals()

    Signals from various elements

  setupTooltip()

    Tooltip for txtConstraint

  setupWidgets()

    Setup widgets based on current parameters

  staticMetaObject = PySide6.QtCore.QMetaObject("ComplexConstraint" inherits "QDialog": Methods: #41 type=Signal, signature=constraintReadySignal(PyObject), parameters=PyObject )
  validateConstraint(constraint_text)

    Ensure the constraint has proper form

  validateFormula()

    Add visual cues when formula is incorrect

## sas.qtgui.Perspectives.Fitting.ConsoleUpdate module

class sas.qtgui.Perspectives.Fitting.ConsoleUpdate.ConsoleUpdate(parent, manager=None, quiet=False, progress_delta=60, improvement_delta=5)

  Bases: `FitHandler`

  Print progress to the console.

  abort()
  error(msg)

    Model had an error; print traceback

  finalize()
  get_result()
  improvement()

    Called when a result is observed which is better than previous results from the fit.

  improvement_delta = 5

    Number of seconds between improvement updates

  isbetter = False

    Record whether results improved since last update

  print_result()

    Print result object

  progress(k, n)

    Report on progress.

  progress_delta = 60

    Number of seconds between progress updates

  set_result(result)
  stop(msg)

    Post event msg and stop

  update_fit(last=False)

## sas.qtgui.Perspectives.Fitting.Constraint module

class sas.qtgui.Perspectives.Fitting.Constraint.Constraint(parent=None, param=None, value=0.0, min=None, max=None, func=None, value_ex=None, operator='=')

  Bases: `object`

  Internal representation of a single parameter constraint Currently just a data structure, might get expanded with more functionality, hence made into a class.

  property func
  property max
  property min
  property model
  property operator
  property param
  property value
  property value_ex

## sas.qtgui.Perspectives.Fitting.ConstraintWidget module

class sas.qtgui.Perspectives.Fitting.ConstraintWidget.ConstraintWidget(parent=None)

  Bases: `QWidget`, `Ui_ConstraintWidgetUI`

  Constraints Dialog to select the desired parameter/model constraints.

  acceptsData()

    Tells the caller this widget doesn’t accept data

  batchComplete(result)

    Respond to the successful batch fit complete signal

  batchCompleteSignal
  createPageForParameters(parameters=None)

    Update the page with passed parameter values

  deleteConstraint()

    Delete all selected constraints.

  deselectConstraints()

    Selected constraints are removed for fitting

  deselectModels()

    Selected models are removed for fitting

  fitComplete(result)

    Respond to the successful fit complete signal

  fitCompleteSignal
  fitFailed(reason)

    Respond to fitting failure.

  fitFailedSignal
  getFitModel()

    Retrieves current model

  getFitPage()

    Retrieves the state of this page

  getObjectByName(name)

    Given name of the fit, returns associated fit object

  getReport()

    Wrapper for non-existent functionality. Tell the user to use the reporting tool on separate fit pages.

  getTabsForFit()

    Returns list of tab names selected for fitting

  initializeFitList(row=0, model_key='standard')

    Fill the list of model/data sets for fitting/constraining

  initializeSignals()

    Set up signals/slots for this widget

  initializeWidgets()

    Set up various widget states

  isTabImportable(tab)

    Determines if the tab can be imported and included in the widget

  onAcceptConstraint(con_tuple)

    Receive constraint tuple from the ComplexConstraint dialog and adds constraint. Checks the constraints for errors and displays a warning message interrupting flow if any are found

  onBatchFitComplete(result)

    Send the fit complete signal to main thread

  onChainFit(is_checked)

    Respond to selecting the Chain Fit checkbox

  onConstraintChange(row, column)

    Modify the constraint when the user edits the constraint list. If the user changes the constrained parameter, the constraint is erased and a new one is created. Checking is performed on the constrained entered by the user. In case of an error during checking, a warning message box is shown and the constraint is cancelled by reloading the view. View is also reloaded when the user is finished for consistency.

  onFit()

    Perform the constrained/simultaneous fit

  onFitComplete(result)

    Send the fit complete signal to main thread

  onFitFailed(reason)

    Send the fit failed signal to main thread

  onFitTypeChange(checked)

    Respond to the fit type change single fit/batch fit

  onHelp()

    Show the “Fitting” section of help

  onSpecialCaseChange(index)

    Respond to the combobox change for special case constraint sets

  onTabCellEdit(row, column)

    Respond to check/uncheck and to modify the model moniker and weighting actions

  onTabCellEntered(row, column)

    Remember the original tab list cell data. Needed for reverting back on bad validation

  onWeightModify(is_checked)

    Respond to selecting the Modify weighting checkbox

  orderedSublist(order_list, target_list)

    Orders the target_list such that any elements present in order_list show up first and in the order from order_list.

  selectConstraints()

    Selected constraints are chosen for fitting

  selectModels()

    Selected models are chosen for fitting

  selectedParameters(widget)

    Returns list of selected (highlighted) parameters

  setRowSelection(widget, status=CheckState.Unchecked)

    Selected models are chosen for fitting

  showConstrContextMenu(position)

    Show context specific menu in the tab table widget.

  showModelContextMenu(position)

    Show context specific menu in the tab table widget.

  showMultiConstraint()

    Invoke the complex constraint editor

  staticMetaObject = PySide6.QtCore.QMetaObject("ConstraintWidget" inherits "QWidget": Methods: #33 type=Signal, signature=fitCompleteSignal(PyObject), parameters=PyObject #34 type=Signal, signature=batchCompleteSignal(PyObject), parameters=PyObject #35 type=Signal, signature=fitFailedSignal(PyObject), parameters=PyObject )
  uncheckConstraint(name)

    Unchecks the constraint in tblConstraint with name slave parameter and deactivates the constraint.

  uneditableItem(data='')

    Returns an uneditable Table Widget Item

  updateFitLine(tab, model_key='standard')

    Update a single line of the table widget with tab info

  updateSignalsFromTab(tab=None)

    Intercept update signals from fitting tabs

  validateMoniker(new_moniker=None)

    Check new_moniker for correctness. It must be non-empty. It must not be the same as other monikers.

class sas.qtgui.Perspectives.Fitting.ConstraintWidget.DnDTableWidget(*args, **kwargs)

  Bases: `QTableWidget`

  dragEnterEvent(event)

    Called automatically on a drag in the TableWidget

  dragLeaveEvent(event)

    Called automatically on a drag stop

  dropEvent(event: QDropEvent)
  drop_on(event)
  isDragged()

    Return the drag status

  is_below(pos, index)
  staticMetaObject = PySide6.QtCore.QMetaObject("DnDTableWidget" inherits "QTableWidget": )

## sas.qtgui.Perspectives.Fitting.FitPage module

Container class for fitting widget state storage

class sas.qtgui.Perspectives.Fitting.FitPage.FitPage

  Bases: `object`

  Container for all data related to the current fit page

  LOG_POINTS = 4
  MAX_RANGE = 1
  MIN_RANGE = 0
  NPTS = 2
  NPTS_FIT = 3
  SMEARING_ACCURACY = 7
  SMEARING_MAX = 9
  SMEARING_MIN = 8
  SMEARING_OPTION = 6
  WEIGHTING = 5
  load(location)

    Retrieve serialized state from specified location

  save()

    Serialize the current state

  saveAsXML()

    Serialize the current state

## sas.qtgui.Perspectives.Fitting.FitThread module

class sas.qtgui.Perspectives.Fitting.FitThread.FitThread(fn, page_id, handler, batch_outputs, batch_inputs=None, pars=None, completefn=None, updatefn=None, yieldtime=0.03, worktime=0.03, reset_flag=False)

  Bases: `CalcThread`

  Thread performing the fit

  compute()

    Perform a fit

  isquit()
    Raises:

      KeyboardInterrupt – when the thread is interrupted

sas.qtgui.Perspectives.Fitting.FitThread.map_apply(arguments)

sas.qtgui.Perspectives.Fitting.FitThread.map_getattr(classInstance, classFunc, *args)

  Take an instance of a class and a function name as a string. Execute class.function and return result

## sas.qtgui.Perspectives.Fitting.FittingLogic module

class sas.qtgui.Perspectives.Fitting.FittingLogic.FittingLogic(data=None)

  Bases: `object`

  All the data-related logic. This class deals exclusively with Data1D/2D No QStandardModelIndex here.

  computeDataRange()

    Wrapper for calculating the data range based on local dataset

  computeRangeFromData(data)

    Compute the minimum and the maximum range of the data return the npts contains in data

  createDefault1dData(interval, tab_id=0)

    Create default data for fitting perspective Only when the page is on theory mode.

  createDefault2dData(qmax, qstep, tab_id=0)

    Create 2D data by default Only when the page is on theory mode.

  property data
  getScalarIntermediateResults(return_data)

    Returns a dict of scalar-only intermediate results from the return data.

  isLoadedData()

    accessor

  new1DPlot(return_data, tab_id)

    Create a new 1D data instance based on fitting results

  new1DProductPlots(return_data, tab_id)

    If return_data contains separated P(Q) and/or S(Q) data, create 1D plots for each and return as the tuple (pq_plot, sq_plot). If either are unavailable, the corresponding plot is None.

  new2DPlot(return_data)

    Create a new 2D data instance based on fitting results

  setDataProperties()

    Analyze data and set up some properties important for the Presentation layer

## sas.qtgui.Perspectives.Fitting.FittingOptions module

class sas.qtgui.Perspectives.Fitting.FittingOptions.FittingOptions(config=None)

  Bases: `PreferencesWidget`, `Ui_FittingOptions`

  Hard-coded version of the fit options dialog available from BUMPS. This should be make more “dynamic”. bumps.options.FIT_FIELDS gives mapping between parameter names, parameter strings and field type (double line edit, integer line edit, combo box etc.), e.g.:

      FIT_FIELDS = dict(
          samples = ("Samples", parse_int),
          xtol = ("x tolerance", float),
      )

  bumps.fitters.<algorithm>.settings gives mapping between algorithm, parameter name and default value, e.g.:

      >>> settings = [('steps', 1000), ('starts', 1), ('radius', 0.15), ('xtol', 1e-6), ('ftol', 1e-8)]

  addSignals()
  applyNonConfigValues()

    Applies values that aren’t stored in config. Only widgets that require this need to override this method.

  assignValidators()

    Use options.FIT_FIELDS to assert which line edit gets what validator

  check_state(*args, **kwargs)
  fit_option_changed
  getResults()

    Sends back the current choice of parameters

  name: str = 'Fit Optimizers'
  onAlgorithmChange(index)

    Triggered method when the index of the combo box changes.

  onDefaultAlgorithmChange()
  onHelp()

    Show the “Fitting options” section of help

  staticMetaObject = PySide6.QtCore.QMetaObject("FittingOptions" inherits "PreferencesWidget": Methods: #33 type=Signal, signature=fit_option_changed(QString), parameters=QString )
  updateWidgetFromBumps(fitter_id)

    Given the ID of the current optimizer, fetch the values and update the widget

  widgetFromOption(option_id, current_fitter=None)

    returns widget’s element linked to the given option_id

## sas.qtgui.Perspectives.Fitting.FittingPerspective module

class sas.qtgui.Perspectives.Fitting.FittingPerspective.FittingWindow(parent=None, data=None)

  Bases: `QTabWidget`, `Perspective`

  addClosedTab()

    Recover the deleted tab. The tab is held in self.lastTabClosed

  addConstraintTab()

    Add a new C&S fitting tab

  addFit(data, is_batch=False, tab_index=None)

    Add a new tab for passed data

  allowBatch()

    Tell the caller that we accept multiple data instances

  allowSwap()

    Tell the caller that you can swap data

  clipboard_copy()

    Called by copy menu item

  clipboard_paste()

    Called by paste menu item

  closeEvent(event)

    Overwrite QDialog close method to allow for custom widget close

  closeTabByIndex(index)

    Close/delete a tab with the given index. No checks on validity of the index.

  closeTabByName(tab_name)

    Given name of the fitting tab - close it

  property currentFittingWidget: FittingWidget | None
  property currentTab

    Returns the tab widget currently shown

  currentTabDataId()

    Returns the data ID of the current tab

  dataDeleted(index_list)

    Delete fit tabs referencing given data

  eventFilter(widget, event)
  excel_clipboard_copy()

    Called by copy excel menu item

  ext = 'fitv'
  fittingStartedSignal
  fittingStoppedSignal
  getActiveConstraintList()

    Returns a list of the constraints for all fitting tabs. Constraints are a tuple of strings (parameter, expression) e.g. (‘M1.scale’, ‘M2.scale + 2’)

  getCSTabName()

    Get the new tab name, based on the number of fitting tabs so far

  getConstraintTab()

    Returns the constraint tab, or None if no constraint tab is active

  getCurrentStateAsXml()

    Returns an XML version of the current state

  getFitTabs()

    Returns the list of fitting tabs

  getReport() → ReportData | None

    Get the report from the current tab

  getSerializedFitpage(tab)

    get serialize requested fit tab

  getSymbolDictForConstraints()

    Returns a dictionary containing all the symbols in all constrained tabs and their values.

  getTabByName(name)

    Returns the tab with with attribute name name

  getTabName(is_batch=False)

    Get the new tab name, based on the number of fitting tabs so far

  isSerializable()

    Tell the caller that this perspective writes its state

  latex_clipboard_copy()

    Called by copy latex menu item

  name = 'Fitting'
  nextAvailableTabIndex()

    Returns the index of the next available tab

  onFittingOptionsChange(fit_engine)

    React to the fitting algorithm change by modifying window title

  onFittingStarted(tabs_for_fitting=None)

    Notify tabs listed in tabs_for_fitting that the fitting thread started

  onFittingStopped(tabs_for_fitting=None)

    Notify tabs listed in tabs_for_fitting that the fitting thread stopped

  property preferences

    Return a list of widgets that should be added to the preferences panel.

  resetTab(index)

    Adds a new tab and removes the last tab as a way of resetting the fit tabs

  save_parameters()

    Save parameters to a file

  serializeAll()
  serializeAllFitpage()
  serializeCurrentPage()
  setClosable(value=True)

    Allow outsiders to close this widget

  setData(data_item=None, is_batch=False, tab_index=None)

    Assign new dataset to the fitting instance Obtain a QStandardItem object and dissect it to get Data1D/2D Pass it over to the calculator

  staticMetaObject = PySide6.QtCore.QMetaObject("FittingWindow" inherits "QTabWidget": Methods: #39 type=Signal, signature=tabsModifiedSignal() #40 type=Signal, signature=fittingStartedSignal(QVariantList), parameters=QVariantList #41 type=Signal, signature=fittingStoppedSignal(QVariantList), parameters=QVariantList )
  property supports_copy: bool

    Does this perspective support copy functionality?

  property supports_copy_excel: bool

    Does this perspective support copy functionality?

  property supports_copy_latex: bool

    Does this perspective support copy functionality?

  property supports_fitting_menu: bool

    Should the fitting menu be shown when using this perspective (unless its Fitting, probably not)

  property supports_paste: bool

    Does this perspective allow pasting?

  property supports_reports: bool

    Does this perspective have a report functionality (currently used by menus and toolbar)

  swapData(data)

    Replace the data from the current fitting tab

  tabCloses(index)

    Update local bookkeeping on tab close

  tabsModifiedSignal
  property title

    Window title

  updateFitDict(item_key, tab_name)

    Create a list if none exists and append if there’s already a list

  updateFromConstraints(constraint_dict)

    Updates all tabs with constraints present in constraint_dict, where constraint_dict keys are the fit page name, and the value is a list of constraints. A constraint is represented by a list [value, param, value_ex, validate, function] of attributes of a Constraint object

  updateFromParameters(parameters)

    Pass the update parameters to the current fit page

  updateWindowTitle()

    Update the window title with the current optimizer name

## sas.qtgui.Perspectives.Fitting.FittingUtilities module

class sas.qtgui.Perspectives.Fitting.FittingUtilities.ToolTippedItemModel(parent=None)

  Bases: `QStandardItemModel`

  Subclass from QStandardItemModel to allow displaying tooltips in QTableView model.

  headerData(section, orientation, role=ItemDataRole.DisplayRole)

    Displays tooltip for each column’s header :param section: :param orientation: :param role: :return:

  staticMetaObject = PySide6.QtCore.QMetaObject("ToolTippedItemModel" inherits "QStandardItemModel": )

sas.qtgui.Perspectives.Fitting.FittingUtilities.addCheckedListToModel(model, param_list)

  Add a QItem to model. Makes the QItem checkable

sas.qtgui.Perspectives.Fitting.FittingUtilities.addErrorHeadersToModel(model)

  Adds predefined headers to the model

sas.qtgui.Perspectives.Fitting.FittingUtilities.addErrorPolyHeadersToModel(model)

  Adds predefined headers to the model

sas.qtgui.Perspectives.Fitting.FittingUtilities.addHeadersToModel(model)

  Adds predefined headers to the model

sas.qtgui.Perspectives.Fitting.FittingUtilities.addHeadingRowToModel(model, name)

  adds a non-interactive top-level row to the model

sas.qtgui.Perspectives.Fitting.FittingUtilities.addParametersToModel(parameters, kernel_module, is2D, model=None, view=None)

  Update local ModelModel with sasmodel parameters. Actually appends to model, if model and view params are not None. Always returns list of lists of QStandardItems.

sas.qtgui.Perspectives.Fitting.FittingUtilities.addPolyHeadersToModel(model)

  Adds predefined headers to the model

sas.qtgui.Perspectives.Fitting.FittingUtilities.addShellsToModel(parameters, model, index, row_num=None, view=None)

  Find out multishell parameters and update the model with the requested number of them. Inserts them after the row at row_num, if not None; otherwise, appends to end. If view param is not None, supports fixed-choice params. Returns a list of lists of QStandardItem objects.

sas.qtgui.Perspectives.Fitting.FittingUtilities.addSimpleParametersToModel(parameters, is2D, parameters_original=None, model=None, view=None, row_num=None)

  Update local ModelModel with sasmodel parameters (non-dispersed, non-magnetic) Actually appends to model, if model and view params are not None. Always returns list of lists of QStandardItems.

  parameters_original: list of parameters before any tagging on their IDs, e.g. for product model (so that those are the display names; see below)

sas.qtgui.Perspectives.Fitting.FittingUtilities.binary_encode(i, digits)

sas.qtgui.Perspectives.Fitting.FittingUtilities.calcWeightIncrease(weights, ratios, flag=False)
  Calculate the weights to be passed to bumps in order to ensure

    that each data set contributes to the total residual with a relative weight roughly proportional to the ratios defined by the user when the “Modify weighting” option is employed.

    The influence of each data set in the global fit is approximately proportional to the number of points and to (1/sigma^2), or probably better to (1/relative_error^2) = (intensity/sigma)^2.

    Therefore in order to try to give equal weights to each data set in the global fitting, we can compute the total relative weight of each data set as the sum (y_i/dy_i**2) over all the points in the data set and then renormalize them using:

    user_weight[dataset] * sqrt(min(relative_weights) / relative_weights[dataset])

    If all user weights are one (the default), this will decrease the weight of the data sets initially contributing more to the global fit, while keeping the weight of the initially smaller contributor equal to one.

    These weights are stored for each data set (FitPage) in a dictionary that will be then used by bumps to modify the weights of each set.

    Warning: As bumps uses the data set weights to multiply the residuals calculated as (y-f(x))/sigma, it would probably make sense to include the value of user_weight[dataset] in the square root, but as in any case this is just a qualitative way of increasing/decreasing the weight of some datasets and there is not a real mathematical justification behind, this provides a more intuitive behaviour for the user, who will see that the final weights of the data sets vary proportionally to changes in the input user weights.

  Parameters:

    - weights (dict of numpy.ndarray) – Dictionary of data for the statistical weight, typical the y axis error

    - ratios (dict) – Desired relative statistical weight ratio between the different datasets.

    - flag (bool) – Boolean indicating if the weight of the datasets should be modified or not, which depends on the “Modify weighting” box in the Simultaneous Fit tab being checked or not

  Returns:

    Weight multiplier for each dataset

  Return type:

    dict

sas.qtgui.Perspectives.Fitting.FittingUtilities.calculateChi2(reference_data, current_data, weight)

  Calculate Chi2 value between two sets of data

sas.qtgui.Perspectives.Fitting.FittingUtilities.checkConstraints(symtab: dict[str, float], constraints: Sequence[tuple[str, str]]) → str

  Compile and evaluate the constraints in the context of the initial values and return the list of errors.

  Errors are returned as an html string where errors are tagged with <b> markups: Unknown symbol: tags unknown symbols in constraints Syntax error: tags the beginning of a syntax error in constraints Cyclic dependency: tags comma separated parameters that have cyclic dependency

  The errors are wrapped in a <div class = “error”> and a style header is added

sas.qtgui.Perspectives.Fitting.FittingUtilities.createFixedChoiceComboBox(param, item_row)

  Determines whether param is a fixed-choice parameter, modifies items in item_row appropriately and returns a combo box containing the fixed choices. Returns None if param is not fixed-choice.

  item_row is a list of QStandardItem objects for insertion into the parameter table.

sas.qtgui.Perspectives.Fitting.FittingUtilities.formatParameters(parameters: list, entry_sep=',', line_sep=':')

  Prepare the parameter string in the standard SasView layout

sas.qtgui.Perspectives.Fitting.FittingUtilities.formatParametersExcel(parameters: list)

  Prepare the parameter string in the Excel format (tab delimited)

sas.qtgui.Perspectives.Fitting.FittingUtilities.formatParametersLatex(parameters: list)

  Prepare the parameter string in latex

sas.qtgui.Perspectives.Fitting.FittingUtilities.getIterParams(model)

  Returns a list of all multi-shell parameters in ‘model’

sas.qtgui.Perspectives.Fitting.FittingUtilities.getMultiplicity(model)

  Finds out if ‘model’ has multishell parameters. If so, returns the name of the counter parameter and the number of shells

sas.qtgui.Perspectives.Fitting.FittingUtilities.getOrientationParam(kernel_module=None)

  Get the dictionary with orientation parameters

sas.qtgui.Perspectives.Fitting.FittingUtilities.getRelativeError(data, is2d, flag=None)

  Return dy/y.

sas.qtgui.Perspectives.Fitting.FittingUtilities.getStandardParam(model=None)

  Returns a list with standard parameters for the current model

sas.qtgui.Perspectives.Fitting.FittingUtilities.getWeight(data, is2d, flag=None)

  Received flag and compute error on data. :param flag: flag to transform error of data.

sas.qtgui.Perspectives.Fitting.FittingUtilities.isNumber(s)

  Checks if string ‘s’ is an int/float

sas.qtgui.Perspectives.Fitting.FittingUtilities.isParamPolydisperse(param_name, kernel_params, is2D=False)

  Simple lookup for polydispersity for the given param name

sas.qtgui.Perspectives.Fitting.FittingUtilities.markParameterDisabled(model, row)

  Given the QModel row number, format to show it is not available for fitting

sas.qtgui.Perspectives.Fitting.FittingUtilities.plotPolydispersities(model)

sas.qtgui.Perspectives.Fitting.FittingUtilities.plotResiduals(reference_data, current_data, weights)

  Create Data1D/Data2D with residuals, ready for plotting

sas.qtgui.Perspectives.Fitting.FittingUtilities.replaceShellName(param_name, value)

  Updates parameter name from <param_name>[n_shell] to <param_name>value

sas.qtgui.Perspectives.Fitting.FittingUtilities.residualsData1D(reference_data, current_data, weights)

  Calculate the residuals for difference of two Data1D sets

sas.qtgui.Perspectives.Fitting.FittingUtilities.residualsData2D(reference_data, current_data, weight)

  Calculate the residuals for difference of two Data2D sets

sas.qtgui.Perspectives.Fitting.FittingUtilities.setTableProperties(table)

  Setting table properties

sas.qtgui.Perspectives.Fitting.FittingUtilities.updateKernelWithResults(kernel, results)

  Takes model kernel and applies results dict to its parameters, returning the modified (deep) copy of the kernel.

## sas.qtgui.Perspectives.Fitting.FittingWidget module

class sas.qtgui.Perspectives.Fitting.FittingWidget.FittingWidget(parent: QWidget | None = None, data: Any | None = None, tab_id: int = 1)

  Bases: `QWidget`, `Ui_FittingWidgetUI`

  Main widget for selecting form and structure factor models

  Calc1DFinishedSignal
  Calc2DFinishedSignal
  MAGNETIC_MODELS = ['sphere', 'core_shell_sphere', 'core_multi_shell', 'cylinder', 'parallelepiped']
  SASModelToQModel(model_name: str | None, structure_factor: str | None = None) → None

    Setting model parameters into table based on selected category

  acceptsData() → bool

    Tells the caller this widget can accept new dataset

  addBackgroundToModel(model: QStandardItemModel) → None

    Adds background parameter with default values to the model

  addConstraintToRow(constraint: Constraint | None = None, row: int = 0, model_key: str = 'standard') → None

    Adds the constraint object to requested row. The constraint is first checked for errors, and a message box interrupting flow is displayed, with the reason of the failure.

  addExtraShells() → None

    Add a combobox for multiple shell display

  addScaleToModel(model: QStandardItemModel) → None

    Adds scale parameter with default values to the model

  addSimpleConstraint() → None

    Adds a constraint on a single parameter.

  addWeightingToData(data: Data1D | Data2D) → Data1D | Data2D

    Adds weighting contribution to fitting data

  allParamNames() → list[str]

    Returns a list of all parameter names defined on the current model

  batchFitComplete(result: tuple) → None

    Receive and display batch fitting results

  batchFittingCompleted(result: tuple | None) → None

    Send the finish message from calculate threads to main thread

  batchFittingFinishedSignal
  calcException(etype: Any, value: Any, tb: Any) → None

    Thread threw an exception.

  calculateDataFailed(reason: Any) → None

    Thread returned error

  calculateQGridForModel() → None

    Prepare the fitting data object, based on current ModelModel

  calculateQGridForModelExt(data: Data1D | Data2D | None = None, model: Any | None = None, completefn: Any | None = None, use_threads: bool = True) → None

    Wrapper for Calc1D/2D calls

  calculateResiduals(fitted_data: Data1D | Data2D) → Data1D | Data2D | None

    Calculate and print Chi2 and display chart of residuals. Returns residuals plot object.

  canHaveMagnetism() → bool

    Checks if the current model has magnetic scattering implemented

  changeCheckboxStatus(row: int, checkbox_status: bool, model_key: str = 'standard') → None

    Checks/unchecks the checkbox at given row

  checkboxSelected(item: QStandardItem, model_key: str = 'standard') → None
  checkedListFromModel(model_key: str) → list[str]

    Returns list of checked parameters for given model

  clipboard_copy() → None
  clipboard_copy_excel() → None
  clipboard_copy_latex() → None
  clipboard_paste() → None

    Use the clipboard to update fit state

  complete1D(return_data: dict) → None

    Plot the current 1D data

  complete2D(return_data: dict) → None

    Plot the current 2D data

  completed1D(return_data: dict) → None
  completed2D(return_data: dict) → None
  constraintAddedSignal
  createDefaultDataset() → None

    Generate default Dataset 1D/2D for the given model

  createNewIndex(fitted_data: Data1D | Data2D) → None

    Create a model or theory index with passed Data1D/Data2D

  createPageForParameters(line_dict: dict[str, list[str]]) → None

    Sets up page with requested model/str factor and fills it up with sent parameters

  createTheoryIndex(fitted_data: Data1D | Data2D) → None

    Create a QStandardModelIndex containing model data

  currentState() → FitPage

    Return fit page with current state

  classmethod customModels() → dict[str, Any]

    Reads in file names in the custom plugin directory

  property data: Data1D | Data2D
  dataFromItems(value: QStandardItem | list[QStandardItem]) → None

    data setter

  deleteConstraint() → None

    Delete constraints from selected parameters.

  deleteConstraintOnParameter(param: str | None = None, model_key: str = 'standard') → None

    Delete the constraint on model parameter ‘param’

  deselectParameters() → None

    Selected parameters are removed for fitting

  disableBackgroundParameter(set_value: float | None = None) → None

    Disable the background parameter. Optionally set at a specified value.

  disableInteractiveElements() → None

    Set button caption on fitting/calculate start Disable the param table(s)

  disableInteractiveElementsOnCalculate() → None

    Set button caption on fitting/calculate start Disable the param table(s)

  disableModelCombo() → None

    Disable the combobox

  disableStructureCombo() → None

    Disable the combobox

  editConstraint() → None

    Edit constraints for selected parameters.

  enableBackgroundParameter(set_value: float | None = None) → None

    Enable the background parameter. Optionally set at a specified value.

  enableInteractiveElements() → None

    Set button caption on fitting/calculate finish Enable the param table(s)

  enableModelCombo() → None

    Enable the combobox

  enableStructureCombo() → None

    Enable the combobox

  enableStructureFactorControl(structure_factor: str | None) → None

    Add structure factors to the list of parameters

  eventFilter(obj: QObject, event: QEvent) → bool
  excel_copy_data() → str

    Excel format data destined for the clipboard

  fitComplete(result: tuple) → None

    Receive and display fitting results “result” is a tuple of actual result list and the fit time in seconds

  fitFailed(reason: Any) → None
  fittingCompleted(result: tuple | None) → None

    Send the finish message from calculate threads to main thread

  fittingFinishedSignal
  fromModelToQModel(model_name: str) → None

    Setting model parameters into QStandardItemModel based on selected model

  fromStructureFactorToQModel(structure_factor: str) → None

    Setting model parameters into QStandardItemModel based on selected structure factor

  full_copy_data() → str

    Data destined for the clipboard when copy clicked

  getComplexConstraintsForAllModels() → list[tuple[str, str]]

    Returns a list of tuples containing all the constraints defined for a given FitPage

  getComplexConstraintsForModel(model_key: str) → list[tuple[str, str]]

    Return a list of tuples. Each tuple contains constraints mapped as (‘constrained parameter’, ‘function to constrain’) e.g. [(‘sld’,’5*M2.sld_solvent’)]. Only for constraints with defined VALUE

  getConstraintForRow(row: int, model_key: str = 'standard') → Constraint | None

    For the given row, return its constraint, if any (otherwise None)

  getConstraintObjectsForAllModels() → list[Constraint]

    Returns a list of the constraint object for a given FitPage

  getConstraintObjectsForModel(model_key: str) → list[Constraint]

    Returns Constraint objects present on the whole model

  getConstraintsForAllModels() → list[tuple[str, str]]

    Return a list of tuples. Each tuple contains constraints mapped as (‘constrained parameter’, ‘function to constrain’) e.g. [(‘sld’,’5*sld_solvent’)]

  getConstraintsForFitting() → list[tuple[str, str]]

    Return a list of constraints in format ready for use in fiting

  getCurrentFitState(state: Any | None = None) → None

    Store current state for fit_page

  getFitModel() → list[list[str]]

    serializes combobox state

  getFitPage() → list[list[str]]

    serializes full state of this fit page

  getFitParameters() → list[list[str | tuple]]

    serializes current parameters

  getFullConstraintNameListForModel(model_key: str) → list[tuple[str, str]]

    Return a list of tuples. Each tuple contains constraints mapped as (‘constrained parameter’, ‘function to constrain’) e.g. [(‘sld’,’5*M2.sld_solvent’)]. Returns a list of all constraints, not only active ones

  getHelpLocation(tree_base: Path) → Path
  getModelKey(constraint: Constraint) → str | None

    Given parameter name get the model index.

  getModelKeyFromName(name: str) → str

    Given parameter name, get the model index.

  getParamNames() → list[str]

    Return list of all active parameters for the current model

  getParamNamesMagnet() → list[str]

    Return list of magnetic parameters for the current model

  getParamNamesMain() → list[str]

    Return list of main parameters for the current model

  getParameterDict() → dict[str, list[str]]

    Gather current fitting parameters as dict

  getReport() → list[str]

    Create and return HTML report with parameters and charts

  getRowFromName(name: str) → int | None

    Given parameter name, get the row number in a model. The model is the main _model_model by default

  getSymbolDict() → dict[str, float]

    Return a dict containing a list of all the symbols used for fitting and their values, e.g. {‘M1.scale’:1, ‘M1.background’: 0.001}

  haveParamsToFit() → bool

    Finds out if there are any parameters ready to be fitted

  info(type: Any, value: Any, tb: Any) → None
  initializeCategoryCombo() → None

    Model category combo setup

  initializeControls() → None

    Set initial control enablement

  initializeGlobals() → None

    Initialize global variables used in this class

  initializeModels() → None

    Set up models and views

  initializeSignals() → None

    Connect GUI element signals

  initializeWidgets() → None

    Initialize widgets for tabs

  isCheckable(row: int, model_key: str = 'standard') → bool
  isConstraintMultimodel(constraint: str) → bool

    Check if the constraint function text contains current model name

  iterateOverModel(func: Any) → None

    Take func and throw it inside the model row loop

  keyPressEvent(event: QKeyEvent) → None
  keyPressedSignal
  latex_copy_data() → str

    Latex format data destined for the clipboard

  loadAnalysisFile() → str

    Called when the “Open Project” menu item chosen.

  loadPageState(pagestate: Any | None = None) → None

    Load the PageState object and update the current widget

  loadPageStateCallback(state: Any | None = None, datainfo: Any | None = None, format: Any | None = None) → None

    This is a callback method called from the CANSAS reader. We need the instance of this reader only for writing out a file, so there’s nothing here. Until Load Analysis is implemented, that is.

  property logic: FittingLogic
  methodCalculateForData() → Any

    return the method for data calculation

  methodCompleteForData() → Any

    return the method for result parsin on calc complete

  modelContextMenu(rows: list[int]) → QMenu

    Create context menu for the parameter selection

  modelName() → str

    Returns model name, by default M<tab#>, e.g. M1, M2

  modifyShellsInList(text: str) → None

    Add/remove additional multishell parameters

  modifyViewOnRow(row: int, font: QFont | None = None, brush: QBrush | None = None, model_key: str = 'standard') → None

    Change how the given row of the main model is shown

  nameForFittedData(name: str) → str

    Generate name for the current fit

  nameFromData(fitted_data: Data1D | Data2D) → str

    Return name for the dataset. Terribly impure function.

  newModelSignal
  onCategoriesChanged() → None

    Reload the category/model comboboxes

  onColumnWidthUpdate(index: int, old_size: int, new_size: int) → None

    Simple state update of the current column widths in the param list

  onCustomModelChange() → None

    Reload the custom model combobox

  onFit() → None

    Perform fitting on the current data

  onHelp()

    Show the “Fitting” section of help

  onKey(event: QKeyEvent) → None
  onMainParamsChange(top: QModelIndex, bottom: QModelIndex) → None

    Callback method for updating the sasmodel parameters with the GUI values

  onMaskedData() → None

    A mask has been applied to current data. Update the Q ranges.

  onOptionsUpdate() → None

    Update local option values and replot

  onPlot() → None

    Plot the current set of data

  onSelectBatchFilename(data_index: int) → None

    Update the logic based on the selected file in batch fitting

  onSelectCategory() → None

    Select Category from list

  onSelectModel() → None

    Respond to select Model from list event

  onSelectStructureFactor() → None

    Select Structure Factor from list

  onSelectionChanged() → None

    React to parameter selection

  onSesansData() → None

    Updates the fitting widget format when SESANS data is loaded.

  onShowSLDProfile() → None

    Show a quick plot of SLD profile

  onSmearingOptionsUpdate() → None

    React to changes in the smearing widget

  paramDictFromResults(results: Any) → dict[str, tuple[float, float]] | None

    Given the fit results structure, pull out optimized parameters and return them as nicely formatted dict

  paramHasConstraint(param: str | None = None) → bool

    Finds out if the given parameter in all the models has a constraint child

  popFitPage() → None

    Remove top fit page from stack

  prepareFitters(fitter: BumpsFit | None = None, fit_id: int = 0, weight_increase: int = 1) → tuple[list[BumpsFit], int]

    Prepare the Fitter object for use in fitting

  processEffectiveRadius() → None

    Checks the value of radius_effective_mode, if existent, and processes radius_effective as necessary. * mode == 0: This means ‘unconstrained’; ensure use can specify ER. * mode > 0: This means it is constrained to a P(Q)-computed value in sasmodels; prevent user from editing ER.

    Note: If ER has been computed, it is passed back to SasView as an intermediate result. That value must be displayed for the user; that is not dealt with here, but in complete1D.

  pushFitPage(new_page: FitPage) → None

    Add a new fit page object with current state

  readCategoryInfo() → None

    Reads the categories in from file

  readCustomCategoryInfo() → None

    Reads the custom model category

  readFitPage(fp: FitPage) → None

    Read in state from a fitpage object and update GUI

  recalculatePlotData() → None

    Generate a new dataset for model

  regenerateModelDict() → None

    Regenerates self.by_model_dict which has each model name as the key and the list of categories belonging to that model along with the enabled mapping

  replaceConstraintName(old_name: str, new_name: str = '') → None

    Replace names of models in defined constraints

  resetParametersToFit() → None

    Clears the list of parameters to be fitted

  respondToModelStructure(model: str | None = None, structure_factor: str | None = None) → None
  rowHasActiveComplexConstraint(row: int, model_key: str = 'standard') → bool

    Finds out if row of the main model has an active, nontrivial constraint child

  rowHasActiveConstraint(row: int, model_key: str = 'standard') → bool

    Finds out if row of the main model has an active constraint child

  rowHasConstraint(row: int, model_key: str = 'standard') → bool

    Finds out if row of the main model has a constraint child

  saveToFitPage(fp: FitPage) → None

    Write current state to the given fitpage

  save_parameters() → None

    Save parameters to a file

  selectParameters() → None

    Selected parameter is chosen for fitting

  selectedParameters(model_key: str = 'standard') → list[int]

    Returns list of selected (highlighted) parameters

  setDefaultStructureCombo() → None

    Fill in the structure factors combo box with defaults

  setEnablementOnDataLoad() → None

    Enable/disable various UI elements based on data loaded

  setInteractiveElements(enabled: bool = True) → None

    Switch interactive GUI elements on/off

  setParamEditableByRow(row: int, editable: bool = True) → None

    Sets whether the user can edit a parameter in the table. If they cannot, the parameter name’s font is changed, the value itself cannot be edited if clicked on, and the parameter may not be fitted.

  setParameterSelection(status: CheckState = CheckState.Unchecked, item: QStandardItem | None = None, model_key: str = 'standard') → None

    Selected parameters are chosen for fitting

  setTheoryItem(item: Any) → None

    Reset the theory item based on the data explorer update

  set_clipboard(data: str) → None

    Set the data in the clipboard

  shellNamesList() → list[str]

    Returns list of names of all multi-shell parameters E.g. for sld[n], radius[n], n=1..3 it will return [sld1, sld2, sld3, radius1, radius2, radius3]

  showModelContextMenu(position: QPoint) → None

    Show context specific menu in the parameter table. When clicked on parameter(s): fitting/constraints options When clicked on white space: model description

  showModelDescription() → QMenu

    Creates a window with model description, when right-clicked in the treeview

  showMultiConstraint(current_list: QTreeView | None = None) → None

    Show the constraint widget and receive the expression

  showPlot() → None

    Show the current plot in MPL

  showTheoryPlot() → None

    Show the current theory plot in MPL

  staticMetaObject = PySide6.QtCore.QMetaObject("FittingWidget" inherits "QWidget": Methods: #33 type=Signal, signature=constraintAddedSignal(QVariantList,QString), parameters=QVariantList, QString #34 type=Signal, signature=newModelSignal() #35 type=Signal, signature=fittingFinishedSignal(PyObject), parameters=PyObject #36 type=Signal, signature=batchFittingFinishedSignal(PyObject), parameters=PyObject #37 type=Signal, signature=Calc1DFinishedSignal(QVariantMap), parameters=QVariantMap #38 type=Signal, signature=Calc2DFinishedSignal(QVariantMap), parameters=QVariantMap #39 type=Signal, signature=keyPressedSignal(QEvent*), parameters=QEvent* )
  stopFit() → None

    Attempt to stop the fitting thread

  toggle2D(isChecked: bool) → None

    Enable/disable the controls dependent on 1D/2D data instance

  toggleChainFit(isChecked: bool) → None

    Enable/disable chain fitting

  toggleMagnetism(isChecked: bool) → None

    Enable/disable the magnetism tab

  togglePoly(isChecked: bool) → None

    Enable/disable the polydispersity tab

  updateData() → None

    Helper function for recalculation of data used in plotting

  updateEffectiveRadius(return_data: dict) → None

    Given return data from sasmodels, update the effective radius parameter in the GUI table with the new calculated value as returned by sasmodels (if the value was returned).

  updateFit() → None
  updateFullModel(param_dict: dict[str, list[str]]) → None

    Update the model with new parameters

  updateFunctionCaption(row)
  updateKernelModelWithExtraParams(model: Any | None = None) → None

    Updates kernel model ‘model’ with extra parameters from the polydisp and magnetism tab, if the tabs are enabled

  updateModelFromList(param_dict: dict[str, tuple[float, float]]) → None

    Update the model with new parameters, create the errors column

  updateModelIndex(fitted_data: Data1D | Data2D) → None

    Update a QStandardModelIndex containing model data

  updateMultiplicityCombo(multip: int) → None

    Find and update the multiplicity combobox

  updatePageWithParameters(line_dict: dict[str, list[str]], warn_user: bool = True) → None

    Update FitPage with parameters in line_dict

  updateQRange() → None

    Updates Q Range display

  updateUndo() → None

    Create a new state page and add it to the stack

sas.qtgui.Perspectives.Fitting.FittingWidget.get_weights(self: Any, name: str) → tuple[ndarray, ndarray]

  Returns the polydispersity distribution for parameter name as value and weight arrays.

## sas.qtgui.Perspectives.Fitting.GPUOptions module

class sas.qtgui.Perspectives.Fitting.GPUOptions.GPUOptions

  Bases: `PreferencesWidget`, `Ui_GPUOptions`

  OpenCL Dialog to select the desired OpenCL driver

  accept()

    Close the window after modifying the SAS_OPENCL value

  add_options()

    Populate the window with a list of OpenCL options

  applyNonConfigValues()

    Applies values that aren’t stored in config. Only widgets that require this need to override this method.

  cl_options = None
  closeEvent(event)

    Overwrite QDialog close method to allow for custom widget close

  get_sas_open_cl()

    Set SAS_OPENCL value when tests run or OK button clicked

  helpButtonClicked()

    Open the help menu when the help button is clicked

  name: str = 'GPU Options'
  reject()

    Close the window without modifying SAS_OPENCL

  set_sas_open_cl()
  staticMetaObject = PySide6.QtCore.QMetaObject("GPUOptions" inherits "PreferencesWidget": Methods: #33 type=Signal, signature=testingDoneSignal(QString), parameters=QString #34 type=Signal, signature=testingFailedSignal(QString), parameters=QString )
  testButtonClicked()

    Run sasmodels check from here and report results from

  testComplete(msg)

    Testing done: send signal to main thread with update

  testCompleted(msg)

    Respond to successful test completion

  testFail(msg)

    Testing failed: log the reason

  testFailed(msg)

    Testing failed: log the reason

  testThread(no_opencl_msg)

    Testing in another thread

  testingDoneSignal
  testingFailedSignal
  updateCounter(step)

    Update progress bar with current value

class sas.qtgui.Perspectives.Fitting.GPUOptions.GPUTestResults(parent, msg)

  Bases: `QDialog`, `Ui_GPUTestResults`

  OpenCL Dialog to modify the OpenCL options

  staticMetaObject = PySide6.QtCore.QMetaObject("GPUTestResults" inherits "QDialog": )

## sas.qtgui.Perspectives.Fitting.MagnetismWidget module

Widget/logic for magnetism.

class sas.qtgui.Perspectives.Fitting.MagnetismWidget.MagnetismWidget(parent: QWidget | None = None, logic: Any | None = None)

  Bases: `QWidget`, `Ui_MagnetismWidgetUI`

  addCheckedMagneticListToModel(param: Any, value: float) → None

    Wrapper for model update with a subset of magnetic parameters

  cmdFitSignal
  gatherMagnetParams(row)

    Create list of magnetic parameters based on _magnet_model

  getParamNamesMagnet() → list[str]

    Return list of magnetic parameters for the current model

  iterateOverMagnetModel(func: Any) → None

    Take func and throw it inside the magnet model row loop

  iterateOverModelSignal
  onDisplayMagneticAngles() → None

    Display a simple image showing direction of magnetic angles

  onMagnetModelChange(top: QModelIndex, bottom: QModelIndex) → None

    Callback method for updating the sasmodel magnetic parameters with the GUI values

  setMagneticModel() → None

    Set magnetism values on model

  staticMetaObject = PySide6.QtCore.QMetaObject("MagnetismWidget" inherits "QWidget": Methods: #33 type=Signal, signature=cmdFitSignal() #34 type=Signal, signature=updateDataSignal() #35 type=Signal, signature=iterateOverModelSignal() )
  updateDataSignal
  updateFullMagnetModel(param_dict: dict[str, list[str]]) → None

    Update the magnetism model with new parameters, create the errors column

  updateMagnetModelFromList(param_dict: dict[str, tuple[float, float]]) → None

    Update the magnetic model with new parameters, create the errors column

  updateModel(model: Any | None = None) → None

## sas.qtgui.Perspectives.Fitting.ModelThread module

Calculation thread for modeling

class sas.qtgui.Perspectives.Fitting.ModelThread.Calc1D(model, page_id, data, fid=None, qmin=None, qmax=None, weight=None, smearer=None, toggle_mode_on=False, state=None, completefn=None, update_chisqr=True, source='model', updatefn=None, yieldtime=0.01, worktime=0.01, exception_handler=None)

  Bases: `CalcThread`

  Compute 1D data

  compute()

    Compute model 1d value given qmin , qmax , x value

  results()

    Send resuts of the computation

class sas.qtgui.Perspectives.Fitting.ModelThread.Calc2D(data, model, smearer, qmin, qmax, page_id, state=None, weight=None, fid=None, toggle_mode_on=False, completefn=None, updatefn=None, update_chisqr=True, source='model', yieldtime=0.04, worktime=0.04, exception_handler=None)

  Bases: `CalcThread`

  Compute 2D model This calculation assumes a 2-fold symmetry of the model where points are computed for one half of the detector and I(qx, qy) = I(-qx, -qy) is assumed.

  compute()

    Compute the data given a model function

## sas.qtgui.Perspectives.Fitting.MultiConstraint module

Widget for parameter constraints.

class sas.qtgui.Perspectives.Fitting.MultiConstraint.MultiConstraint(parent=None, params=None, constraint=None)

  Bases: `QDialog`, `Ui_MultiConstraintUI`

  Logic class for interacting with MultiConstrainedUI view

  onHelp()

    Display related help section

  revert()

    Swap parameters in the view

  setupLabels()

    Setup labels based on current parameters

  setupTooltip()

    Tooltip for txtConstraint

  staticMetaObject = PySide6.QtCore.QMetaObject("MultiConstraint" inherits "QDialog": )
  validateConstraint(constraint_text)

    Ensure the constraint has proper form

  validateFormula()

    Add visual cues when formula is incorrect

## sas.qtgui.Perspectives.Fitting.OptionsWidget module

Widget/logic for smearing data.

class sas.qtgui.Perspectives.Fitting.OptionsWidget.DataWidgetMapper

  Bases: `QDataWidgetMapper`

  Custom version of the standard QDataWidgetMapper allowing for proper response to index change in comboboxes

  addMapping(widget, section, propertyName=None)
  staticMetaObject = PySide6.QtCore.QMetaObject("DataWidgetMapper" inherits "QDataWidgetMapper": )

class sas.qtgui.Perspectives.Fitting.OptionsWidget.OptionsWidget(parent=None, logic=None)

  Bases: `QWidget`, `Ui_tabOptions`

  MODEL = ['MIN_RANGE', 'MAX_RANGE', 'NPTS', 'NPTS_FIT']
  NPTS_DEFAULT = 150
  QMAX_DEFAULT = 0.5
  QMIN_DEFAULT = 0.0005
  initMapper()

    Initialize model item <-> UI element mapping

  initModel()

    Initialize the state

  npts2fit(data=None, qmin=None, qmax=None, npts=None)

    return numbers of data points within qrange :Note: This is to normalize chisq by Npts of fit

  onMaskEdit()

    Callback for running the mask editor

  onModelChange(top, bottom)

    Respond to model change by updating the plot

  onRangeReset()

    Callback for resetting qmin/qmax

  onWeightingChoice(button)

    Update weighting in the fit state

  plot_signal
  setEnablementOnDataLoad()

    Enable/disable various UI elements based on data loaded

  setLogScale(log_scale)
  state()

    Returns current state of controls

  staticMetaObject = PySide6.QtCore.QMetaObject("OptionsWidget" inherits "QWidget": Methods: #33 type=Signal, signature=plot_signal() )
  toggleLogData(isChecked)

    Toggles between log and linear data sets

  updateMaxQ(q_max=None)
  updateMinQ(q_min=None)
  updateQRange(q_range_min, q_range_max, npts)

    Update the local model based on calculated values

## sas.qtgui.Perspectives.Fitting.OrderWidget module

Widget/logic for dataset ordering.

class sas.qtgui.Perspectives.Fitting.OrderWidget.OrderWidget(parent=None, all_data=None)

  Bases: `QWidget`, `Ui_OrderWidgetUI`

  ordering()

    Returns the current ordering of the datasets

  setupTable()

    Populate the widget with dataset names in original order

  staticMetaObject = PySide6.QtCore.QMetaObject("OrderWidget" inherits "QWidget": )
  updateData(all_data)

    Read in new datasets and update the view

## sas.qtgui.Perspectives.Fitting.PolydispersityWidget module

Widget/logic for polydispersity.

class sas.qtgui.Perspectives.Fitting.PolydispersityWidget.PolydispersityWidget(parent: QWidget | None = None)

  Bases: `QWidget`, `Ui_PolydispersityWidgetUI`

  addNameToPolyModel(param_name: str) → None

    Creates a checked row in the poly model with param_name

  checkedListFromModel() → list[str]

    Returns list of checked parameters for given model

  cmdFitSignal
  gatherPolyParams(row: int) → list[list[str]]

    Create list of polydisperse parameters based on _poly_model

  getParamNamesPoly() → list[str]

    Return list of polydisperse parameters for the current model

  iterateOverModelSignal
  iterateOverPolyModel(func: Any) → None

    Take func and throw it inside the poly model row loop

  loadPolydispArray(row_index: int) → None

    Show the load file dialog and loads requested data into state

  onPolyComboIndexChange(combo_string: str, row_index: int) → None

    Modify polydisp. defaults on function choice

  onPolyFilenameChange(row_index: int) → None

    Respond to filename_updated signal from the delegate

  onPolyModelChange(top: QModelIndex) → None

    Callback method for updating the main model and sasmodel parameters with the GUI values in the polydispersity view

  polyModel() → ToolTippedItemModel

    Return the polydispersity model

  static polyNameToParam(param_name: str) → str

    Translate polydisperse QTable representation into parameter name

  resetParameters() → None

    Reset polydispersity parameters

  setPolyModel() → None

    Set polydispersity values

  setPolyModelParameters(i: int, param: Any) → None

    Standard of multishell poly parameter driver

  staticMetaObject = PySide6.QtCore.QMetaObject("PolydispersityWidget" inherits "QWidget": Methods: #33 type=Signal, signature=cmdFitSignal() #34 type=Signal, signature=updateDataSignal() #35 type=Signal, signature=iterateOverModelSignal() )
  togglePoly(isChecked: bool = True) → None

    Toggle polydispersity

  updateDataSignal
  updateFullPolyModel(param_dict: dict[str, list[str]]) → None

    Update the polydispersity model with new parameters, create the errors column

  updateModel(model: Any | None = None) → None
  updatePolyModelFromList(param_dict: dict[str, tuple[float, float]]) → None

    Update the polydispersity model with new parameters, create the errors column

## sas.qtgui.Perspectives.Fitting.ReportPageLogic module

class sas.qtgui.Perspectives.Fitting.ReportPageLogic.ReportPageLogic(parent=None, kernel_module=None, data=None, index=None, params=None)

  Bases: `object`

  Logic for the Report Page functionality. Refactored from FittingWidget.

  buildPlotsForReport(images)

    Convert Matplotlib figure ‘fig’ into a <img> tag for HTML use using base64 encoding.

  getImages() → list[PlotterBase]

    Create MPL figures for the current fit

  reportHeader()

    Look at widget state and extract report header info

  reportList() → ReportData

    Return the HTML version of the full report

  reportParams()

    Look at widget state and extract parameters

## sas.qtgui.Perspectives.Fitting.SmearingWidget module

Widget/logic for smearing data.

class sas.qtgui.Perspectives.Fitting.SmearingWidget.DataWidgetMapper

  Bases: `QDataWidgetMapper`

  Custom version of the standard QDataWidgetMapper allowing for proper response to index change in comboboxes

  addMapping(widget, section, propertyName=None)
  staticMetaObject = PySide6.QtCore.QMetaObject("DataWidgetMapper" inherits "QDataWidgetMapper": )

class sas.qtgui.Perspectives.Fitting.SmearingWidget.SmearingWidget(parent=None)

  Bases: `QWidget`, `Ui_SmearingWidgetUI`

  initMapper()

    Initialize model item <-> UI element mapping

  initModel()

    Initialize the state

  onDQSmear()

    Create a custom dQ smear object that will change the way residuals are compute when fitting

  onIndexChange(index)

    Callback for smearing combobox index change

  onModelChange()

    Respond to model change by notifying any listeners

  onPinholeSmear()

    Create a custom pinhole smear object that will change the way residuals are compute when fitting

  onSlitSmear()

    Create a custom slit smear object that will change the way residuals are compute when fitting

  resetSmearer()
  setAccuracyVisibility()

    Accuracy combobox visibility

  setDQLabels()

    Use appropriate labels

  setElementsVisibility(visible)

    Labels and linedits visibility control

  setPinholeLabels()

    Use pinhole labels

  setSlitLabels()

    Use pinhole labels

  setSmearInfo()

    Set default smear_type, dq_l, and dq_r based on the q-resolution information found in the data.

  setState(smearing, accuracy, d_down, d_up)

    Sets new values for the controls

  smearer()

    Returns the current smearer

  smearingChangedSignal
  state()

    Returns current state of controls

  staticMetaObject = PySide6.QtCore.QMetaObject("SmearingWidget" inherits "QWidget": Methods: #33 type=Signal, signature=smearingChangedSignal() )
  updateData(data=None)

    Update control elements based on data and model passed

  updateKernelModel(kernel_model=None, keep_order=False, old_index=None)

    Update the model

## sas.qtgui.Perspectives.Fitting.ViewDelegate module

class sas.qtgui.Perspectives.Fitting.ViewDelegate.MagnetismViewDelegate(parent=None)

  Bases: `QStyledItemDelegate`

  Custom delegate for appearance and behavior control of the magnetism view

  addErrorColumn()

    Modify local column pointers Note: the reverse is never required!

  createEditor(widget, option, index)
  editableParameters()
  paint(painter, option, index)

    Overwrite generic painter for certain columns

  staticMetaObject = PySide6.QtCore.QMetaObject("MagnetismViewDelegate" inherits "QStyledItemDelegate": )

class sas.qtgui.Perspectives.Fitting.ViewDelegate.ModelViewDelegate(parent=None)

  Bases: `QStyledItemDelegate`

  Custom delegate for appearance and behavior control of the model view

  addErrorColumn()

    Modify local column pointers Note: the reverse is never required!

  createEditor(widget, option, index)

    Overwrite generic editor for certain columns

  fancyColumns()
  paint(painter, option, index)

    Overwrite generic painter for certain columns

  setModelData(editor, model, index)

    Overwrite generic model update method for certain columns

  staticMetaObject = PySide6.QtCore.QMetaObject("ModelViewDelegate" inherits "QStyledItemDelegate": )

class sas.qtgui.Perspectives.Fitting.ViewDelegate.PolyViewDelegate(parent=None)

  Bases: `QStyledItemDelegate`

  Custom delegate for appearance and behavior control of the polydispersity view

  POLYDISPERSE_FUNCTIONS = ['rectangle', 'array', 'lognormal', 'gaussian', 'schulz']
  addErrorColumn()

    Modify local column pointers Note: the reverse is never required!

  columnDict()
  combo_updated
  createEditor(widget, option, index)
  editableParameters()
  filename_updated
  paint(painter, option, index)

    Overwrite generic painter for certain columns

  staticMetaObject = PySide6.QtCore.QMetaObject("PolyViewDelegate" inherits "QStyledItemDelegate": Methods: #9 type=Signal, signature=combo_updated(QString,int), parameters=QString, int #10 type=Signal, signature=filename_updated(int), parameters=int )

## Module contents