SbS Propagable Refactor (#490)

* save sbs_propagation ini
* separated classes

Author: JoschD

omc3/definitions/formats.py

@@ -15,7 +15,7 @@
 def get_config_filename(script):
     """Default Filename for config-files. Call from script with ``__file__``."""
     return CONFIG_FILENAME.format(
-        script=Path(script).name.split('.')[0],
+        script=Path(script).stem,
         time=datetime.now(timezone.utc).strftime(TIME)
     )
 

omc3/sbs_propagation.py

@@ -55,7 +55,6 @@
 from omc3 import model_creator
 from omc3.definitions.optics import OpticsMeasurement
 from omc3.model import manager as model_manager
-from omc3.model.model_creators.manager import get_model_creator_class, CreatorType
 from omc3.model.accelerators.accelerator import AcceleratorDefinitionError
 from omc3.model.constants import (
     ACC_MODELS_PREFIX,
@@ -64,6 +63,7 @@
     TWISS_DAT,
     TWISS_ELEMENTS_DAT,
 )
+from omc3.model.model_creators.manager import CreatorType, get_model_creator_class
 from omc3.segment_by_segment.constants import logfile
 from omc3.segment_by_segment.propagables import Propagable, get_all_propagables
 from omc3.segment_by_segment.segments import (
@@ -73,7 +73,7 @@
     SegmentModels,
 )
 from omc3.utils import logging_tools
-from omc3.utils.iotools import PathOrStr, PathOrStrOrDict
+from omc3.utils.iotools import PathOrStr, PathOrStrOrDict, save_config
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Sequence
@@ -86,7 +86,6 @@
         ModelCreator,
     )
 
-
 LOGGER = logging_tools.get_logger(__name__)
 
 
