ihmt 0.9.0__py3-none-any.whl

ihmt/__init__.py

@@ -0,0 +1,10 @@
+from ihmt.meta import Signal, Duration, Frequency, AngularFrequency, Angle, CompositeDictionary
+from ihmt.pulse import Tukey
+from ihmt.system import System
+from ihmt.sequence import Sequence
+from ihmt.simulator import Simulator
+from ihmt.corrector import Corrector
+from ihmt.trajector import Trajector
+from ihmt.run import SingleRun, GridRuns, SampledRuns
+
+from ihmt.vectorized.pulse import TukeyVector

ihmt/config.py

@@ -0,0 +1,38 @@
+from logging import getLogger, NullHandler
+from pathlib import Path
+from yaml import safe_load  # noqa: F401
+from typing import Any
+
+logger = getLogger(__name__)
+logger.addHandler(NullHandler())
+logger.debug('`config` module loaded successfully')
+
+
+default: Config
+BP_3T  : Config
+MC_3T  : Config
+BP_7T  : Config
+MC_7T  : Config
+
+
+class Config(dict):
+    def __init__(self, mapping: Any):
+        super().__init__(mapping)
+
+    def as_dict(self):
+        ...
+
+    def to_file(self):
+        ...
+
+    def __getitem__(self, subscript: str):
+        return dict.__getitem__(self, subscript)
+
+
+for file in (Path(__file__).parent / 'configs').glob('*.yaml'):
+    with open(file, 'r') as f:
+        try:
+            exec(f'{file.stem} = safe_load(f)')
+            logger.debug(f"<{file}> configuration file loaded successfully.")
+        except Exception as e:
+            logger.error(e)

ihmt/configs/default.yaml

@@ -0,0 +1,82 @@
+run:  # mandatory, provides the parameters for simulator.SingleRun
+  pw: 0.001
+  r_tukey: 0.3
+  fa_sat: 200
+  offset: 7000
+
+  FLAG_Signal: ALL
+  N_altern: 1
+  np: 4
+  nb: 10
+  turbo: 80
+  N_dummyADC: 3
+  dt: 0.0015
+  btr: 0.1
+  btrlast: 0.001
+  es: 0.006
+  tr: 3
+  fa_rage: 5
+
+  M0a: 1
+  M0b: 0.1
+  T1f: 1
+  T2f: 0.1
+  T1b: 1
+  T1D: 0.01
+  T2b: 1.e-5
+  R: 10
+  poolBound_lineshapeAsymmetry: -593.83
+
+  export_read: True
+  output_fullVector: True
+
+  outputDir: ./output/
+  filePrefix: ''
+  export: True
+
+log:  # if `log` category is undefined, no logging will happen
+  # https://docs.python.org/3/library/logging.config.html#dictionary-schema-details
+  version: 1
+  disable_existing_loggers: false
+
+  formatters:
+    standard:
+      format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+    error:
+      format: "%(asctime)s - %(name)s - %(levelname)s <PID %(process)d:%(processName)s> %(name)s.%(funcName)s(): %(message)s"
+
+  handlers:
+    root_file_handler:
+      class: logging.FileHandler
+      level: INFO  # NOTSET, DEBUG, INFO, WARNING, ERROR, CRITICAL
+      formatter: standard
+      filename: ./output/logs.txt
+      mode: w  # a: append, w: write
+      # encoding: utf8
+
+    debug_root_file_handler:
+      class: logging.FileHandler
+      level: DEBUG  # NOTSET, DEBUG, INFO, WARNING, ERROR, CRITICAL
+      formatter: error
+      filename: ./output/logs_debug.txt
+      # suffix: "%Y%m%d-%H%M%S"
+      mode: w  # a: append, w: write
+      # encoding: utf8
+
+    console:
+      class: logging.StreamHandler
+      level: INFO  # NOTSET, DEBUG, INFO, WARNING, ERROR, CRITICAL
+      formatter: standard
+      stream: ext://sys.stdout
+
+    error_console:
+      class: logging.StreamHandler
+      level: ERROR  # NOTSET, DEBUG, INFO, WARNING, ERROR, CRITICAL
+      formatter: error
+      stream: ext://sys.stderr
+
+  root:
+    level: DEBUG
+    # handlers: [console, error_console]
+    handlers: [console, error_console, root_file_handler, debug_root_file_handler]

