DMSC Integration Testing

Test: scipp-analysis|estia|analyze_reduced_data|fit_model_success

2025-11-02 00:16:28: error

load_data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])

@pytest.fixture(scope="module")
def fit_model(load_data):
data = load_data
# Rescale data
reflectivity = data["data"]["R_0"].values
scale_factor = 1 / np.max(reflectivity)
data["data"]["R_0"].values *= scale_factor

# Create a model for the sample

si = Material(sld=2.07, isld=0.0, name="Si")
sio2 = Material(sld=3.47, isld=0.0, name="SiO2")
d2o = Material(sld=6.33, isld=0.0, name="D2O")
dlipids = Material(sld=5.0, isld=0.0, name="DLipids")

superphase = Layer(material=si, thickness=0, roughness=0, name="Si superphase")
sio2_layer = Layer(material=sio2, thickness=20, roughness=4, name="SiO2 layer")
dlipids_layer = Layer(
material=dlipids, thickness=40, roughness=4, name="DLipids layer"
)
subphase = Layer(material=d2o, thickness=0, roughness=5, name="D2O subphase")

multi_sample = Sample(
Multilayer(superphase),
Multilayer(sio2_layer),
Multilayer(dlipids_layer),
Multilayer(subphase),
name="Multilayer Structure",
)

multi_layer_model = Model(
sample=multi_sample,
scale=1,
background=0.000001,
resolution_function=PercentageFwhm(0),
name="Multilayer Model",
)

# Set the fitting parameters

sio2_layer.roughness.bounds = (3, 12)
sio2_layer.material.sld.bounds = (3.47, 5)
sio2_layer.thickness.bounds = (10, 30)

subphase.material.sld.bounds = (6, 6.35)
dlipids_layer.thickness.bounds = (30, 60)
dlipids_layer.roughness.bounds = (3, 10)
dlipids_layer.material.sld.bounds = (4, 6)
multi_layer_model.scale.bounds = (0.8, 1.2)
multi_layer_model.background.bounds = (1e-6, 1e-3)

# Run the model and plot the results

multi_layer_model.interface = CalculatorFactory()

fitter1 = MultiFitter(multi_layer_model)
fitter1.switch_minimizer(AvailableMinimizers.Bumps_simplex)

> analysed = fitter1.fit(data)
^^^^^^^^^^^^^^^^^

tests/scipp-analysis/estia/ort_file_test.py:99:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self =
data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])
id = 0

def fit(self, data: sc.DataGroup, id: int = 0) -> sc.DataGroup:
"""
Perform the fitting and populate the DataGroups with the result.

:param data: DataGroup to be fitted to and populated
:param method: Optimisation method

:note: Points with zero variance in the data will be automatically masked
out during fitting. A warning will be issued if any such points
are found, indicating the number of points masked per reflectivity.
"""
refl_nums = [k[3:] for k in data['coords'].keys() if 'Qz' == k[:2]]
x = []
y = []
dy = []

# Process each reflectivity dataset
for i in refl_nums:
x_vals = data['coords'][f'Qz_{i}'].values
y_vals = data['data'][f'R_{i}'].values
variances = data['data'][f'R_{i}'].variances

# Find points with non-zero variance
zero_variance_mask = (variances == 0.0)
num_zero_variance = np.sum(zero_variance_mask)

if num_zero_variance > 0:
> warnings.warn(
f"Masked {num_zero_variance} data point(s) in reflectivity {i} due to zero variance during fitting.",
UserWarning
)
E UserWarning: Masked 11 data point(s) in reflectivity 0 due to zero variance during fitting.

.tox/scipp-analysis-estia/lib/python3.12/site-packages/easyreflectometry/fitting.py:62: UserWarning

2025-11-01 00:16:50: error

2025-10-31 00:16:02: error

2025-10-30 19:36:56: error

2025-10-30 00:17:07: error

2025-10-29 00:16:49: error

2025-10-28 15:40:39: error

2025-10-28 00:17:11: error

2025-10-27 00:16:43: error

2025-10-26 00:16:45: error

2025-10-25 00:16:32: error

2025-10-24 00:17:18: error

2025-10-23 00:16:34: error

2025-10-22 16:42:08: error

2025-10-22 15:30:22: error

2025-10-22 15:25:34: error

2025-10-22 13:36:16: success

None

2025-10-22 13:28:30: error

self =
x = array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.,
11., 12., 13., 14., 15., 16., 1...., 161., 162., 163., 164.,
165., 166., 167., 168., 169., 170., 171., 172., 173., 174., 175.,
176., 177.])
y = array([9.47216216e-01, 9.43773836e-01, 9.38502976e-01, 9.46840466e-01,
9.14225023e-01, 9.35726410e-01, 9.455203...276e-04,
1.63630238e-04, 5.43758707e-04, 1.89620095e-04, 3.91717822e-04,
9.29053816e-04, 1.57791806e-03])
weights = array([ 127.86777981, 132.28252712, 136.10474825, 135.25991667,
143.63041869, 145.07311013, 147.96158964,...4913.35246359,
5868.77357106, 3058.0499722 , 5064.3831663 , 2451.53209981,
1461.78332249, 608.59232244])
model = Curve(fn= ._fit_function at 0x7fa5203163e0>, x=array([ 0., 1....,
1461.78332249, 608.59232244]), name='', pars={}, state={}, labels=['x', 'y', 'y'], plot_x=None, plotter=None)
parameters = None, method = None, tolerance = None, max_evaluations = None
minimizer_kwargs = {}, engine_kwargs = {}, kwargs = {}
method_dict = {'method': 'amoeba'}
model_function = ._outer. ._make_func at 0x7fa520316520>
problem = FitProblem(name=None)
global_object =
stack_status = False

def fit(
self,
x: np.ndarray,
y: np.ndarray,
weights: np.ndarray,
model: Optional[Callable] = None,
parameters: Optional[Parameter] = None,
method: Optional[str] = None,
tolerance: Optional[float] = None,
max_evaluations: Optional[int] = None,
minimizer_kwargs: Optional[dict] = None,
engine_kwargs: Optional[dict] = None,
**kwargs,
) -> FitResults:
"""
Perform a fit using the lmfit engine.

:param x: points to be calculated at
:type x: np.ndarray
:param y: measured points
:type y: np.ndarray
:param weights: Weights for supplied measured points
:type weights: np.ndarray
:param model: Optional Model which is being fitted to
:type model: lmModel
:param parameters: Optional parameters for the fit
:type parameters: List[BumpsParameter]
:param kwargs: Additional arguments for the fitting function.
:param method: Method for minimization
:type method: str
:return: Fit results
:rtype: ModelResult
"""
method_dict = self._get_method_kwargs(method)

