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

Proposed Implementation

The concept of a dependent Parameter can be implemented using the generic "Observer" coding pattern, with all the dependent parameters being observers subscribing to the independent parameters. The update of a dependent parameter can be done using the asteval python interpreter with its functionality limited to only arithmetic and logical operation, and its symtable including only the independent parameters.

The observer pattern

The observer pattern is a fairly simple pattern including only 4 basic methods and 1 attribute:

class ConcreteSubject(ABC):
    """
    The Subject owns some important state and notifies observers when the state
    changes.
    """

    _state: int = None
    """
    For the sake of simplicity, the Subject's state, essential to all
    subscribers, is stored in this variable.
    """

    _observers: List[Observer] = []
    """
    List of subscribers. In real life, the list of subscribers can be stored
    more comprehensively (categorized by event type, etc.).
    """

    def _attach(self, observer: Observer) -> None:
        print("Subject: Attached an observer.")
        self._observers.append(observer)

    def _detach(self, observer: Observer) -> None:
        self._observers.remove(observer)

    """
    The subscription management methods.
    """

    def _notify_observers(self) -> None:
        """
        Trigger an update in each subscriber.
        """

        print("Subject: Notifying observers...")
        for observer in self._observers:
            observer._update(self)

This is the basic construct of the observed object, here namely the independent parameters. Since a dependent Parameter can use a DescriptorNumber for its relation, this part of the observer pattern should be implemented on the DescriptorNumber

class Observer(ABC):
    """
    The Observer interface declares the update method, used by subjects.
    """

    @abstractmethod
    def _update(self, subject: Subject) -> None:
        """
        Receive update from subject.
        """
        pass

Since only Parameters can be a dependent parameter, the _update method is defined in the Parameter class.

The string value evaluation with asteval

At startup, a python interpreter is created in the global_object, using asteval to limit its functionality to only arithmetic and logical expressions, to avoid many of the potential safety issues with embedded interpreters: https://lmfit.github.io/asteval/motivation.html.

The user makes a value dependent by setting its value to a string:

a = Parameter(name='a', value=2)
b = Parameter(name='b', value=3)
c = Parameter(name='best_name', value='a + b')

When a value is set by a string, the internal attribute _independent is set to False, the fixed attribute is set to True, the string is scanned for Parameters and DescriptorNumbers which are added to the astevals interpreters symtable, the _update method is called and the setters on the Parameter can no longer be used.

The _update method runs the value string expression through the asteval interpreter and sets the Parameters attributes to the output of the expression:

def update(self):
   temp = self._global_object.dependency_interpreter(self._dependency_string)
   self._scalar.value = temp.value
   self._scalar.unit = temp.unit
   self._scalar.variance = temp.variance
   self._min = temp.min
   self._max = temp.max
   self._notify_observers()

Requirements

• A dependent parameter should also be easy to change back into an independent parameter
• [Optional] It should be possible to visualize a dependency tree to get an overview of all parameter dependencies
• 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.