New block: ionisation chamber

[RemDelaporteMathurin]

New block idea for tritium detection: ionisation chamber.

Inputs: sample in concentration, sample in flow rate
Outputs: sample out, signal

Internal parameters:

• detection efficiency

Illustration

Here I set the detection effieicny as a simple step function with a threshold of 10

[RemDelaporteMathurin]

Proposed pathsim implementation:

import pathsim.blocks as blocks
from pathsim.optim.operator import Operator


class IC(blocks.Block):
    def __init__(self, detection_efficiency=None, detection_threshold=None):
        super().__init__()

        self.detection_efficiency = detection_efficiency
        self.detection_threshold = detection_threshold

        # if both detection_efficiency and detection_threshold are provided or if they are both None
        # raise an error
        if (detection_efficiency is not None and detection_threshold is not None) or (
            detection_efficiency is None and detection_threshold is None
        ):
            raise ValueError(
                "Either detection_efficiency or detection_threshold must be provided, but not both."
            )
        if detection_threshold is not None:
            self.detection_efficiency = (
                lambda x: 1.0 if x >= detection_threshold else 0.0
            )

        self.op_alg = Operator(
            func=self.func,
            jac=self.jac,
        )

    def func(self, x):
        """Function to compute the product of all elements in x."""
        flux_in, flow_rate = x
        concentration = flux_in / flow_rate
        if callable(self.detection_efficiency):
            detection_efficiency = self.detection_efficiency(concentration)
        else:
            detection_efficiency = self.detection_efficiency

        signal = concentration * detection_efficiency
        return signal

    def jac(self, x):
        """Jacobian of the function."""
        flux_in, flow_rate = x
        concentration = flux_in / flow_rate
        if callable(self.detection_efficiency):
            detection_efficiency = self.detection_efficiency(concentration)
        else:
            detection_efficiency = self.detection_efficiency

        if self.detection_threshold:
            jacobian = [
                detection_efficiency * (-concentration / flow_rate),
                detection_efficiency * (1 / flow_rate),
            ]
            return jacobian
        else:
            return None

    def update(self, t):
        """update system equation

        Parameters
        ----------
        t : float
            evaluation time
        """
        u = self.inputs.to_array()
        self.outputs.update_from_array(self.op_alg(u))