x, y, weights = np.asarray(x), np.asarray(y), np.asarray(weights)

if y.shape != x.shape:
raise ValueError('x and y must have the same shape.')

if weights.shape != x.shape:
raise ValueError('Weights must have the same shape as x and y.')

if not np.isfinite(weights).all():
raise ValueError('Weights cannot be NaN or infinite.')

if (weights <= 0).any():
raise ValueError('Weights must be strictly positive and non-zero.')

if engine_kwargs is None:
engine_kwargs = {}

if minimizer_kwargs is None:
minimizer_kwargs = {}
minimizer_kwargs.update(engine_kwargs)

if tolerance is not None:
minimizer_kwargs['ftol'] = tolerance # tolerance for change in function value
minimizer_kwargs['xtol'] = tolerance # tolerance for change in parameter value, could be an independent value
if max_evaluations is not None:
minimizer_kwargs['steps'] = max_evaluations

if model is None:
model_function = self._make_model(parameters=parameters)
model = model_function(x, y, weights)
self._cached_model = model

self._p_0 = {f'p{key}': self._cached_pars[key].value for key in self._cached_pars.keys()}

problem = FitProblem(model)
# Why do we do this? Because a fitting template has to have global_object instantiated outside pre-runtime
from easyscience import global_object

stack_status = global_object.stack.enabled
global_object.stack.enabled = False

try:
> model_results = bumps_fit(problem, **method_dict, **minimizer_kwargs, **kwargs)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.tox/scipp-analysis-estia/lib/python3.12/site-packages/easyscience/fitting/minimizers/minimizer_bumps.py:146:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
.tox/scipp-analysis-estia/lib/python3.12/site-packages/bumps/fitters.py:1463: in fit
x, fx = driver.fit(fit_state=None if resume is None else resume.state)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
.tox/scipp-analysis-estia/lib/python3.12/site-packages/bumps/fitters.py:1119: in fit
x, fx = fitter.solve(
.tox/scipp-analysis-estia/lib/python3.12/site-packages/bumps/fitters.py:612: in solve
result = simplex(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

f =
x0 = array([], dtype=float64), bounds = array([], shape=(2, 0), dtype=float64)
radius = np.float64(0.15), xtol = array([], dtype=float64), ftol = 1e-08
maxiter = 1000
update_handler = .update at 0x7fa520317a60>
abort_test = >

def simplex(
f, x0=None, bounds=None, radius=0.05, xtol=1e-4, ftol=1e-4, maxiter=None, update_handler=None, abort_test=dont_abort
):
"""
Minimize a function using Nelder-Mead downhill simplex algorithm.

This optimizer is also known as Amoeba (from Numerical Recipes) and
the Nealder-Mead simplex algorithm. This is not the simplex algorithm
for solving constrained linear systems.

Downhill simplex is a robust derivative free algorithm for finding
minima. It proceeds by choosing a set of points (the simplex) forming
an n-dimensional triangle, and transforming that triangle so that the
worst vertex is improved, either by stretching, shrinking or reflecting
it about the center of the triangle. This algorithm is not known for
its speed, but for its simplicity and robustness, and is a good algorithm
to start your problem with.

*Parameters*:

f : callable f(x,*args)
The objective function to be minimized.
x0 : NDArray
Initial guess.
bounds : (NDArray,NDArray) or None
Bounds on the parameter values for the function.
radius: float
Size of the initial simplex. For bounded parameters (those
which have finite lower and upper bounds), radius is clipped
to a value in (0,0.5] representing the portion of the
range to use as the size of the initial simplex.

*Returns*: Result (`park.simplex.Result`)

x : NDArray
Parameter that minimizes function.
fx : float
Value of function at minimum: ``fopt = func(xopt)``.
iters : int
Number of iterations performed.
calls : int
Number of function calls made.
success : boolean
True if fit completed successfully.

*Other Parameters*:

xtol : float
Relative error in xopt acceptable for convergence.
ftol : number
Relative error in func(xopt) acceptable for convergence.
maxiter : int=200*N
Maximum number of iterations to perform. Defaults
update_handler : callable
Called after each iteration, as callback(k,n,xk,fxk),
where k is the current iteration, n is the maximum
iteration, xk is the simplex and fxk is the value of
the simplex vertices. xk[0],fxk[0] is the current best.
abort_test : callable
Called after each iteration, as callback(), to see if
an external process has requested stop.

*Notes*

Uses a Nelder-Mead simplex algorithm to find the minimum of
function of one or more variables.

"""
fcalls, func = wrap_function(f, bounds)
x0 = np.asarray(x0, dtype=float).flatten()
# print "x0",x0
N = len(x0)
rank = len(x0.shape)
if not -1 < rank < 2:
raise ValueError("Initial guess must be a scalar or rank-1 sequence.")

if maxiter is None:
maxiter = N * 200

rho = 1
chi = 2
psi = 0.5
sigma = 0.5

if rank == 0:
sim = np.zeros((N + 1,), dtype=x0.dtype)
else:
sim = np.zeros((N + 1, N), dtype=x0.dtype)
fsim = np.zeros((N + 1,), float)
sim[0] = x0
fsim[0] = func(x0)

# Metropolitan simplex: simplex has vertices at x0 and at
# x0 + j*radius for each unit vector j. Radius is a percentage
# change from the initial value, or just the radius if the initial
# value is 0. For bounded problems, the radius is a percentage of
# the bounded range in dimension j.
val = x0 * (1 + radius)
val[val == 0] = radius
if bounds is not None:
radius = np.clip(radius, 0, 0.5)
lo, hi = [np.asarray(v) for v in bounds]

# Keep the initial simplex inside the bounds
x0 = np.select([x0 < lo, x0 > hi], [lo, hi], x0)
bounded = ~np.isinf(lo) & ~np.isinf(hi)
val[bounded] = x0[bounded] + (hi[bounded] - lo[bounded]) * radius
val = np.select([val < lo, val > hi], [lo, hi], val)

# If the initial point was at or beyond an upper bound, then bounds
# projection will put x0 and x0+j*radius at the same point. We
# need to detect these collisions and reverse the radius step
# direction when such collisions occur. The only time the collision
# can occur at the lower bound is when upper and lower bound are
# identical. In that case, we are already done.
collision = val == x0
if np.any(collision):
reverse = x0 * (1 - radius)
reverse[reverse == 0] = -radius
reverse[bounded] = x0[bounded] - (hi[bounded] - lo[bounded]) * radius
val[collision] = reverse[collision]

# Make tolerance relative for bounded parameters
tol = np.ones(x0.shape) * xtol
tol[bounded] = (hi[bounded] - lo[bounded]) * xtol
xtol = tol

# Compute values at the simplex vertices
for k in range(0, N):
y = x0 + 0
y[k] = val[k]
sim[k + 1] = y
fsim[k + 1] = func(y)

# print sim
ind = np.argsort(fsim)
fsim = np.take(fsim, ind, 0)
# sort so sim[0,:] has the lowest function value
sim = np.take(sim, ind, 0)
# print sim

iterations = 1
while iterations < maxiter:
> if np.all(abs(sim[1:] - sim[0]) <= xtol) and max(abs(fsim[0] - fsim[1:])) <= ftol:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: max() iterable argument is empty

.tox/scipp-analysis-estia/lib/python3.12/site-packages/bumps/simplex.py:215: ValueError

During handling of the above exception, another exception occurred:

load_data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])

