sas.qtgui.Perspectives.Fitting package

Subpackages

Submodules

sas.qtgui.Perspectives.Fitting.AssociatedComboBox module

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

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.

__annotations__ = {}
__doc__ = "Just a regular combo box, but associated with a particular QStandardItem so that it can be used to display and\n    select an item's current text and a restricted list of other possible text.\n\n    When the combo box's current text is changed, the change is immediately reflected in the associated item; either\n    the text itself is set as the item's data, or the current index is used; see constructor."
__init__(item: QStandardItem, idx_as_value: bool = False, parent: QWidget = None) None[source]

Initialize widget. idx_as_value indicates whether to use the combo box’s current index (otherwise, current text) as the associated item’s new data.

__module__ = 'sas.qtgui.Perspectives.Fitting.AssociatedComboBox'
_onIndexChanged(idx: int) None[source]

Callback for combo box’s currentIndexChanged. Set associated item’s data to the new index.

_onTextChanged(text: str) None[source]

Callback for combo box’s currentTextChanged. Set associated item’s data to the new text.

item: QStandardItem = None

sas.qtgui.Perspectives.Fitting.ComplexConstraint module

sas.qtgui.Perspectives.Fitting.ConsoleUpdate module

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

Bases: FitHandler

Print progress to the console.

__doc__ = '\n    Print progress to the console.\n    '
__init__(parent, manager=None, quiet=False, progress_delta=60, improvement_delta=5)[source]

If quiet is true, only print out final summary, not progress and improvements.

Attr parent:

the object that handle the messages

__module__ = 'sas.qtgui.Perspectives.Fitting.ConsoleUpdate'
abort()[source]
error(msg)[source]

Model had an error; print traceback

finalize()[source]
get_result()[source]
improvement()[source]

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()[source]

Print result object

progress(k, n)[source]

Report on progress.

progress_delta = 60

Number of seconds between progress updates

set_result(result)[source]
stop(msg)[source]

Post event msg and stop

update_fit(last=False)[source]

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='=')[source]

Bases: object

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

__dict__ = mappingproxy({'__module__': 'sas.qtgui.Perspectives.Fitting.Constraint', '__doc__': '\n    Internal representation of a single parameter constraint\n    Currently just a data structure, might get expaned with more functionality,\n    hence made into a class.\n    ', '__init__': <function Constraint.__init__>, 'value': <property object>, 'value_ex': <property object>, 'param': <property object>, 'func': <property object>, 'min': <property object>, 'max': <property object>, 'operator': <property object>, '__dict__': <attribute '__dict__' of 'Constraint' objects>, '__weakref__': <attribute '__weakref__' of 'Constraint' objects>, '__annotations__': {}})
__doc__ = '\n    Internal representation of a single parameter constraint\n    Currently just a data structure, might get expaned with more functionality,\n    hence made into a class.\n    '
__init__(parent=None, param=None, value=0.0, min=None, max=None, func=None, value_ex=None, operator='=')[source]
__module__ = 'sas.qtgui.Perspectives.Fitting.Constraint'
__weakref__

list of weak references to the object

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

sas.qtgui.Perspectives.Fitting.ConstraintWidget module

sas.qtgui.Perspectives.Fitting.FitPage module

Container class for fitting widget state storage

class sas.qtgui.Perspectives.Fitting.FitPage.FitPage[source]

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
__dict__ = mappingproxy({'__module__': 'sas.qtgui.Perspectives.Fitting.FitPage', '__doc__': '\n    Container for all data related to the current fit page\n    ', 'MIN_RANGE': 0, 'MAX_RANGE': 1, 'NPTS': 2, 'NPTS_FIT': 3, 'LOG_POINTS': 4, 'WEIGHTING': 5, 'SMEARING_OPTION': 6, 'SMEARING_ACCURACY': 7, 'SMEARING_MIN': 8, 'SMEARING_MAX': 9, '__init__': <function FitPage.__init__>, 'save': <function FitPage.save>, 'load': <function FitPage.load>, 'saveAsXML': <function FitPage.saveAsXML>, '__dict__': <attribute '__dict__' of 'FitPage' objects>, '__weakref__': <attribute '__weakref__' of 'FitPage' objects>, '__annotations__': {}})
__doc__ = '\n    Container for all data related to the current fit page\n    '
__init__()[source]

Define the dictionary

__module__ = 'sas.qtgui.Perspectives.Fitting.FitPage'
__weakref__

list of weak references to the object

load(location)[source]

Retrieve serialized state from specified location

save()[source]

Serialize the current state

saveAsXML()[source]

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)[source]

Bases: CalcThread

Thread performing the fit

__doc__ = 'Thread performing the fit '
__init__(fn, page_id, handler, batch_outputs, batch_inputs=None, pars=None, completefn=None, updatefn=None, yieldtime=0.03, worktime=0.03, reset_flag=False)[source]

Prepare the calculator

__module__ = 'sas.qtgui.Perspectives.Fitting.FitThread'
compute()[source]

Perform a fit

isquit()[source]
Raises:

KeyboardInterrupt – when the thread is interrupted

sas.qtgui.Perspectives.Fitting.FitThread.map_apply(arguments)[source]
sas.qtgui.Perspectives.Fitting.FitThread.map_getattr(classInstance, classFunc, *args)[source]

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)[source]

Bases: object

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

