Python scripting interface for the Fittable fitting widget.
Access via: f = Fittable

f = Fittable
 
f.configure("Guinier", ["table_I"])
chi2 = f.fit()
 
r = f.results()
print(r["Rg"])      # (value, error)

f = Fittable
 
f.configure("Guinier", ["table_I1", "table_I2", "table_I3"])
 
f.setParamShared("Rg", True)
f.setParamLimits("Rg", 1.0, 500.0)
f.setFitMethod("LM")
 
chi2 = f.fit()
print(f.results())
print(f.fitReport())

The API has two phases separated by function selection:

1. Pre-function — instrument, dataset count, fit algorithm options
2. Function selection — configure() or setFunction()
3. Post-function — datasets, range, weighting, resolution, polydispersity, parameters

The widget has five stages reflecting the current UI page:

print(f.stage())    # e.g. "fit"

Navigates to the named stage using the widget's own page-transition logic.

f.selectStage("fit")          # go to fitting page
f.selectStage("simulate")     # go to Simulate Curve tab
f.selectStage("results")      # go to Generate Tables tab
f.selectStage("batch-fit")    # go to Batch-Fit tab
f.selectStage("init")         # go back to function-selection page

• Returns True on success, False if already in init and s == “init”.
• Raises RuntimeError if called from init stage with any target other than init.
• Raises ValueError for unknown stage names.

s = f.state()

Returns a dict:

f.fitFunctions()             # all available functions
f.fitFunctions("*sphere*")   # wildcard filter (case-insensitive)
f.fitFunctions("Guinier*")   # prefix match
f.fitFunctions("*SANS*")     # substring match

Returns sorted list of function names. Wildcards: * matches any substring including /.

name = f.currentFunction()

Resets to init stage, then runs the full mandatory sequence setDatasetCount → setFunction → selectDataset in one call.

f.configure("Guinier")                              # single dataset (select manually after)
f.configure("Guinier", ["table_I"])                 # single dataset
f.configure("Guinier", ["table_I1", "table_I2"])    # multi-dataset global fit

• Raises ValueError if the function or any dataset name is not found.
• Safe to call from any stage — always starts fresh.

f.setDatasetCount(3)            # MUST come before setFunction
f.setFunction("Guinier")        # raises ValueError if not found
f.selectDataset(1, "table_I1")  # 1-indexed; raises ValueError if not found
f.selectDataset(2, "table_I2")
f.selectDataset(3, "table_I3")

f.setWeightingMethod(0)        # use error bars (default)
f.setWeightingMethod(4)
f.setWeightingA(2.0)           # exponent a for methods 4–6
f.setWeightingB(1.0)           # parameter b for method 5
f.setWeightingC(1.0)           # parameter c for methods 5–6
f.setWeightingXmax(0.3)        # Xmax for method 6
 
f.setWeightingEnabled(1, True)         # enable weighting for dataset 1
f.setWeightingDataset(1, "table_dI")   # σ column for dataset 1

All dataset arguments are 1-indexed (1 = first dataset).
For setParamValue and setParamVaries, dataset=-1 (default) applies to all datasets.
For limits, dataset=-1 means the global (shared) limit.

names  = f.paramNames()          # list of parameter names
n      = f.paramCount()          # number of parameters
 
val    = f.paramValue("Rg")          # value, dataset 1
val2   = f.paramValue("Rg", 2)       # value, dataset 2
err    = f.paramError("Rg")          # fit error (NaN if fixed or not yet fitted)
varies = f.paramVaries("Rg")         # True if free parameter
shared = f.paramShared("Rg")         # True if shared across datasets
 
lL  = f.paramLimitLeft("Rg")         # global left limit
lR  = f.paramLimitRight("Rg")        # global right limit
lL2 = f.paramLimitLeft("Rg", 1)      # local left limit for dataset 1
bay = f.paramBayesian("Rg")          # True if Bayesian prior active

f.setParamValue("Rg", 50.0)           # set value, all datasets (default)
f.setParamValue("Rg", 50.0, 2)        # set value, dataset 2 only
f.setParamVaries("bgd", False)         # fix parameter, all datasets (default)
f.setParamVaries("bgd", False, 1)      # fix parameter, dataset 1 only
f.setParamShared("Rg", True)           # share across datasets (global fit)
 
# bulk setters — values list ordered as paramNames()
f.setParamValueAll([50.0, 0.001, 1.0])        # set all param values, all datasets
f.setParamValueAll([50.0, 0.001, 1.0], 2)     # set all param values, dataset 2 only
f.setParamVariesAll([True, False, True])       # set varies for all params, all datasets
f.setParamVariesAll([True, False, True], 1)   # set varies for all params, dataset 1 only
 