@pytest.fixture(scope="module")
def fit_model(load_data):
data = load_data
# Rescale data
reflectivity = data["data"]["R_0"].values
scale_factor = 1 / np.max(reflectivity)
data["data"]["R_0"].values *= scale_factor

# Create a model for the sample

si = Material(sld=2.07, isld=0.0, name="Si")
sio2 = Material(sld=3.47, isld=0.0, name="SiO2")
d2o = Material(sld=6.33, isld=0.0, name="D2O")
dlipids = Material(sld=5.0, isld=0.0, name="DLipids")

superphase = Layer(material=si, thickness=0, roughness=0, name="Si superphase")
sio2_layer = Layer(material=sio2, thickness=20, roughness=4, name="SiO2 layer")
dlipids_layer = Layer(
material=dlipids, thickness=40, roughness=4, name="DLipids layer"
)
subphase = Layer(material=d2o, thickness=0, roughness=5, name="D2O subphase")

multi_sample = Sample(
Multilayer(superphase),
Multilayer(sio2_layer),
Multilayer(dlipids_layer),
Multilayer(subphase),
name="Multilayer Structure",
)

multi_layer_model = Model(
sample=multi_sample,
scale=1,
background=0.000001,
resolution_function=PercentageFwhm(0),
name="Multilayer Model",
)

# Set the fitting parameters

sio2_layer.roughness.bounds = (3, 12)
sio2_layer.material.sld.bounds = (3.47, 5)
sio2_layer.thickness.bounds = (10, 30)

subphase.material.sld.bounds = (6, 6.35)
dlipids_layer.thickness.bounds = (30, 60)
dlipids_layer.roughness.bounds = (3, 10)
dlipids_layer.material.sld.bounds = (4, 6)
multi_layer_model.scale.bounds = (0.8, 1.2)
multi_layer_model.background.bounds = (1e-6, 1e-3)

# Run the model and plot the results

multi_layer_model.interface = CalculatorFactory()

fitter1 = MultiFitter(multi_layer_model)
fitter1.switch_minimizer(AvailableMinimizers.Bumps_simplex)

> analysed = fitter1.fit(data)
^^^^^^^^^^^^^^^^^

tests/scipp-analysis/estia/ort_file_test.py:99:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
.tox/scipp-analysis-estia/lib/python3.12/site-packages/easyreflectometry/fitting.py:77: in fit
result = self.easy_science_multi_fitter.fit(x, y, weights=dy)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
.tox/scipp-analysis-estia/lib/python3.12/site-packages/easyscience/fitting/fitter.py:228: in inner_fit_callable
f_res = self._minimizer.fit(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self =
x = array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.,
11., 12., 13., 14., 15., 16., 1...., 161., 162., 163., 164.,
165., 166., 167., 168., 169., 170., 171., 172., 173., 174., 175.,
176., 177.])
y = array([9.47216216e-01, 9.43773836e-01, 9.38502976e-01, 9.46840466e-01,
9.14225023e-01, 9.35726410e-01, 9.455203...276e-04,
1.63630238e-04, 5.43758707e-04, 1.89620095e-04, 3.91717822e-04,
9.29053816e-04, 1.57791806e-03])
weights = array([ 127.86777981, 132.28252712, 136.10474825, 135.25991667,
143.63041869, 145.07311013, 147.96158964,...4913.35246359,
5868.77357106, 3058.0499722 , 5064.3831663 , 2451.53209981,
1461.78332249, 608.59232244])
model = Curve(fn= ._fit_function at 0x7fa5203163e0>, x=array([ 0., 1....,
1461.78332249, 608.59232244]), name='', pars={}, state={}, labels=['x', 'y', 'y'], plot_x=None, plotter=None)
parameters = None, method = None, tolerance = None, max_evaluations = None
minimizer_kwargs = {}, engine_kwargs = {}, kwargs = {}
method_dict = {'method': 'amoeba'}
model_function = ._outer. ._make_func at 0x7fa520316520>
problem = FitProblem(name=None)
global_object =
stack_status = False

def fit(
self,
x: np.ndarray,
y: np.ndarray,
weights: np.ndarray,
model: Optional[Callable] = None,
parameters: Optional[Parameter] = None,
method: Optional[str] = None,
tolerance: Optional[float] = None,
max_evaluations: Optional[int] = None,
minimizer_kwargs: Optional[dict] = None,
engine_kwargs: Optional[dict] = None,
**kwargs,
) -> FitResults:
"""
Perform a fit using the lmfit engine.

:param x: points to be calculated at
:type x: np.ndarray
:param y: measured points
:type y: np.ndarray
:param weights: Weights for supplied measured points
:type weights: np.ndarray
:param model: Optional Model which is being fitted to
:type model: lmModel
:param parameters: Optional parameters for the fit
:type parameters: List[BumpsParameter]
:param kwargs: Additional arguments for the fitting function.
:param method: Method for minimization
:type method: str
:return: Fit results
:rtype: ModelResult
"""
method_dict = self._get_method_kwargs(method)

