ADR Suggestion, Dependent Parameters

[damskii9992]

General

It can be beneficial in a model to have Parameters which are defined through a relation to other parameters/descriptors. These dependent parameters are defined by their relation and thus should not be fitted during minimization. Their value should be updated when the values of the independent parameters which they depend on are changed. It should be possible to easily convert a dependent parameter to a dependent parameter and vice versa.

Current Implementation

Currently, this is handled by the "constraints" objects which are created separately and then assigned to the parameter, such as:

a = Parameter(name='a', value=0.2)
b = Parameter(name='b', value=1)
constraint = ObjConstraint(a, '2*', b)
b.user_constraints['SET_A'] = constraint

Requirements

• When an independent parameter value is changed, it should update the values of all the parameters which depend directly on it. When doing this update, signals should also be send to the GUI frontend to reflect this change.
• Making a parameter dependent should be easy and user-friendly, both when generated and when changed by the setter, by allowing direct expressions such as: 'value=a+2*b' in the value field
• A dependent parameter should also be easy to change back into an independent parameter
• Dependent parameters should not be included in the fitting procedure
• [Optional] It should be possible to visualize a dependency tree to get an overview of all parameter dependencies

Implementation

• '_is_independent' boolean variable, for checks
• 'list_of_dependents' list variable with UIDs of parameters that depend on the parameter
• '_update' method, to be called on dependent parameters when their independent dependency is changed
• Logic to ensure no broken, cyclic or secondary (for now) dependencies

[AndrewSazonov]

Note that in order to update the part of the GUI that displays the changed parameter, you must decorate the setter and getter of the parameter and emit the parameter changed signal, as shown in the example below:

from PySide6.QtCore import QObject, Signal, Slot, Property

class Model(QObject):
    definedChanged = Signal()

    def __init__(self):
        self._defined = False

    @Property(bool, notify=definedChanged)
    def defined(self):
        return self._defined

    @defined.setter
    def defined(self, newValue):
        if self._defined == newValue:
            return
        self._defined = newValue
        self.definedChanged.emit()

Now every time you assign a new value to the property defined, for example, model.defined = True, the signal definedChanged is emitted and the value of this property displayed in the GUI is updated.

[rozyczko]

Good point.
Also, please keep in mind that signal/slot mechanism is only available in event loop based code (Qt/QML). The underlying library/core code will not be able to use it.

[andped10]

To my understanding we would also need functionality to inform the independent parameter when a new dependent parameter is made dependent.