cgse-common 2023.1.4__py3-none-any.whl → 2024.1.4__py3-none-any.whl

egse/calibration.py

@@ -0,0 +1,250 @@
+import numpy as np
+
+from egse.setup import NavigableDict, Setup, SetupError
+
+
+def apply_gain_offset(counts: float, gain: float, offset: float) -> float:
+    """ Applies the given gain and offset to the given counts.
+
+    Args:
+        counts: Uncalibrated, raw data [ADU]
+        gain: Gain to apply
+        offset: Offset to apply
+
+    Returns: Counts after applying the given gain and offset.
+    """
+
+    return counts * gain + offset
+
+#########################
+# Temperature calibration
+#########################
+
+
+def counts_to_temperature(sensor_name: str, counts: float, sensor_info: NavigableDict, setup: Setup):
+    """ Converts the given counts for the given sensor to temperature.
+
+    This conversion can be done as follows:
+
+        - (1) Directly from counts to temperature, by applying the gain and offset;
+        - (2) Directly from counts to temperature, by applying a function;
+        - (3) From counts, via resistance, to temperature.
+
+    Args:
+        sensor_name: Sensor name
+        counts: Uncalibrated, raw data [ADU]
+        sensor_info: Calibration information for the given sensor (type)
+        setup: Setup
+
+    Returns: Calibrated temperature [°C] for the given sensor
+    """
+
+    # (1) Conversion: temperature = counts * gain + offset
+
+    if "counts_to_temperature_gain" in sensor_info and "counts_to_temperature_offset" in sensor_info:
+
+        return apply_gain_offset(counts,
+                                 gain=eval(str(sensor_info.counts_to_temperature_gain)),
+                                 offset=sensor_info.counts_to_temperature_offset)
+
+    # (2) Conversion: temperature = func(counts)
+
+    if "counts_to_temperature" in sensor_info:
+
+        # (2a) Polynomial
+
+        if sensor_info.counts_to_temperature.method == "polynomial":
+            return np.polyval(sensor_info.counts_to_temperature.counts_to_temperature_coefficients, counts)
+
+    # (3) Conversion: counts -> resistance -> temperature
+
+    else:
+        resistance = counts_to_resistance(sensor_name, counts, sensor_info)
+        return resistance_to_temperature(sensor_name, resistance, sensor_info, setup)
+
+
+def counts_to_resistance(sensor_name: str, counts: float, sensor_info: NavigableDict):
+    """ Converts the given counts for the given sensor to resistance.
+
+    Args:
+        sensor_name: Sensor name
+        counts: Uncalibrated, raw data [ADU]
+        sensor_info: Calibration information for the given sensor (type)
+
+    Returns: Resistance [Ohm] for the given sensor.
+    """
+
+    # Offset (if any)
+
+    counts_to_resistance_offset = sensor_info.counts_to_resistance_offset \
+        if "counts_to_resistance_offset" in sensor_info \
+        else 0
+
+    # Conversion: counts -> voltage -> resistance
+
+    if "counts_to_voltage_gain" in sensor_info and "voltage_to_resistance_gain" in sensor_info:
+
+        return apply_gain_offset(counts,
+                                 gain=sensor_info.counts_to_voltage_gain * sensor_info.voltage_to_resistance_gain,
+                                 offset=counts_to_resistance_offset)
+
+    # Conversion: counts -> resistance
+
+    elif "counts_to_resistance_gain" in sensor_info:
+
+        return apply_gain_offset(counts,
+                                 gain=sensor_info.counts_to_resistance_gain,
+                                 offset=counts_to_resistance_offset)
+
+    raise SetupError(f"Setup does not contain info for conversion from counts to resistance for {sensor_name}")
+
+
+def resistance_to_temperature(sensor_name: str, resistance: float, sensor_info: NavigableDict, setup: Setup):
+    """ Converts the given resistance for the given sensor to temperature.
+
+    Args:
+        sensor_name: Sensor name
+        resistance: Resistance [Ohm]
+        sensor_info: Calibration information for the given sensor (type)
+        setup: Setup
+
+    Returns: Temperature [°C] for the given sensor.
+    """
+
+    resistance_to_temperature_info = sensor_info.resistance_to_temperature
+
+    # Series resistance (if any)
+
+    if "series_resistance" in resistance_to_temperature_info:
+
+        series_resistance = resistance_to_temperature_info.series_resistance
+        if sensor_name in resistance_to_temperature_info:
+            series_resistance = series_resistance[sensor_name]
+        resistance -= series_resistance
+
+    method: str = resistance_to_temperature_info.method
+
+    if "divide_resistance_by" in resistance_to_temperature_info:
+        resistance /= resistance_to_temperature_info.divide_resistance_by
+
+    # Polynomial
+
+    if method == "polynomial":
+
+        # Coefficients given for conversion temperature -> resistance
+
+        if "temperature_to_resistance_coefficients" in resistance_to_temperature_info:
+            return solve_temperature(resistance_to_temperature_info.temperature_to_resistance_coefficients, resistance)
+
+        # Coefficients given for conversion resistance -> temperature
+
+        if "resistance_to_temperature_coefficients" in resistance_to_temperature_info:
+            return np.polyval(resistance_to_temperature_info.resistance_to_temperature_coefficients, resistance)
+
+    elif method == "callendar_van_dusen":
+
+        standard = resistance_to_temperature_info.standard
+        ref_resistance = resistance_to_temperature_info.ref_resistance
+
+        return callendar_van_dusen(resistance, ref_resistance, standard, setup)
+
+    else:
+        raise SetupError(f"Setup does not contain info for conversion from resistance to temperature for {sensor_name}")
+
+
+def solve_temperature(temperature_to_resistance_coefficients, resistance: float):
+    """ Solves the temperature from the temperature -> resistance polynomial.
+
+    For the given temperature -> resistance polynomial and the given resistance, we determine what the corresponding
+    temperature is by:
+
+        - Finding the roots of polynomial(temperature) = resistance;
+        - Discarding the roots with an imaginary component;
+        - Selecting the remaining root in the relevant temperature regime (here: [-200°C, 200°C]).
+    """
+
+    temperature_to_resistance_poly = np.poly1d(temperature_to_resistance_coefficients)
+    temperatures = (temperature_to_resistance_poly - resistance).roots
+
+    for temperature in temperatures:
+        if temperature.imag == 0 and -200 <= temperature <= 200:
+            return temperature.real
+
+
+def callendar_van_dusen(resistance: float, ref_resistance: float, standard: str, setup: Setup):
+    """ Solves the Callendar - van Dusen equation for temperature.
+
+    Args:
+        resistance: Resistance [Ohm] for which to calculate the temperature
+        ref_resistance: Resistance [Ohm] for a temperature of 0°C
+        standard: Sensor standard
+        setup: Setup
+
+    Returns: Temperature [°C] corresponding to the given resistance.
+    """
+
+    # Resistances higher than the reference resistance correspond to
+
+    coefficients = setup.sensor_calibration.callendar_van_dusen[standard]
+
+    # Positive temperatures
+
+    if resistance >= ref_resistance:
+        resistance_to_temperature_coefficients = [ref_resistance * coefficients.C,
+                                                  -ref_resistance * 100 * coefficients.C,
+                                                  ref_resistance * coefficients.B,
+                                                  ref_resistance * coefficients.A, ref_resistance * 1]
+
+    # Negative temperatures
+
+    else:
+        resistance_to_temperature_coefficients = [ref_resistance * coefficients.B,
+                                                  ref_resistance * coefficients.A,
+                                                  ref_resistance * 1]
+
+    return solve_temperature(resistance_to_temperature_coefficients, resistance)
+
+
+def chebychev(resistance: float, sensor_info: NavigableDict):
+    """ Solves the Chebychev equation for temperature.
+
+    Implemented as specified in the calibration certificate of the LakeShore Cernox sensors.
+
+    Args:
+        resistance:Resistance [Ohm] for which to calculate the temperature
+        sensor_info: Calibration information
+
+    Returns: Temperature [°C] corresponding to the given resistance.
+    """
+
+    num_fit_ranges = sensor_info.num_fit_ranges
+
+    for fit_range_index in range(1, num_fit_ranges + 1):
+
+        range_info = sensor_info[f"range{fit_range_index}"]
+
+        resistance_lower_limit, resistance_upper_limit = range_info.resistance_range
+
+        if resistance_lower_limit <= resistance <= resistance_upper_limit:
+
+            if range_info.fit_type == "LOG":
+                z = np.log10(resistance)
+
+            zl, zu = range_info.z_range
+            order = range_info.order
+            coefficients = range_info.coefficients
+
+            temperature = 0
+
+            for index in range(0, order + 1):
+
+                k = ((z-zl)-(zu-z))/(zu-zl)
+                temperature += coefficients[index] * np.cos(index * np.arccos(k))
+
+            return temperature
+
+############################
+# Supply voltage calibration
+############################
+
+# TODO