x, y, weights = np.asarray(x), np.asarray(y), np.asarray(weights)

if y.shape != x.shape:
raise ValueError('x and y must have the same shape.')

if weights.shape != x.shape:
raise ValueError('Weights must have the same shape as x and y.')

if not np.isfinite(weights).all():
raise ValueError('Weights cannot be NaN or infinite.')

if (weights <= 0).any():
raise ValueError('Weights must be strictly positive and non-zero.')

if engine_kwargs is None:
engine_kwargs = {}

if minimizer_kwargs is None:
minimizer_kwargs = {}
minimizer_kwargs.update(engine_kwargs)

if tolerance is not None:
minimizer_kwargs['ftol'] = tolerance # tolerance for change in function value
minimizer_kwargs['xtol'] = tolerance # tolerance for change in parameter value, could be an independent value
if max_evaluations is not None:
minimizer_kwargs['steps'] = max_evaluations

if model is None:
model_function = self._make_model(parameters=parameters)
model = model_function(x, y, weights)
self._cached_model = model

self._p_0 = {f'p{key}': self._cached_pars[key].value for key in self._cached_pars.keys()}

problem = FitProblem(model)
# Why do we do this? Because a fitting template has to have global_object instantiated outside pre-runtime
from easyscience import global_object

stack_status = global_object.stack.enabled
global_object.stack.enabled = False

try:
model_results = bumps_fit(problem, **method_dict, **minimizer_kwargs, **kwargs)
self._set_parameter_fit_result(model_results, stack_status, problem._parameters)
results = self._gen_fit_results(model_results)
except Exception as e:
for key in self._cached_pars.keys():
self._cached_pars[key].value = self._cached_pars_vals[key][0]
> raise FitError(e)
E easyscience.fitting.minimizers.utils.FitError: max() iterable argument is empty
E Something has gone wrong with the fit

.tox/scipp-analysis-estia/lib/python3.12/site-packages/easyscience/fitting/minimizers/minimizer_bumps.py:152: FitError

2025-10-22 00:17:38: error

2025-10-21 00:16:49: error

2025-10-20 00:16:39: error

2025-10-19 00:17:21: error

2025-10-18 00:16:54: error

2025-10-17 16:00:03: error

2025-10-17 10:11:36: error

2025-10-17 00:16:42: error

2025-10-16 00:16:34: error

2025-10-15 00:16:18: error

2025-10-14 00:16:00: error

2025-10-13 12:16:13: error

2025-10-13 10:47:20: error

2025-10-13 11:45:08: error

2025-10-09 00:16:04: error

2025-10-08 00:15:55: error

2025-10-07 10:35:14: error

2025-10-07 00:16:13: error

load_data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])

@pytest.fixture(scope="module")
def fit_model(load_data):
data = load_data
# Rescale data
reflectivity = data["data"]["R_0"].values
scale_factor = 1 / np.max(reflectivity)
data["data"]["R_0"].values *= scale_factor

# Create a model for the sample

si = Material(sld=2.07, isld=0.0, name="Si")
sio2 = Material(sld=3.47, isld=0.0, name="SiO2")
d2o = Material(sld=6.33, isld=0.0, name="D2O")
dlipids = Material(sld=5.0, isld=0.0, name="DLipids")

superphase = Layer(material=si, thickness=0, roughness=0, name="Si superphase")
sio2_layer = Layer(material=sio2, thickness=20, roughness=4, name="SiO2 layer")
dlipids_layer = Layer(
material=dlipids, thickness=40, roughness=4, name="DLipids layer"
)
subphase = Layer(material=d2o, thickness=0, roughness=5, name="D2O subphase")

multi_sample = Sample(
Multilayer(superphase),
Multilayer(sio2_layer),
Multilayer(dlipids_layer),
Multilayer(subphase),
name="Multilayer Structure",
)

multi_layer_model = Model(
sample=multi_sample,
scale=1,
background=0.000001,
resolution_function=PercentageFwhm(0),
name="Multilayer Model",
)

# Set the fitting parameters

sio2_layer.roughness.bounds = (3, 12)
sio2_layer.material.sld.bounds = (3.47, 5)
sio2_layer.thickness.bounds = (10, 30)

subphase.material.sld.bounds = (6, 6.35)
dlipids_layer.thickness.bounds = (30, 60)
dlipids_layer.roughness.bounds = (3, 10)
dlipids_layer.material.sld.bounds = (4, 6)
multi_layer_model.scale.bounds = (0.8, 1.2)
multi_layer_model.background.bounds = (1e-6, 1e-3)

# Run the model and plot the results

multi_layer_model.interface = CalculatorFactory()

fitter1 = MultiFitter(multi_layer_model)
fitter1.switch_minimizer(AvailableMinimizers.Bumps_simplex)

> analysed = fitter1.fit(data)
^^^^^^^^^^^^^^^^^

tests/scipp-analysis/estia/ort_file_test.py:99:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self =
data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])
id = 0

def fit(self, data: sc.DataGroup, id: int = 0) -> sc.DataGroup:
"""
Perform the fitting and populate the DataGroups with the result.

:param data: DataGroup to be fitted to and populated
:param method: Optimisation method
"""
refl_nums = [k[3:] for k in data['coords'].keys() if 'Qz' == k[:2]]
x = [data['coords'][f'Qz_{i}'].values for i in refl_nums]
y = [data['data'][f'R_{i}'].values for i in refl_nums]
> dy = [1 / np.sqrt(data['data'][f'R_{i}'].variances) for i in refl_nums]
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E RuntimeWarning: divide by zero encountered in divide

.tox/scipp-analysis-estia/lib/python3.12/site-packages/easyreflectometry/fitting.py:43: RuntimeWarning

2025-10-06 14:04:10: error