@@ -139,6 +138,7 @@ def segment_by_segment(opt: DotDict, accel_opt: dict | list) -> dict[str, Segmen
 
     accel: Accelerator = model_manager.get_accelerator(accel_opt)
     accel.model_dir = _check_output_directory(opt.output_dir, accel)
+    save_config(accel.model_dir, opt, __file__, accel_opt)
     _maybe_create_nominal_model(accel, fetcher_opts)
 
     measurement = OpticsMeasurement(opt.measurement_dir)
@@ -433,6 +433,8 @@ def _copy_files_from_model_dir(model_dir: Path, output_dir: Path) -> None:
 def _bpm_is_in_meas(bpm_name: str, meas: OpticsMeasurement) -> bool:
     """ Check if the bpm_name is in the measurement in both planes.
     Possible improvement: Check if the error is too high?
+
+    TODO: This does not work with single-plane BPM machines, such as SPS. What to do?
     """
     return bpm_name in meas.beta_phase_x.index and bpm_name in meas.beta_phase_y.index
 

omc3/segment_by_segment/constants.py

@@ -1,6 +1,6 @@
 """
-Segment by Segment: Constants
------------------------------
+Constants
+---------
 
 This module provides constants to be used with segment by segment
 """

omc3/segment_by_segment/definitions.py

@@ -1,6 +1,6 @@
 """
-Segment by Segment: Definitions 
--------------------------------
+Definitions 
+-----------
 
 This module provides definitions to be used with segment by segment
 """
@@ -11,83 +11,6 @@
 from uncertainties.core import Variable 
 from omc3.utils.math_classes import MathMixin
 
-from omc3.optics_measurements.constants import ERR
-from omc3.segment_by_segment.constants import BACKWARD, CORRECTION, EXPECTED, FORWARD
-
-
-class PropagableColumns:
-    """ Class to define columns for propagables. 
-    One could also implicitly define the error-columns,
-    either via __getattr__ or as a wrapper, but I decided to
-    explicitely name these columns, so that the IDEs can see them 
-    and can help in renaming and autocompletion (jdilly 2023).
-    """
-    def __init__(self, column: str, plane: str = "{}") -> None:
-        self._column = column
-        self._plane = plane
-
-    def planed(self, plane: str) -> PropagableColumns:
-        return PropagableColumns(self._column, plane)
-
-    @property
-    def column(self):
-        return f"{self._column}{self._plane}"
-    
-    @property
-    def error_column(self):
-        return f"{ERR}{self.column}"
-    
-    # Propagation ---
-    @property
-    def forward(self):
-        return f"{FORWARD}{self.column}"
-    
-    @property
-    def error_forward(self):
-        return f"{ERR}{self.forward}"
-    
-    @property
-    def backward(self):
-        return f"{BACKWARD}{self.column}"
-    
-    @property
-    def error_backward(self):
-        return f"{ERR}{self.backward}"
-    
-    # Correction ---
-    @property
-    def forward_correction(self):
-        return f"{CORRECTION}{self.forward}"
-
-    @property
-    def error_forward_correction(self):
-        return f"{ERR}{self.forward_correction}"
-        
-    @property
-    def backward_correction(self):
-        return f"{CORRECTION}{self.backward}"
-    
-    @property
-    def error_backward_correction(self):
-        return f"{ERR}{self.backward_correction}"
-
-    # Expectation --- 
-    @property
-    def forward_expected(self):
-        return f"{EXPECTED}{self.forward}"
-
-    @property
-    def error_forward_expected(self):
-        return f"{ERR}{self.forward_expected}"
-        
-    @property
-    def backward_expected(self):
-        return f"{EXPECTED}{self.backward}"
-    
-    @property
-    def error_backward_expected(self):
-        return f"{ERR}{self.backward_expected}"
-
 
 class Measurement(MathMixin, Variable):
     """ Alias for a uncertainties variable.
@@ -110,19 +33,6 @@ def __iter__(self):
         return iter(self.as_tuple())
 
 
-
-@dataclass 
-class PropagableBoundaryConditions:
-    """Store boundary conditions with error for propagating."""
-    alpha: Measurement = None
-    beta: Measurement = None
-    dispersion: Measurement = None
-    f1001_amplitude: Measurement = None
-    f1001_phase: Measurement = None
-    f1010_amplitude: Measurement = None
-    f1010_phase: Measurement = None
-
-
 @dataclass 
 class MadXBoundaryConditions:
     """Store all boundary conditions for a Mad-X twiss."""

omc3/segment_by_segment/math.py

@@ -1,6 +1,6 @@
 """
-Segment by Segment: Maths functions
------------------------------------
+Maths Functions
+---------------
 
 This module provides mathematical helper functions, e.g. to propagate errors.
 """
@@ -11,10 +11,12 @@
 import numpy as np
 
 if TYPE_CHECKING:
-    from omc3.segment_by_segment.definitions import PropagableBoundaryConditions
+    from omc3.segment_by_segment.propagables import PropagableBoundaryConditions
     from numpy.typing import ArrayLike
 
 
+# Error Propagation ------------------------------------------------------------
+
 def propagate_error_phase(dphi: ArrayLike, init: PropagableBoundaryConditions) -> ArrayLike:
     """Propagates the phase-error.
        See Eq. (2) in  [LangnerDevelopmentsSegmentbySegmentTechnique2015]_ .
@@ -192,8 +194,20 @@ def propagate_error_dispersion(beta: ArrayLike, dphi: ArrayLike, init: Propagabl
         (np.cos(2 * np.pi * dphi) + alpha0 * np.sin(2 * np.pi * dphi))
     )
 
+
+# Other Math -------------------------------------------------------------------
 
 def phase_diff(phase_a: ArrayLike, phase_b: ArrayLike) -> ArrayLike:
     """ Returns the phase difference between phase_a and phase_b, mapped to [-0.5, 0.5]. """
     phase_diff = (phase_a - phase_b) % 1
-    return phase_diff - np.where(phase_diff > 0.5, 1, 0)  # this way keeps input type as is (!`where` returns np.array)
+    return phase_diff - np.where(phase_diff > 0.5, 1, 0)  # this way keeps input type as is (!`where` returns np.array)
+
+
+def quadratic_add(*values):
+    """Calculate the root-sum-squared of the given values.
+    The individual "values" can be ``pd.Series`` and then their 
+    elements are summed by indexs."""
+    result = 0.
+    for value in values:
+        result += value ** 2
+    return np.sqrt(result)