egse/command.py

@@ -87,6 +87,7 @@ Do we need additional hooks into this commanding?
 * provide an execute method for the CommandExecution that executes the command
   with the saved parameters
 """
+
 import functools
 import inspect
 import logging
@@ -149,7 +150,6 @@ def dry_run(func: Callable) -> Callable:
 
     @functools.wraps(func)
     def func_wrapper(self, *args, **kwargs):
-
         from egse.state import GlobalState  # prevent circular import
 
         if GlobalState.dry_run:
@@ -167,9 +167,7 @@ def dry_run(func: Callable) -> Callable:
             else:
                 FunctionExecution = namedtuple("FunctionExecution", ["name", "args", "kwargs"])
                 GlobalState.add_command(FunctionExecution(func.__name__, args, kwargs))
-            return Success(
-                "Command execution appended to command sequence, function not executed in dry_run."
-            )
+            return Success("Command execution appended to command sequence, function not executed in dry_run.")
         else:
             return func(self, *args, **kwargs)
 
@@ -206,8 +204,7 @@ def parse_format_string(fstring):
 
     # If this assertion fails, there is a flaw in the algorithm above
     assert tot_n_args == n_args + n_kwargs, (
-        f"Total number of arguments ({tot_n_args}) doesn't match # args ({n_args}) + "
-        f"# kwargs ({n_kwargs})."
+        f"Total number of arguments ({tot_n_args}) doesn't match # args ({n_args}) + # kwargs ({n_kwargs})."
     )
 
     if n_args > 0 and n_kwargs > 0:
@@ -291,9 +288,7 @@ class InvalidCommandExecution(CommandExecution):
         self._exc = exc
 
     def run(self):
-        raise InvalidArgumentsError(
-            f"The command {self.get_name()} can not be executed. Reason: {self._exc}"
-        )
+        raise InvalidArgumentsError(f"The command {self.get_name()} can not be executed. Reason: {self._exc}")
 
     def __str__(self):
         msg = super().__str__()
@@ -307,7 +302,6 @@ class WaitCommand:
         self._condition = condition
 
     def __call__(self):
-
         # .. todo:: do we need a timeout possibility here?
 
         while True:
@@ -330,10 +324,7 @@ class Command:
     Arguments can be positional or keyword arguments, not both.
     """
 