load_data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])

@pytest.fixture(scope="module")
def fit_model(load_data):
data = load_data
# Rescale data
reflectivity = data["data"]["R_0"].values
scale_factor = 1 / np.max(reflectivity)
data["data"]["R_0"].values *= scale_factor

# Create a model for the sample

si = Material(sld=2.07, isld=0.0, name="Si")
sio2 = Material(sld=3.47, isld=0.0, name="SiO2")
d2o = Material(sld=6.33, isld=0.0, name="D2O")
dlipids = Material(sld=5.0, isld=0.0, name="DLipids")

superphase = Layer(material=si, thickness=0, roughness=0, name="Si superphase")
sio2_layer = Layer(material=sio2, thickness=20, roughness=4, name="SiO2 layer")
dlipids_layer = Layer(
material=dlipids, thickness=40, roughness=4, name="DLipids layer"
)
subphase = Layer(material=d2o, thickness=0, roughness=5, name="D2O subphase")

multi_sample = Sample(
Multilayer(superphase),
Multilayer(sio2_layer),
Multilayer(dlipids_layer),
Multilayer(subphase),
name="Multilayer Structure",
)

multi_layer_model = Model(
sample=multi_sample,
scale=1,
background=0.000001,
resolution_function=PercentageFwhm(0),
name="Multilayer Model",
)

# Set the fitting parameters

sio2_layer.roughness.bounds = (3, 12)
sio2_layer.material.sld.bounds = (3.47, 5)
sio2_layer.thickness.bounds = (10, 30)

subphase.material.sld.bounds = (6, 6.35)
dlipids_layer.thickness.bounds = (30, 60)
dlipids_layer.roughness.bounds = (3, 10)
dlipids_layer.material.sld.bounds = (4, 6)
multi_layer_model.scale.bounds = (0.8, 1.2)
multi_layer_model.background.bounds = (1e-6, 1e-3)

# Run the model and plot the results

multi_layer_model.interface = CalculatorFactory()

fitter1 = MultiFitter(multi_layer_model)
fitter1.switch_minimizer(AvailableMinimizers.Bumps_simplex)

> analysed = fitter1.fit(data)
^^^^^^^^^^^^^^^^^

tests/scipp-analysis/estia/ort_file_test.py:99:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self =
data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])
id = 0

def fit(self, data: sc.DataGroup, id: int = 0) -> sc.DataGroup:
"""
Perform the fitting and populate the DataGroups with the result.

:param data: DataGroup to be fitted to and populated
:param method: Optimisation method
"""
refl_nums = [k[3:] for k in data['coords'].keys() if 'Qz' == k[:2]]
x = [data['coords'][f'Qz_{i}'].values for i in refl_nums]
y = [data['data'][f'R_{i}'].values for i in refl_nums]
> dy = [1 / np.sqrt(data['data'][f'R_{i}'].variances) for i in refl_nums]
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E RuntimeWarning: divide by zero encountered in divide

.tox/scipp-analysis-estia/lib/python3.12/site-packages/easyreflectometry/fitting.py:43: RuntimeWarning

2025-10-06 11:14:15: error

load_data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])

@pytest.fixture(scope="module")
def fit_model(load_data):
data = load_data
# Rescale data
reflectivity = data["data"]["R_0"].values
scale_factor = 1 / np.max(reflectivity)
data["data"]["R_0"].values *= scale_factor

# Create a model for the sample

si = Material(sld=2.07, isld=0.0, name="Si")
sio2 = Material(sld=3.47, isld=0.0, name="SiO2")
d2o = Material(sld=6.33, isld=0.0, name="D2O")
dlipids = Material(sld=5.0, isld=0.0, name="DLipids")

superphase = Layer(material=si, thickness=0, roughness=0, name="Si superphase")
sio2_layer = Layer(material=sio2, thickness=20, roughness=4, name="SiO2 layer")
dlipids_layer = Layer(
material=dlipids, thickness=40, roughness=4, name="DLipids layer"
)
subphase = Layer(material=d2o, thickness=0, roughness=5, name="D2O subphase")

multi_sample = Sample(
Multilayer(superphase),
Multilayer(sio2_layer),
Multilayer(dlipids_layer),
Multilayer(subphase),
name="Multilayer Structure",
)

multi_layer_model = Model(
sample=multi_sample,
scale=1,
background=0.000001,
resolution_function=PercentageFwhm(0),
name="Multilayer Model",
)

# Set the fitting parameters

sio2_layer.roughness.bounds = (3, 12)
sio2_layer.material.sld.bounds = (3.47, 5)
sio2_layer.thickness.bounds = (10, 30)

subphase.material.sld.bounds = (6, 6.35)
dlipids_layer.thickness.bounds = (30, 60)
dlipids_layer.roughness.bounds = (3, 10)
dlipids_layer.material.sld.bounds = (4, 6)
multi_layer_model.scale.bounds = (0.8, 1.2)
multi_layer_model.background.bounds = (1e-6, 1e-3)

# Run the model and plot the results

multi_layer_model.interface = CalculatorFactory()

fitter1 = MultiFitter(multi_layer_model)
fitter1.switch_minimizer(AvailableMinimizers.Bumps_simplex)

> analysed = fitter1.fit(data)
^^^^^^^^^^^^^^^^^

tests/scipp-analysis/estia/ort_file_test.py:99:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self =
data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])
id = 0

def fit(self, data: sc.DataGroup, id: int = 0) -> sc.DataGroup:
"""
Perform the fitting and populate the DataGroups with the result.

:param data: DataGroup to be fitted to and populated
:param method: Optimisation method
"""
refl_nums = [k[3:] for k in data['coords'].keys() if 'Qz' == k[:2]]
x = [data['coords'][f'Qz_{i}'].values for i in refl_nums]
y = [data['data'][f'R_{i}'].values for i in refl_nums]
> dy = [1 / np.sqrt(data['data'][f'R_{i}'].variances) for i in refl_nums]
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E RuntimeWarning: divide by zero encountered in divide

.tox/scipp-analysis-estia/lib/python3.12/site-packages/easyreflectometry/fitting.py:43: RuntimeWarning

2025-10-06 10:46:35: error

load_data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])