ihmt/corrector.py

@@ -0,0 +1,223 @@
+from logging import getLogger, NullHandler
+from numpy import linspace, float64, ndarray, number, meshgrid, vstack, nan, ones
+from functools import partial
+from scipy.interpolate import PchipInterpolator, RegularGridInterpolator
+from copy import deepcopy
+
+from ihmt.meta import _Event, Signal, CompositeDictionary
+from ihmt.simulator import Simulator
+from ihmt.run import GridRuns
+
+logger = getLogger(__name__)
+logger.addHandler(NullHandler())
+logger.debug("`corrector` module loaded successfully")
+
+
+class Corrector(_Event):
+    _ranges: dict[str, ndarray[number]]
+    _simulator: Simulator
+
+    _simulated: dict[str, ndarray[number]]
+    _nominals: dict[str, float]
+    _interpolants: dict[str, PchipInterpolator | RegularGridInterpolator]
+
+    _classAttributes: tuple[str] = (
+        "ranges",
+        "simulator",
+        "simulated",
+        "mesh",
+        "nominals",
+        "interpolants",
+    )
+
+    @staticmethod
+    def Simple(simulator: Simulator) -> Corrector:
+        return Corrector(
+            simulator=simulator,
+            ranges={"flipAngle": simulator.pulse.flipAngle * linspace(0.1, 1.5, 141)},
+        )
+
+    def __init__(self, simulator: Simulator, ranges: dict[str, ndarray[number]]):
+        self.simulator = simulator
+        self.ranges = ranges
+
+        self.onChange(
+            "ranges",
+            [
+                lambda: self._reset_computed_attributes(
+                    ["simulated", "nominals", "interpolants"]
+                )
+            ],
+        )
+        self.onChange(
+            "simulator",
+            [
+                lambda: self._reset_computed_attributes(
+                    ["simulated", "nominals", "interpolants"]
+                )
+            ],
+        )
+
+    def copy(self) -> Corrector:
+        return Corrector(self.simulator.copy(), deepcopy(self.ranges))
+
+    def apply(
+        self,
+        parameter_maps: dict[str, ndarray[number]],
+        data_maps: dict[Signal, ndarray[number]],
+    ) -> CompositeDictionary[Signal, ndarray[number]]:
+        for key in self.ranges.keys():
+            if key not in parameter_maps.keys():
+                raise KeyError(f"Missing key `{key}` in parameter map dictionary.")
+
+        for key in data_maps.keys():
+            if type(key) != Signal:
+                raise TypeError(
+                    f"Accepting `{type(Signal)}` flags only. Received `{type(key)}`."
+                )
+
+        shape = None
+        for key, val in (parameter_maps | data_maps).items():
+            if shape is None:
+                shape = val.shape
+                continue
+            if val.shape != shape:
+                raise ValueError(
+                    f"Arrays need to match shape. Received shape `{val.shape}` for array `{key}` while trying to match shape `{shape}`."
+                )
+
+        mask = (
+            ones(shape).astype(bool)
+            if "mask" not in parameter_maps.keys()
+            else parameter_maps["mask"].astype(bool)
+        )
+
+        parameters = vstack(
+            [parameter_maps[key][mask].flatten() for key in self.ranges.keys()]
+        ).T
+
+        corrected: dict[Signal, ndarray[number]] = dict()
+        for key, value in data_maps.items():
+            corrected[key] = value.copy().astype(float64)
+            corrected[key][mask] *= (
+                self.nominals[key] / self.interpolants[key](parameters)
+            ).squeeze()
+
+        return CompositeDictionary(corrected)
+
+    #####
+    # BELOW: property getters and setters
+    #####
+    @property
+    def ranges(self) -> dict[str, ndarray[number]]:
+        return self._ranges
+
+    @ranges.setter
+    def ranges(self, val: dict[str, ndarray[number]]):
+        self._ranges = deepcopy(val)
+        for val in self._ranges.values():
+            val.setflags(write=False)
+        self._changed("ranges")
+
+    @property
+    def simulator(self) -> Simulator:
+        return self._simulator
+
+    @simulator.setter
+    def simulator(self, val: Simulator):
+        self._simulator = val
+        self._changed("simulator")
+
+    @property  # immutable for the user, so only getter is defined
+    def simulated(self) -> CompositeDictionary[str, ndarray[number]]:
+        if not hasattr(self, "_simulated"):
+            sim = self.simulator.copy()
+            sim.output_vectorSlice = slice(1)
+            sim.export_readMatrix = False
+            self._simulated = CompositeDictionary(
+                GridRuns(sim, list(self.ranges.keys()), self.ranges, safe=True)
+            ).squeeze()
+        return self._simulated
+
+    @property  # immutable for the user, so only getter is defined
+    def mesh(self) -> dict[str, ndarray[number]]:
+        if not hasattr(self, "_mesh"):
+            tmp = dict()
+            mesh = meshgrid(*list(self.ranges.values()), indexing="ij", sparse=True)
+            for key, val in zip(self.ranges.keys(), mesh):
+                tmp[key] = val
+                tmp[key].setflags(write=False)
+            self._mesh = tmp
+        return self._mesh
+
+    @property  # immutable for the user, so only getter is defined
+    def nominals(self) -> CompositeDictionary[str, float]:
+        if not hasattr(self, "_nominals"):
+            tmp = self.simulator.output_vectorSlice
+            self.simulator.output_vectorSlice = slice(1)
+            self._nominals = CompositeDictionary(self.simulator.SteadyState())
+            self.simulator.output_vectorSlice = tmp
+        return self._nominals
+
+    @property  # immutable for the user, so only getter is defined
+    def interpolants(self):
+        if not hasattr(self, "_interpolants"):
+            self._interpolants = InterpolantDictionary(
+                interpolator=(
+                    PchipInterpolator
+                    if len(self.ranges) == 1
+                    else partial(
+                        RegularGridInterpolator, bounds_error=False, fill_value=nan
+                    )
+                ),
+                ranges=self.ranges,
+                simulated=self.simulated,
+            )
+        return self._interpolants
+
+
+class InterpolantDictionary(dict):
+    def __init__(
+        self,
+        interpolator: PchipInterpolator | RegularGridInterpolator,
+        ranges: dict[str, ndarray[number]],
+        simulated: CompositeDictionary[str, ndarray[number]],
+    ):
+        self._interpolator = interpolator
+        self._ranges = tuple(ranges.values())
+        self._simulated = simulated
+
+        if len(self._ranges) == 1:
+            self._ranges = tuple(self._ranges[0].tolist())
+
+        super().__init__()
+
+    def __getitem__(self, subscript: Signal):
+        if type(subscript) != Signal:
+            raise TypeError(
+                f"Accepting `{type(Signal)}` flags only. Received `{type(subscript)}`."
+            )
+
+        if subscript == Signal.ALL:
+            for subscript in Signal.values():
+                if (subscript != Signal.ALL) and (subscript not in self.keys()):
+                    try:
+                        dict.__setitem__(
+                            self,
+                            subscript,
+                            self._interpolator(
+                                self._ranges, self._simulated[subscript]
+                            ),
+                        )
+                    except Exception as _:
+                        pass
+            return self
+
+        elif (subscript not in self.keys()) and (subscript in Signal.values()):
+            dict.__setitem__(
+                self,
+                subscript,
+                self._interpolator(self._ranges, self._simulated[subscript]),
+            )
+
+        return dict.__getitem__(self, subscript)