# global limits
f.setParamLimits("Rg", 1.0, 500.0)
 
# global Bayesian prior
f.setParamLimits("Rg", 45.0, 55.0, bayesianYN=True)
 
# local limits for dataset 1 only
f.setParamLimits("Rg", 1.0, 500.0, dataset=1)
 
# local Bayesian for dataset 2
f.setParamLimits("bgd", 0.0, 0.01, bayesianYN=True, dataset=2)

fit(), simulate(), plotResults(), beforeFit() and afterFit() raise RuntimeError if stage is not “fit”.
simulateCurve() raises RuntimeError if stage is not “simulate”.

After simulate(), fit curve tables are created in the workspace named fitCurve-<function>
(single dataset) or fitCurve-<function>-global-N (dataset N of a global fit), with columns x and y.

Always plots into layer 1 (data scatter + fit line).
If the MultiLayer has a second layer and radioButtonSameQrange is checked, residuals (scatter) are added to layer 2 and the X axes are linked.
Existing curves are never duplicated — repeated calls are safe.

# plain new graph
f.plotResults("FitResults")
 
# graph styled from templates/graph.qpt
f.plotResults("FitResults", "graph")
 
# re-running is safe: existing curves are kept, missing ones are added
f.fit()
f.plotResults("FitResults", "graph")

simulateCurve() corresponds to the Simulate Curve tab; call selectStage(“simulate”) first.

Two modes: uniform X (generates a new X grid) and dataset (uses X values of an existing dataset and returns Chi²/DoF).

simulateCurve() returns Chi²/DoF in dataset mode; returns NaN in uniform X mode.

f.selectStage("simulate")
 
# uniform X: generate model curve over a custom range
f.setSimUniformX(True)
f.setSimFromX(0.005)
f.setSimToX(0.5)
f.setSimNumPoints(200)
f.setSimLogStep(True)
f.simulateCurve()
 
# dataset mode: simulate and compare to existing data
f.setSimUniformX(False)
f.setSimDataset("table_I")
chi2 = f.simulateCurve()
print(f"simulation Chi²/DoF = {chi2:.4f}")

chi2 = f.lastChi2    # Chi²/DoF from last fit
dof  = f.lastDoF     # degrees of freedom

r = f.results()

• Single dataset: { name: (value, error), … } — error is None for fixed parameters.
• Multi-dataset: { name: [(v1, e1), (v2, e2), …], … }

# single dataset
rg_val, rg_err = r["Rg"]
if rg_err is None:
    print("Rg is fixed")
 
# multi-dataset
for m, (v, e) in enumerate(r["Rg"], start=1):
    print(f"DS{m}: Rg = {v:.3f} ± {e:.3f}")

print(f.fitReport())

Returns the full fit statistics and covariance matrix as a formatted string.
Fittable.lastFitReport holds the same string as a plain attribute.

When a name is not found, available names are printed to the script console before raising.

f = Fittable
 
# pre-function: instrument (must come before configure)
f.setInstrumentalFit(True)
f.setInstrument("SANS")    # "SANS" or "Back-Scattering"
 
# configure: resets to init, loads function, selects dataset
f.configure("sphere_SANS", ["table_I"])
 
# resolution for dataset 1
f.setResoFunction("Gauss-SANS")
f.setResoSpeedControl(3)
f.setResoEnabled(1, True)
f.setResoDataset(1, "table_sigma")
 
# parameters
f.setParamValue("R", 50.0)
f.setParamLimits("R", 1.0, 1000.0)
f.setParamVaries("bgd", False)
 
# fit
chi2 = f.fit()
print(f"Chi²/DoF = {chi2:.4f}")
print(f.results())

f = Fittable
f.configure("Guinier", ["table_I"])
 
f.setFitMethod("Simplex")
f.setMaxIterations(500)
chi2 = f.fit()
 
if chi2 > 10.0:
    f.setFitMethod("LM")
    chi2 = f.fit()
 
if chi2 > 10.0:
    f.setFitMethod("GenMin")
    f.setGenMinGenerations(200)
    chi2 = f.fit()
 
print(f"Final Chi²/DoF = {chi2:.4f}")
r = f.results()
for name in f.paramNames():
    v, e = r[name]
    if e is not None:
        print(f"  {name:12s} = {v:.5E} ± {e:.2E}")
    else:
        print(f"  {name:12s} = {v:.5E}  (fixed)")

f = Fittable
f.configure("Guinier", ["table_I1", "table_I2", "table_I3"])
 
# Rg shared across all datasets, I0 fitted independently
f.setParamShared("Rg", True)
f.setParamLimits("Rg", 1.0, 500.0)
 