-    def __init__(
-            self, name, cmd, response=None, wait=None, check=None, description=None,
-            device_method=None
-    ):
+    def __init__(self, name, cmd, response=None, wait=None, check=None, description=None, device_method=None):
         self._name = name
         self._cmd = cmd
         self._response = response
@@ -362,7 +353,6 @@ class Command:
         return msg
 
     def validate_arguments(self, *args, **kwargs):
-
         # Special case for commands with *args or **kwargs, we don't validate
 
         if self._cmd in ("*", "**"):
@@ -373,8 +363,7 @@ class Command:
 
         if self._tot_n_args != nargs + nkwargs:
             raise InvalidArgumentsError(
-                f"Expected {self._tot_n_args} arguments for command {self._name}, "
-                f"got {nargs + nkwargs} arguments."
+                f"Expected {self._tot_n_args} arguments for command {self._name}, got {nargs + nkwargs} arguments."
             )
 
         if self._tot_n_args == 0:
@@ -414,7 +403,6 @@ class Command:
         return self._device_method.__name__
 
     def get_command_execution(self, *args, **kwargs):
-
         return CommandExecution(self, *args, **kwargs)
 
     def __call__(self, *args, **kwargs):
@@ -444,8 +432,7 @@ class Command:
 
         if self._tot_n_args != nargs + nkwargs:
             raise CommandError(
-                f"Expected {self._tot_n_args} arguments for command {self._name}, "
-                f"got {nargs + nkwargs} arguments."
+                f"Expected {self._tot_n_args} arguments for command {self._name}, got {nargs + nkwargs} arguments."
             )
 
         if self._tot_n_args == 0:
@@ -539,17 +526,13 @@ class ClientServerCommand(Command):
         # the class instances are not known at the other side.
 
         if self._response.__name__ == "handle_device_method":
-
             # call the handle_device_method of the Protocol sub-class
 
-            logger.log(0,
-                       f"Executing Command {self._response.__name__}({other!r}, "
-                       f"{self!r}, {args}, {kwargs})")
+            logger.log(0, f"Executing Command {self._response.__name__}({other!r}, {self!r}, {args}, {kwargs})")
 
             rc = self._response(other, self, *args, **kwargs)
         else:
-            logger.log(0,
-                       f"Executing Command {self._response.__name__}({other!r}, {args}, {kwargs})")
+            logger.log(0, f"Executing Command {self._response.__name__}({other!r}, {args}, {kwargs})")
 
             rc = self._response(other, *args, **kwargs)
 
@@ -615,9 +598,7 @@ def get_function(parent_class, method_name: str):
             return func
         logger.warning(f"{method_name} is not a function, type={type(func)}")
     else:
-        logger.warning(
-            f"{parent_class.__module__}.{parent_class.__name__} has no method called {method_name}"
-        )
+        logger.warning(f"{parent_class.__module__}.{parent_class.__name__} has no method called {method_name}")
 
     return None
 

egse/config.py

@@ -20,8 +20,10 @@ from typing import Union
 
 import git
 
-HERE = Path(__file__).parent.resolve()
-MODULE_LOGGER = logging.getLogger(__name__)
+from egse.decorators import deprecate
+
+_HERE = Path(__file__).parent.resolve()
+_LOGGER = logging.getLogger(__name__)
 
 
 def find_first_occurrence_of_dir(pattern: str, root: Path | str = None) -> Optional[Path]:
@@ -43,7 +45,7 @@ def find_first_occurrence_of_dir(pattern: str, root: Path | str = None) -> Optio
     """
     import fnmatch
 
-    root = Path(root).resolve() if root else HERE
+    root = Path(root).resolve() if root else _HERE
     if not root.is_dir():
         root = root.parent
 
@@ -130,7 +132,7 @@ def find_dirs(pattern: str, root: str = None):
                 yield Path(path) / name
 
 
-def find_files(pattern: str, root: str = None, in_dir: str = None):
+def find_files(pattern: str, root: PurePath | str = None, in_dir: str = None):
     """
     Generator for returning file paths from a top folder, matching the pattern.
 
@@ -171,7 +173,7 @@ def find_files(pattern: str, root: str = None, in_dir: str = None):
 
 def find_file(name: str, root: str = None, in_dir: str = None) -> Optional[Path]:
     """
-    Find the path to the given file starting from the root directory of the Common-EGSE
+    Find the path to the given file starting from the root directory of the
     distribution.
 
     Note that if there are more files with the given name found in the distribution,
@@ -202,7 +204,7 @@ def find_file(name: str, root: str = None, in_dir: str = None) -> Optional[Path]
 
 
 def find_root(
-    path: Union[str, PurePath], tests: Tuple[str, ...] = (), default: str = None
+    path: Union[str, PurePath] | None, tests: Tuple[str, ...] = (), default: str = None
 ) -> Union[PurePath, None]:
     """
     Find the root folder based on the files in ``tests``.