__dict__ = mappingproxy({'__module__': 'sas.qtgui.Perspectives.Fitting.FittingLogic', '__doc__': '\n    All the data-related logic. This class deals exclusively with Data1D/2D\n    No QStandardModelIndex here.\n    ', '__init__': <function FittingLogic.__init__>, 'data': <property object>, 'isLoadedData': <function FittingLogic.isLoadedData>, 'setDataProperties': <function FittingLogic.setDataProperties>, 'createDefault1dData': <function FittingLogic.createDefault1dData>, 'createDefault2dData': <function FittingLogic.createDefault2dData>, '_create1DPlot': <function FittingLogic._create1DPlot>, 'new1DPlot': <function FittingLogic.new1DPlot>, 'new2DPlot': <function FittingLogic.new2DPlot>, 'new1DProductPlots': <function FittingLogic.new1DProductPlots>, 'getScalarIntermediateResults': <function FittingLogic.getScalarIntermediateResults>, 'computeDataRange': <function FittingLogic.computeDataRange>, 'computeRangeFromData': <function FittingLogic.computeRangeFromData>, '__dict__': <attribute '__dict__' of 'FittingLogic' objects>, '__weakref__': <attribute '__weakref__' of 'FittingLogic' objects>, '__annotations__': {}})
__doc__ = '\n    All the data-related logic. This class deals exclusively with Data1D/2D\n    No QStandardModelIndex here.\n    '
__init__(data=None)[source]
__module__ = 'sas.qtgui.Perspectives.Fitting.FittingLogic'
__weakref__

list of weak references to the object

_create1DPlot(tab_id, x, y, model, data, component=None)[source]

For internal use: create a new 1D data instance based on fitting results. ‘component’ is a string indicating the model component, e.g. “P(Q)”

computeDataRange()[source]

Wrapper for calculating the data range based on local dataset

computeRangeFromData(data)[source]

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

createDefault1dData(interval, tab_id=0)[source]

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

createDefault2dData(qmax, qstep, tab_id=0)[source]

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

property data
getScalarIntermediateResults(return_data)[source]

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

isLoadedData()[source]

accessor

new1DPlot(return_data, tab_id)[source]

Create a new 1D data instance based on fitting results

new1DProductPlots(return_data, tab_id)[source]

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)[source]

Create a new 2D data instance based on fitting results

setDataProperties()[source]

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

sas.qtgui.Perspectives.Fitting.FittingOptions module

sas.qtgui.Perspectives.Fitting.FittingPerspective module

sas.qtgui.Perspectives.Fitting.FittingUtilities module

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

Add a QItem to model. Makes the QItem checkable

sas.qtgui.Perspectives.Fitting.FittingUtilities.addErrorHeadersToModel(model)[source]

Adds predefined headers to the model

sas.qtgui.Perspectives.Fitting.FittingUtilities.addErrorPolyHeadersToModel(model)[source]

Adds predefined headers to the model

sas.qtgui.Perspectives.Fitting.FittingUtilities.addHeadersToModel(model)[source]

Adds predefined headers to the model

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

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

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

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)[source]

Adds predefined headers to the model

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

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)[source]

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)[source]
sas.qtgui.Perspectives.Fitting.FittingUtilities.calculateChi2(reference_data, current_data, weight)[source]

Calculate Chi2 value between two sets of data

sas.qtgui.Perspectives.Fitting.FittingUtilities.checkConstraints(symtab: Dict[str, float], constraints: Sequence[Tuple[str, str]]) str[source]

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)[source]

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, Check=True)[source]

Prepare the parameter string in the standard SasView layout

sas.qtgui.Perspectives.Fitting.FittingUtilities.formatParametersExcel(parameters)[source]

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

sas.qtgui.Perspectives.Fitting.FittingUtilities.formatParametersLatex(parameters)[source]

Prepare the parameter string in latex

sas.qtgui.Perspectives.Fitting.FittingUtilities.getIterParams(model)[source]

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

sas.qtgui.Perspectives.Fitting.FittingUtilities.getMultiplicity(model)[source]

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)[source]

Get the dictionary with orientation parameters

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

Returns a list with standard parameters for the current model

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

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

sas.qtgui.Perspectives.Fitting.FittingUtilities.isNumber(s)[source]

Checks if string ‘s’ is an int/float

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

Simple lookup for polydispersity for the given param name

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

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

sas.qtgui.Perspectives.Fitting.FittingUtilities.plotPolydispersities(model)[source]
sas.qtgui.Perspectives.Fitting.FittingUtilities.plotResiduals(reference_data, current_data, weights)[source]

Create Data1D/Data2D with residuals, ready for plotting

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

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

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

Calculate the residuals for difference of two Data1D sets

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

Calculate the residuals for difference of two Data2D sets

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

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

sas.qtgui.Perspectives.Fitting.FittingWidget module

sas.qtgui.Perspectives.Fitting.GPUOptions module

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)[source]

Bases: CalcThread

Compute 1D data

__annotations__ = {}
__doc__ = '\n    Compute 1D data\n    '
__init__(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)[source]
__module__ = 'sas.qtgui.Perspectives.Fitting.ModelThread'
compute()[source]

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

results()[source]

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)[source]

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.

__annotations__ = {}
__doc__ = '\n    Compute 2D model\n    This calculation assumes a 2-fold symmetry of the model\n    where points are computed for one half of the detector\n    and I(qx, qy) = I(-qx, -qy) is assumed.\n    '
__init__(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)[source]

Prepare the calculator

__module__ = 'sas.qtgui.Perspectives.Fitting.ModelThread'
compute()[source]

Compute the data given a model function

sas.qtgui.Perspectives.Fitting.MultiConstraint module

sas.qtgui.Perspectives.Fitting.OptionsWidget module

sas.qtgui.Perspectives.Fitting.OrderWidget module

sas.qtgui.Perspectives.Fitting.ReportPageLogic module

sas.qtgui.Perspectives.Fitting.SmearingWidget module

sas.qtgui.Perspectives.Fitting.ViewDelegate module

Module contents