@pytest.fixture(scope="module")
def fit_model(load_data):
data = load_data
# Rescale data
reflectivity = data["data"]["R_0"].values
scale_factor = 1 / np.max(reflectivity)
data["data"]["R_0"].values *= scale_factor

# Create a model for the sample

si = Material(sld=2.07, isld=0.0, name="Si")
sio2 = Material(sld=3.47, isld=0.0, name="SiO2")
d2o = Material(sld=6.33, isld=0.0, name="D2O")
dlipids = Material(sld=5.0, isld=0.0, name="DLipids")

superphase = Layer(material=si, thickness=0, roughness=0, name="Si superphase")
sio2_layer = Layer(material=sio2, thickness=20, roughness=4, name="SiO2 layer")
dlipids_layer = Layer(
material=dlipids, thickness=40, roughness=4, name="DLipids layer"
)
subphase = Layer(material=d2o, thickness=0, roughness=5, name="D2O subphase")

multi_sample = Sample(
Multilayer(superphase),
Multilayer(sio2_layer),
Multilayer(dlipids_layer),
Multilayer(subphase),
name="Multilayer Structure",
)

multi_layer_model = Model(
sample=multi_sample,
scale=1,
background=0.000001,
resolution_function=PercentageFwhm(0),
name="Multilayer Model",
)

# Set the fitting parameters

sio2_layer.roughness.bounds = (3, 12)
sio2_layer.material.sld.bounds = (3.47, 5)
sio2_layer.thickness.bounds = (10, 30)

subphase.material.sld.bounds = (6, 6.35)
dlipids_layer.thickness.bounds = (30, 60)
dlipids_layer.roughness.bounds = (3, 10)
dlipids_layer.material.sld.bounds = (4, 6)
multi_layer_model.scale.bounds = (0.8, 1.2)
multi_layer_model.background.bounds = (1e-6, 1e-3)

# Run the model and plot the results

multi_layer_model.interface = CalculatorFactory()

fitter1 = MultiFitter(multi_layer_model)
fitter1.switch_minimizer(AvailableMinimizers.Bumps_simplex)

> analysed = fitter1.fit(data)
^^^^^^^^^^^^^^^^^

tests/scipp-analysis/estia/ort_file_test.py:99:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self =
data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])
id = 0

def fit(self, data: sc.DataGroup, id: int = 0) -> sc.DataGroup:
"""
Perform the fitting and populate the DataGroups with the result.

:param data: DataGroup to be fitted to and populated
:param method: Optimisation method
"""
refl_nums = [k[3:] for k in data['coords'].keys() if 'Qz' == k[:2]]
x = [data['coords'][f'Qz_{i}'].values for i in refl_nums]
y = [data['data'][f'R_{i}'].values for i in refl_nums]
> dy = [1 / np.sqrt(data['data'][f'R_{i}'].variances) for i in refl_nums]
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E RuntimeWarning: divide by zero encountered in divide

.tox/scipp-analysis-estia/lib/python3.12/site-packages/easyreflectometry/fitting.py:43: RuntimeWarning

2025-10-03 00:15:48: error

load_data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])

@pytest.fixture(scope="module")
def fit_model(load_data):
data = load_data
# Rescale data
reflectivity = data["data"]["R_0"].values
scale_factor = 1 / np.max(reflectivity)
data["data"]["R_0"].values *= scale_factor

# Create a model for the sample

si = Material(sld=2.07, isld=0.0, name="Si")
sio2 = Material(sld=3.47, isld=0.0, name="SiO2")
d2o = Material(sld=6.33, isld=0.0, name="D2O")
dlipids = Material(sld=5.0, isld=0.0, name="DLipids")

superphase = Layer(material=si, thickness=0, roughness=0, name="Si superphase")
sio2_layer = Layer(material=sio2, thickness=20, roughness=4, name="SiO2 layer")
dlipids_layer = Layer(
material=dlipids, thickness=40, roughness=4, name="DLipids layer"
)
subphase = Layer(material=d2o, thickness=0, roughness=5, name="D2O subphase")

multi_sample = Sample(
Multilayer(superphase),
Multilayer(sio2_layer),
Multilayer(dlipids_layer),
Multilayer(subphase),
name="Multilayer Structure",
)

multi_layer_model = Model(
sample=multi_sample,
scale=1,
background=0.000001,
resolution_function=PercentageFwhm(0),
name="Multilayer Model",
)

# Set the fitting parameters

sio2_layer.roughness.bounds = (3, 12)
sio2_layer.material.sld.bounds = (3.47, 5)
sio2_layer.thickness.bounds = (10, 30)

subphase.material.sld.bounds = (6, 6.35)
dlipids_layer.thickness.bounds = (30, 60)
dlipids_layer.roughness.bounds = (3, 10)
dlipids_layer.material.sld.bounds = (4, 6)
multi_layer_model.scale.bounds = (0.8, 1.2)
multi_layer_model.background.bounds = (1e-6, 1e-3)

# Run the model and plot the results

multi_layer_model.interface = CalculatorFactory()

fitter1 = MultiFitter(multi_layer_model)
fitter1.switch_minimizer(AvailableMinimizers.Bumps_simplex)

> analysed = fitter1.fit(data)
^^^^^^^^^^^^^^^^^

tests/scipp-analysis/estia/ort_file_test.py:99:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self =
data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])
id = 0

def fit(self, data: sc.DataGroup, id: int = 0) -> sc.DataGroup:
"""
Perform the fitting and populate the DataGroups with the result.

:param data: DataGroup to be fitted to and populated
:param method: Optimisation method
"""
refl_nums = [k[3:] for k in data['coords'].keys() if 'Qz' == k[:2]]
x = [data['coords'][f'Qz_{i}'].values for i in refl_nums]
y = [data['data'][f'R_{i}'].values for i in refl_nums]
> dy = [1 / np.sqrt(data['data'][f'R_{i}'].variances) for i in refl_nums]
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E RuntimeWarning: divide by zero encountered in divide

.tox/scipp-analysis-estia/lib/python3.12/site-packages/easyreflectometry/fitting.py:43: RuntimeWarning

2025-10-02 16:06:39: error

load_data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])