@@ -240,6 +242,8 @@ def find_root(
 
 
 @lru_cache(maxsize=16)
+@deprecate(reason="the concept of CGSE root doesn't exist in a monorepo.",
+           alternative="a case-by-case alternative.")
 def get_common_egse_root(path: Union[str, PurePath] = None) -> Optional[PurePath]:
     """
     Returns the absolute path to the installation directory for the Common-EGSE.
@@ -266,7 +270,7 @@ def get_common_egse_root(path: Union[str, PurePath] = None) -> Optional[PurePath
     if path is not None:
         return find_root(path, tests=_TEST_NAMES)
 
-    egse_path: Union[str, PurePath, None] = os.getenv("PLATO_COMMON_EGSE_PATH")
+    egse_path: Union[str, PurePath, None] = os.getenv("COMMON_EGSE_PATH")
 
     if egse_path is None:
 
@@ -285,13 +289,13 @@ def get_common_egse_root(path: Union[str, PurePath] = None) -> Optional[PurePath
             git_root = git_repo.git.rev_parse("--show-toplevel")
             egse_path = git_root
         except (git.exc.InvalidGitRepositoryError, git.exc.NoSuchPathError):
-            MODULE_LOGGER.info("no git repository found, assuming installation from distribution.")
+            _LOGGER.info("no git repository found, assuming installation from distribution.")
             egse_path = find_root(_THIS_FILE_LOCATION, tests=_TEST_NAMES)
 
-        MODULE_LOGGER.debug(f"Common-EGSE location is automatically determined: {egse_path}.")
+        _LOGGER.debug(f"Common-EGSE location is automatically determined: {egse_path}.")
 
     else:
-        MODULE_LOGGER.debug(
+        _LOGGER.debug(
             f"Common-EGSE location determined from environment variable "
             f"PLATO_COMMON_EGSE_PATH: {egse_path}"
         )
@@ -368,7 +372,8 @@ def set_logger_levels(logger_levels: List[Tuple] = None):
 
 
 class WorkingDirectory:
-    """WorkingDirectory is a context manager to temporarily change the working directory while
+    """
+    WorkingDirectory is a context manager to temporarily change the working directory while
     executing some code.
 
     This context manager has a property `path` which returns the absolute path of the
@@ -402,7 +407,7 @@ class WorkingDirectory:
         try:
             os.chdir(self._current_dir)
         except OSError as exc:
-            MODULE_LOGGER.warning(f"Change back to previous directory failed: {exc}")
+            _LOGGER.warning(f"Change back to previous directory failed: {exc}")
 
     @property
     def path(self):

egse/control.py

@@ -5,7 +5,6 @@ import abc
 import logging
 import pickle
 import threading
-import time
 from typing import Any
 
 import zmq
@@ -63,86 +62,6 @@ def is_control_server_active(endpoint: str = None, timeout: float = 0.5) -> bool
     return return_code
 
 
-class Response:
-    """Base class for any reply or response between client-server communication.
-
-    The idea is that the response is encapsulated in one of the subclasses depending
-    on the type of response.
-    """
-
-    def __init__(self, message: str):
-        self.message = message
-
-    def __str__(self):
-        return self.message
-
-    @property
-    def successful(self):
-        """Returns True if the Response is not an Exception."""
-        return not isinstance(self, Exception)
-
-
-class Failure(Response, Exception):
-    """A failure response indicating something went wrong at the other side.
-
-    This class is used to encapsulate an Exception that was caught and needs to be
-    passed to the client. So, the intended use is like this:
-    ```
-    try:
-        # perform some useful action that might raise an Exception
-    except SomeException as exc:
-        return Failure("Our action failed", exc)
-    ```
-    The client can inspect the Exception that was originally raised, in this case `SomeException`
-    with the `cause` variable.
-
-    Since a Failure is also an Exception, the property `successful` will return False.
-    So, the calling method can test for this easily.
-
-    ```
-    rc: Response = function_that_returns_a_response()
-
-    if not rc.successful:
-        # handle the failure
-    else:
-        # handle success
-    ```
-
-    """
-
-    def __init__(self, message: str, cause: Exception = None):
-        msg = f"{message}: {cause}" if cause is not None else message
-        super().__init__(msg)
-        self.cause = cause
-
-
-class Success(Response):
-    """A success response for the client.
-
-    The return code from any action or function that needs to be returned to the
-    client shall be added.
-
-    Since `Success` doesn't inherit from `Exception`, the property `successful` will return True.
-    """
-
-    def __init__(self, message: str, return_code: Any = None):
-        msg = f"{message}: {return_code}" if return_code is not None else message
-        super().__init__(msg)
-        self.return_code = return_code
-
-
-class Message(Response):
-    """A message response from the client.
-
-    Send a Message when there is no Failure, but also no return code. This is the alternative of
-    returning a None.
-
-    Message returns True for the property successful since it doesn't inherit from Exception.
-    """
-
-    pass
-
-
 class ControlServer(metaclass=abc.ABCMeta):
     """
     The base class for all device control servers and for the Storage Manager and Configuration

egse/decorators.py

@@ -13,7 +13,7 @@ from typing import Optional
 from egse.settings import Settings
 from egse.system import get_caller_info
 
-MODULE_LOGGER = logging.getLogger(__name__)
+_LOGGER = logging.getLogger(__name__)
 
 
 def static_vars(**kwargs):
@@ -95,7 +95,7 @@ def timer(*, level: int = logging.INFO, precision: int = 4):
             value = func(*args, **kwargs)
             end_time = time.perf_counter()
             run_time = end_time - start_time
-            MODULE_LOGGER.log(level, f"Finished {func.__name__!r} in {run_time:.{precision}f} secs")
+            _LOGGER.log(level, f"Finished {func.__name__!r} in {run_time:.{precision}f} secs")
             return value
 
         return wrapper_timer
@@ -160,9 +160,9 @@ def debug(func):
             args_repr = [repr(a) for a in args]
             kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
             signature = ", ".join(args_repr + kwargs_repr)
-            MODULE_LOGGER.debug(f"Calling {func.__name__}({signature})")
+            _LOGGER.debug(f"Calling {func.__name__}({signature})")
             value = func(*args, **kwargs)
-            MODULE_LOGGER.debug(f"{func.__name__!r} returned {value!r}")
+            _LOGGER.debug(f"{func.__name__!r} returned {value!r}")
         else:
             value = func(*args, **kwargs)
         return value
@@ -240,10 +240,10 @@ def profile(func):
             signature = ", ".join(args_repr + kwargs_repr)
             caller = get_caller_info(level=2)
             prefix = f"PROFILE[{profile.counter}]: "
-            MODULE_LOGGER.info(f"{prefix}Calling {func.__name__}({signature})")
-            MODULE_LOGGER.info(f"{prefix}    from {caller.filename} at {caller.lineno}.")
+            _LOGGER.info(f"{prefix}Calling {func.__name__}({signature})")
+            _LOGGER.info(f"{prefix}    from {caller.filename} at {caller.lineno}.")
             value = func(*args, **kwargs)
-            MODULE_LOGGER.info(f"{prefix}{func.__name__!r} returned {value!r}")
+            _LOGGER.info(f"{prefix}{func.__name__!r} returned {value!r}")
             profile.counter -= 1
         else:
             value = func(*args, **kwargs)
@@ -257,7 +257,7 @@ def to_be_implemented(func):
 
     @functools.wraps(func)
     def wrapper_tbi(*args, **kwargs):
-        MODULE_LOGGER.warning(f"The function/method {func.__name__} is not yet implemented.")
+        _LOGGER.warning(f"The function/method {func.__name__} is not yet implemented.")
         return func(*args, **kwargs)
 
     return wrapper_tbi

egse/device.py

@@ -12,8 +12,10 @@ class DeviceConnectionState(IntEnum):
     """Defines connection states for device connections."""
 
     # We do not use zero '0' as the connected state to prevent a state to be set
-    # to connected by default without it explicitly being set.
+    # to connected by default without it explicitly being set. Therefore, 0 will
+    # be the state where the connection is not explicitly set.
 
+    DEVICE_CONNECTION_NOT_SET = 0
     DEVICE_CONNECTED = 1
     DEVICE_NOT_CONNECTED = 2