chi2 = f.fit()
r = f.results()
 
rg_val, rg_err = r["Rg"][0]
print(f"Rg = {rg_val:.3f} ± {rg_err:.3f}")
 
for m, (v, e) in enumerate(r["I0"], start=1):
    print(f"I0[DS{m}] = {v:.4E} ± {e:.2E}")

f = Fittable
f.configure("Guinier", ["table_I"])
chi2 = f.fit()
print(f"fit Chi²/DoF = {chi2:.4f}")
 
# plot with template; layer 1 = data+fit, layer 2 = residuals (if present)
f.plotResults("FitResults", "graph")
 
# navigate to Simulate Curve tab and run simulation on custom X grid
f.selectStage("simulate")
f.setSimUniformX(True)
f.setSimFromX(0.001)
f.setSimToX(1.0)
f.setSimNumPoints(500)
f.setSimLogStep(True)
f.simulateCurve()

datasets = ["sample1_I", "sample2_I", "sample3_I"]
results  = []
 
f = Fittable
for ds in datasets:
    f.configure("Guinier", [ds])
    f.setParamLimits("Rg", 1.0, 500.0)
    chi2 = f.fit()
    r    = f.results()
    rg_v, rg_e = r["Rg"]
    i0_v, i0_e = r["I0"]
    results.append((ds, chi2, rg_v, rg_e, i0_v, i0_e))
 
t = newTable("FitSummary", len(results), 6)
t.setColNames(["dataset", "chi2", "Rg", "dRg", "I0", "dI0"])
t.setColumnRole(1, Table.Label)
for row, (ds, chi2, rg_v, rg_e, i0_v, i0_e) in enumerate(results, start=1):
    t.setText(1, row, ds)
    t.setCell(2, row, chi2)
    t.setCell(3, row, rg_v)
    t.setCell(4, row, rg_e)
    t.setCell(5, row, i0_v)
    t.setCell(6, row, i0_e)

f = Fittable
f.configure("sphere_SANS", ["table_I"])
 
f.setParamValue("R", 40.0)
f.setParamValue("bgd", 0.001)
f.setParamVaries("bgd", True)
 
# broad exploration with Simplex
f.setFitMethod("Simplex")
f.setMaxIterations(2000)
f.fit()
 
# precise refinement with LM
f.setFitMethod("LM")
chi2 = f.fit()
print(f"R = {f.paramValue('R'):.2f} ± {f.paramError('R'):.2f}")
print(f"Chi²/DoF = {chi2:.4f}")

f = Fittable
f.configure("PowerLaw", ["table_I"])
 
# fit only the crossover range
f.setRange(1, 0.02, 0.15)
 
# weight by error bars from table_dI
f.setWeightingMethod(0)
f.setWeightingEnabled(1, True)
f.setWeightingDataset(1, "table_dI")
 
chi2 = f.fit()
f.plotResults("PowerLaw_fit", "graph")
print(f.results())

f = Fittable
f.configure("Guinier", ["ds1_I", "ds2_I", "ds3_I"])
 
f.setParamShared("Rg", True)              # Rg common to all datasets
f.setParamLimits("Rg", 1.0, 300.0)
 
chi2 = f.fit()
r    = f.results()
 
print(f"Shared Rg = {r['Rg'][0][0]:.3f} ± {r['Rg'][0][1]:.3f}")
print()
for m in range(1, f.datasetCount() + 1):
    v, e = r["I0"][m - 1]
    print(f"  DS{m}  I0 = {v:.4E} ± {e:.2E}")
 
f.plotResults("GlobalFit", "graph")

f = Fittable
f.configure("Guinier", ["table_I"])
 
# load saved parameter values from the UI table into the solver
f.beforeFit()
 
chi2 = f.fit()
 
# write fitted values back into the UI parameter table
f.afterFit()
 
print(f.fitReport())

import numpy as np
 
f = Fittable
f.configure("Guinier", ["table_I"])
f.setParamVaries("Rg", False)   # hold Rg fixed at each probe point
 
chi2_list = []
rg_values = np.linspace(10.0, 200.0, 20)
 
for rg in rg_values:
    f.setParamValue("Rg", float(rg))
    chi2 = f.fit()
    chi2_list.append(chi2)
 
# store in a table for plotting
t = newTable("RgScan", len(rg_values), 2)
t.setColNames(["Rg", "chi2"])
t.setColumnRole(1, Table.X)
t.setColumnRole(2, Table.Y)
for i, (rg, chi2) in enumerate(zip(rg_values, chi2_list), start=1):
    t.setCell(1, i, float(rg))
    t.setCell(2, i, chi2)