@pytest.fixture(scope="module")
def fit_model(load_data):
data = load_data
# Rescale data
reflectivity = data["data"]["R_0"].values
scale_factor = 1 / np.max(reflectivity)
data["data"]["R_0"].values *= scale_factor

# Create a model for the sample

si = Material(sld=2.07, isld=0.0, name="Si")
sio2 = Material(sld=3.47, isld=0.0, name="SiO2")
d2o = Material(sld=6.33, isld=0.0, name="D2O")
dlipids = Material(sld=5.0, isld=0.0, name="DLipids")

superphase = Layer(material=si, thickness=0, roughness=0, name="Si superphase")
sio2_layer = Layer(material=sio2, thickness=20, roughness=4, name="SiO2 layer")
dlipids_layer = Layer(
material=dlipids, thickness=40, roughness=4, name="DLipids layer"
)
subphase = Layer(material=d2o, thickness=0, roughness=5, name="D2O subphase")

multi_sample = Sample(
Multilayer(superphase),
Multilayer(sio2_layer),
Multilayer(dlipids_layer),
Multilayer(subphase),
name="Multilayer Structure",
)

multi_layer_model = Model(
sample=multi_sample,
scale=1,
background=0.000001,
resolution_function=PercentageFwhm(0),
name="Multilayer Model",
)

# Set the fitting parameters

sio2_layer.roughness.bounds = (3, 12)
sio2_layer.material.sld.bounds = (3.47, 5)
sio2_layer.thickness.bounds = (10, 30)

subphase.material.sld.bounds = (6, 6.35)
dlipids_layer.thickness.bounds = (30, 60)
dlipids_layer.roughness.bounds = (3, 10)
dlipids_layer.material.sld.bounds = (4, 6)
multi_layer_model.scale.bounds = (0.8, 1.2)
multi_layer_model.background.bounds = (1e-6, 1e-3)

# Run the model and plot the results

multi_layer_model.interface = CalculatorFactory()

fitter1 = MultiFitter(multi_layer_model)
fitter1.switch_minimizer(AvailableMinimizers.Bumps_simplex)

> analysed = fitter1.fit(data)
^^^^^^^^^^^^^^^^^

tests/scipp-analysis/estia/ort_file_test.py:99:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self =
data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])
id = 0

def fit(self, data: sc.DataGroup, id: int = 0) -> sc.DataGroup:
"""
Perform the fitting and populate the DataGroups with the result.

:param data: DataGroup to be fitted to and populated
:param method: Optimisation method
"""
refl_nums = [k[3:] for k in data['coords'].keys() if 'Qz' == k[:2]]
x = [data['coords'][f'Qz_{i}'].values for i in refl_nums]
y = [data['data'][f'R_{i}'].values for i in refl_nums]
> dy = [1 / np.sqrt(data['data'][f'R_{i}'].variances) for i in refl_nums]
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E RuntimeWarning: divide by zero encountered in divide

.tox/scipp-analysis-estia/lib/python3.12/site-packages/easyreflectometry/fitting.py:43: RuntimeWarning

2025-10-02 15:59:26: error

load_data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])

@pytest.fixture(scope="module")
def fit_model(load_data):
data = load_data
# Rescale data
reflectivity = data["data"]["R_0"].values
scale_factor = 1 / np.max(reflectivity)
data["data"]["R_0"].values *= scale_factor

# Create a model for the sample

si = Material(sld=2.07, isld=0.0, name="Si")
sio2 = Material(sld=3.47, isld=0.0, name="SiO2")
d2o = Material(sld=6.33, isld=0.0, name="D2O")
dlipids = Material(sld=5.0, isld=0.0, name="DLipids")

superphase = Layer(material=si, thickness=0, roughness=0, name="Si superphase")
sio2_layer = Layer(material=sio2, thickness=20, roughness=4, name="SiO2 layer")
dlipids_layer = Layer(
material=dlipids, thickness=40, roughness=4, name="DLipids layer"
)
subphase = Layer(material=d2o, thickness=0, roughness=5, name="D2O subphase")

multi_sample = Sample(
Multilayer(superphase),
Multilayer(sio2_layer),
Multilayer(dlipids_layer),
Multilayer(subphase),
name="Multilayer Structure",
)

multi_layer_model = Model(
sample=multi_sample,
scale=1,
background=0.000001,
resolution_function=PercentageFwhm(0),
name="Multilayer Model",
)

# Set the fitting parameters

sio2_layer.roughness.bounds = (3, 12)
sio2_layer.material.sld.bounds = (3.47, 5)
sio2_layer.thickness.bounds = (10, 30)

subphase.material.sld.bounds = (6, 6.35)
dlipids_layer.thickness.bounds = (30, 60)
dlipids_layer.roughness.bounds = (3, 10)
dlipids_layer.material.sld.bounds = (4, 6)
multi_layer_model.scale.bounds = (0.8, 1.2)
multi_layer_model.background.bounds = (1e-6, 1e-3)

# Run the model and plot the results

multi_layer_model.interface = CalculatorFactory()

fitter1 = MultiFitter(multi_layer_model)
fitter1.switch_minimizer(AvailableMinimizers.Bumps_simplex)

> analysed = fitter1.fit(data)
^^^^^^^^^^^^^^^^^

tests/scipp-analysis/estia/ort_file_test.py:99:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self =
data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])
id = 0

def fit(self, data: sc.DataGroup, id: int = 0) -> sc.DataGroup:
"""
Perform the fitting and populate the DataGroups with the result.

:param data: DataGroup to be fitted to and populated
:param method: Optimisation method
"""
refl_nums = [k[3:] for k in data['coords'].keys() if 'Qz' == k[:2]]
x = [data['coords'][f'Qz_{i}'].values for i in refl_nums]
y = [data['data'][f'R_{i}'].values for i in refl_nums]
> dy = [1 / np.sqrt(data['data'][f'R_{i}'].variances) for i in refl_nums]
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E RuntimeWarning: divide by zero encountered in divide

.tox/scipp-analysis-estia/lib/python3.12/site-packages/easyreflectometry/fitting.py:43: RuntimeWarning

2025-10-02 15:47:54: error

load_data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])

@pytest.fixture(scope="module")
def fit_model(load_data):
data = load_data
# Rescale data
reflectivity = data["data"]["R_0"].values
scale_factor = 1 / np.max(reflectivity)
data["data"]["R_0"].values *= scale_factor

# Create a model for the sample

si = Material(sld=2.07, isld=0.0, name="Si")
sio2 = Material(sld=3.47, isld=0.0, name="SiO2")
d2o = Material(sld=6.33, isld=0.0, name="D2O")
dlipids = Material(sld=5.0, isld=0.0, name="DLipids")

superphase = Layer(material=si, thickness=0, roughness=0, name="Si superphase")
sio2_layer = Layer(material=sio2, thickness=20, roughness=4, name="SiO2 layer")
dlipids_layer = Layer(
material=dlipids, thickness=40, roughness=4, name="DLipids layer"
)
subphase = Layer(material=d2o, thickness=0, roughness=5, name="D2O subphase")

multi_sample = Sample(
Multilayer(superphase),
Multilayer(sio2_layer),
Multilayer(dlipids_layer),
Multilayer(subphase),
name="Multilayer Structure",
)

multi_layer_model = Model(
sample=multi_sample,
scale=1,
background=0.000001,
resolution_function=PercentageFwhm(0),
name="Multilayer Model",
)

# Set the fitting parameters

sio2_layer.roughness.bounds = (3, 12)
sio2_layer.material.sld.bounds = (3.47, 5)
sio2_layer.thickness.bounds = (10, 30)

subphase.material.sld.bounds = (6, 6.35)
dlipids_layer.thickness.bounds = (30, 60)
dlipids_layer.roughness.bounds = (3, 10)
dlipids_layer.material.sld.bounds = (4, 6)
multi_layer_model.scale.bounds = (0.8, 1.2)
multi_layer_model.background.bounds = (1e-6, 1e-3)

# Run the model and plot the results

multi_layer_model.interface = CalculatorFactory()

fitter1 = MultiFitter(multi_layer_model)
fitter1.switch_minimizer(AvailableMinimizers.Bumps_simplex)

> analysed = fitter1.fit(data)
^^^^^^^^^^^^^^^^^

tests/scipp-analysis/estia/ort_file_test.py:99:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self =
data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])
id = 0

def fit(self, data: sc.DataGroup, id: int = 0) -> sc.DataGroup:
"""
Perform the fitting and populate the DataGroups with the result.

:param data: DataGroup to be fitted to and populated
:param method: Optimisation method
"""
refl_nums = [k[3:] for k in data['coords'].keys() if 'Qz' == k[:2]]
x = [data['coords'][f'Qz_{i}'].values for i in refl_nums]
y = [data['data'][f'R_{i}'].values for i in refl_nums]
> dy = [1 / np.sqrt(data['data'][f'R_{i}'].variances) for i in refl_nums]
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E RuntimeWarning: divide by zero encountered in divide

.tox/scipp-analysis-estia/lib/python3.12/site-packages/easyreflectometry/fitting.py:43: RuntimeWarning

2025-10-02 15:35:45: error

load_data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])

@pytest.fixture(scope="module")
def fit_model(load_data):
data = load_data
# Rescale data
reflectivity = data["data"]["R_0"].values
scale_factor = 1 / np.max(reflectivity)
data["data"]["R_0"].values *= scale_factor

# Create a model for the sample

si = Material(sld=2.07, isld=0.0, name="Si")
sio2 = Material(sld=3.47, isld=0.0, name="SiO2")
d2o = Material(sld=6.33, isld=0.0, name="D2O")
dlipids = Material(sld=5.0, isld=0.0, name="DLipids")

superphase = Layer(material=si, thickness=0, roughness=0, name="Si superphase")
sio2_layer = Layer(material=sio2, thickness=20, roughness=4, name="SiO2 layer")
dlipids_layer = Layer(
material=dlipids, thickness=40, roughness=4, name="DLipids layer"
)
subphase = Layer(material=d2o, thickness=0, roughness=5, name="D2O subphase")

multi_sample = Sample(
Multilayer(superphase),
Multilayer(sio2_layer),
Multilayer(dlipids_layer),
Multilayer(subphase),
name="Multilayer Structure",
)

multi_layer_model = Model(
sample=multi_sample,
scale=1,
background=0.000001,
resolution_function=PercentageFwhm(0),
name="Multilayer Model",
)

# Set the fitting parameters

sio2_layer.roughness.bounds = (3, 12)
sio2_layer.material.sld.bounds = (3.47, 5)
sio2_layer.thickness.bounds = (10, 30)

subphase.material.sld.bounds = (6, 6.35)
dlipids_layer.thickness.bounds = (30, 60)
dlipids_layer.roughness.bounds = (3, 10)
dlipids_layer.material.sld.bounds = (4, 6)
multi_layer_model.scale.bounds = (0.8, 1.2)
multi_layer_model.background.bounds = (1e-6, 1e-3)

# Run the model and plot the results

multi_layer_model.interface = CalculatorFactory()

fitter1 = MultiFitter(multi_layer_model)
fitter1.switch_minimizer(AvailableMinimizers.Bumps_simplex)

> analysed = fitter1.fit(data)
^^^^^^^^^^^^^^^^^

tests/scipp-analysis/estia/ort_file_test.py:99:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self =
data = DataGroup(sizes={}, keys=[
data: {'R_0': (Qz_0: 189) float64 [dimensionless] [0.947216, 0.94...ame': 'sQz', 'unit': '1/angstrom', 'physical_quantity': 'standard deviation of wavevector transfer resolution'}]}}},
])
id = 0

def fit(self, data: sc.DataGroup, id: int = 0) -> sc.DataGroup:
"""
Perform the fitting and populate the DataGroups with the result.

:param data: DataGroup to be fitted to and populated
:param method: Optimisation method
"""
refl_nums = [k[3:] for k in data['coords'].keys() if 'Qz' == k[:2]]
x = [data['coords'][f'Qz_{i}'].values for i in refl_nums]
y = [data['data'][f'R_{i}'].values for i in refl_nums]
> dy = [1 / np.sqrt(data['data'][f'R_{i}'].variances) for i in refl_nums]
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E RuntimeWarning: divide by zero encountered in divide

.tox/scipp-analysis-estia/lib/python3.12/site-packages/easyreflectometry/fitting.py:43: RuntimeWarning