Implemented new CFM holder API

pyaml/accelerator.py

@@ -6,8 +6,8 @@
 
 from .arrays.array import ArrayConfig
 from .common.element import Element, __pyaml_repr__
-from .common.element_holder import ElementHolder
 from .common.exception import PyAMLConfigException
+from .common.holders.element_holder import ElementHolder
 from .configuration import ConfigurationManager, UnsupportedConfigurationRootError
 from .configuration.factory import Factory
 from .control.controlsystem import ControlSystem

pyaml/apidoc/gen_api.py

@@ -26,23 +26,25 @@
     "pyaml.common.abstract_aggregator",
     "pyaml.common.constants",
     "pyaml.common.element",
-    "pyaml.common.element_holder",
     "pyaml.common.exception",
-    "pyaml.magnet.csvcurve",
-    "pyaml.magnet.csvmatrix",
-    "pyaml.magnet.curve",
+    "pyaml.common.holders.element_holder",
+    "pyaml.common.holders.magnet_holder",
+    "pyaml.common.holders.magnets_holder",
+    "pyaml.common.holders.serialized_magnet_holder",
+    "pyaml.common.holders.serialized_magnets_holder",
+    "pyaml.common.holders.combinded_function_magnet_holder",
+    "pyaml.common.holders.combinded_function_magnets_holder",
     "pyaml.configuration.factory",
     "pyaml.configuration.fileloader",
-    "pyaml.magnet.inline_curve",
-    "pyaml.magnet.inline_matrix",
     "pyaml.configuration.manager",
-    "pyaml.magnet.matrix",
+    "pyaml.configuration.restfetcher",
+    "pyaml.configuration.unbound_element",
     "pyaml.control.abstract_impl",
     "pyaml.control.controlsystem",
     "pyaml.control.deviceaccess",
     "pyaml.control.deviceaccesslist",
     "pyaml.control.readback_value",
-    "pyaml.tuning_tools.chromaticity_monitor",
+    "pyaml.diagnostics.atune_monitor",
     "pyaml.diagnostics.tune_monitor",
     "pyaml.external.pySC_interface",
     "pyaml.lattice.abstract_impl",
@@ -52,40 +54,57 @@
     "pyaml.lattice.simulator",
     "pyaml.magnet.cfm_magnet",
     "pyaml.magnet.corrector",
+    "pyaml.magnet.linear_cfm_model",
+    "pyaml.magnet.linear_model",
+    "pyaml.magnet.linear_serialized_model",
     "pyaml.magnet.function_mapping",
     "pyaml.magnet.hcorrector",
     "pyaml.magnet.identity_cfm_model",
     "pyaml.magnet.identity_model",
-    "pyaml.magnet.linear_cfm_model",
-    "pyaml.magnet.linear_model",
-    "pyaml.magnet.linear_serialized_model",
     "pyaml.magnet.magnet",
+    "pyaml.magnet.serialized_magnet",
+    "pyaml.magnet.spline_model",
     "pyaml.magnet.model",
     "pyaml.magnet.octupole",
     "pyaml.magnet.quadrupole",
-    "pyaml.magnet.serialized_magnet",
     "pyaml.magnet.sextupole",
     "pyaml.magnet.skewoctu",
     "pyaml.magnet.skewquad",
     "pyaml.magnet.skewsext",
-    "pyaml.magnet.spline_model",
     "pyaml.magnet.vcorrector",
+    "pyaml.magnet.csvcurve",
+    "pyaml.magnet.csvmatrix",
+    "pyaml.magnet.curve",
+    "pyaml.magnet.inline_curve",
+    "pyaml.magnet.inline_matrix",
+    "pyaml.magnet.matrix",
     "pyaml.rf.rf_plant",
     "pyaml.rf.rf_transmitter",
     # "pyaml.tuning_tools.LOCO.loco",
     # "pyaml.tuning_tools.SOFB.sofb",
+    "pyaml.tuning_tools.chromaticity",
+    "pyaml.tuning_tools.measurement_tool",
+    "pyaml.tuning_tools.chromaticity_response_matrix",
     "pyaml.tuning_tools.dispersion",
+    "pyaml.tuning_tools.response_matrix_data",
     "pyaml.tuning_tools.orbit",
     "pyaml.tuning_tools.orbit_response_matrix",
-    "pyaml.tuning_tools.chromaticity",
-    "pyaml.tuning_tools.tune",
-    "pyaml.tuning_tools.chromaticity_response_matrix",
-    "pyaml.tuning_tools.measurement_tool",
     "pyaml.tuning_tools.orbit_response_matrix_data",
-    "pyaml.tuning_tools.response_matrix_data",
+    "pyaml.tuning_tools.chromaticity_monitor",
+    "pyaml.tuning_tools.tune",
     "pyaml.tuning_tools.tune_response_matrix",
     "pyaml.tuning_tools.tuning_tool",
+    "pyaml.tuning_tools.bba",
+    "pyaml.tuning_tools.bba2",
     "pyaml.yellow_pages",
+    "pyaml._version",
+    "pyaml.validation.configuration_models",
+    "pyaml.validation.errors",
+    "pyaml.validation.generator",
+    "pyaml.validation.registry",
+    "pyaml.validation.schema_builder",
+    "pyaml.validation.validation_models",
+    "pyaml.validation.validator",
 ]
 
 

pyaml/arrays/array.py

@@ -5,7 +5,7 @@
 from pyaml.common.exception import PyAMLException
 
 from ..common.element import __pyaml_repr__
-from ..common.element_holder import ElementHolder
+from ..common.holders.element_holder import ElementHolder
 from ..validation import DynamicValidation, register_schema
 
 

pyaml/arrays/bpm.py

@@ -1,4 +1,4 @@
-from ..common.element_holder import ElementHolder
+from ..common.holders.element_holder import ElementHolder
 from ..validation import DynamicValidation, register_schema
 from .array import ArrayConfig
 

pyaml/arrays/cfm_magnet.py

@@ -1,4 +1,4 @@
-from ..common.element_holder import ElementHolder
+from ..common.holders.element_holder import ElementHolder
 from ..validation import DynamicValidation, register_schema
 from .array import ArrayConfig
 
@@ -36,4 +36,4 @@ def fill_array(self, holder: ElementHolder):
         holder : ElementHolder
             The element holder to populate with combined function magnet array
         """
-        holder.fill_cfm_magnet_array(self._name, self._elements)
+        holder.combined_function_magnets.add(self._name, self._elements)

pyaml/arrays/element.py

@@ -1,4 +1,4 @@
-from ..common.element_holder import ElementHolder
+from ..common.holders.element_holder import ElementHolder
 from ..validation import DynamicValidation, register_schema
 from .array import ArrayConfig
 

pyaml/arrays/element_array.py

@@ -12,7 +12,7 @@
 from ..magnet.serialized_magnet import SerializedMagnets
 
 if TYPE_CHECKING:
-    from ..common.element_holder import ElementHolder
+    from ..common.holders.element_holder import ElementHolder
 
 
 class ElementArray(list[Element]):

pyaml/arrays/magnet.py

@@ -1,4 +1,4 @@
-from ..common.element_holder import ElementHolder
+from ..common.holders.element_holder import ElementHolder
 from ..validation import DynamicValidation, register_schema
 from .array import ArrayConfig
 

pyaml/arrays/serialized_magnet.py

@@ -1,4 +1,4 @@
-from ..common.element_holder import ElementHolder
+from ..common.holders.element_holder import ElementHolder
 from ..validation import DynamicValidation, register_schema
 from .array import ArrayConfig
 

pyaml/common/element.py

@@ -5,7 +5,7 @@
 from .exception import PyAMLException
 
 if TYPE_CHECKING:
-    from ..common.element_holder import ElementHolder
+    from .holders.element_holder import ElementHolder
 
 
 def __pyaml_repr__(obj, exclude: list[str] | None = None):

pyaml/common/holders/combinded_function_magnet_holder.py

@@ -0,0 +1,39 @@
+from typing import TYPE_CHECKING
+
+from ...magnet.cfm_magnet import CombinedFunctionMagnet
+
+if TYPE_CHECKING:
+    from .element_holder import ElementHolder
+
+
+class CombinedFunctionMagnetHolder:
+    def __init__(self, peer: "ElementHolder"):
+        self._peer = peer
+
+    def all(self) -> list[CombinedFunctionMagnet]:
+        """
+        Returns all combined function magnets as a list
+        """
+        return [value for key, value in self._peer._CFM_MAGNETS.items()]
+
+    def get(self, name: str) -> CombinedFunctionMagnet:
+        """
+        Returns the specified combined function magnet
+
+        Parameters
+        ----------
+        name : str
+            Name of the magnet
+        """
+        return self._peer._get("Combined function magnet", name, self._peer._CFM_MAGNETS)
+
+    def add(self, m: CombinedFunctionMagnet):
+        """
+        Adds the specified combined function magnet to the holder
+
+        Parameters
+        ----------
+        m : Magnet
+           Magnet to be added
+        """
+        self._peer._add(self._peer._CFM_MAGNETS, m)

pyaml/common/holders/combinded_function_magnets_holder.py

@@ -0,0 +1,47 @@
+from typing import TYPE_CHECKING
+
+from ...arrays.cfm_magnet_array import CombinedFunctionMagnetArray
+
+if TYPE_CHECKING:
+    from .element_holder import ElementHolder
+
+
+class CombinedFunctionMagnetsHolder:
+    def __init__(self, peer: "ElementHolder"):
+        self._peer = peer
+
+    def get(self, name: str = None) -> CombinedFunctionMagnetArray:
+        """
+        Returns the specified conbined function magnet array or all combined function magnets if no name specified
+
+        Parameters
+        ----------
+        name : str
+            Name of the combined function magnet array
+        """
+        if name is None:
+            return CombinedFunctionMagnetArray("", self._peer.combined_function_magnet.all())
+        else:
+            return self._peer._get("Combined function magnet array", name, self._peer._CFM_MAGNET_ARRAYS)
+
+    def add(self, arrayName: str, elementNames: list[str]):
+        """
+        Adds the specified combined function magnet array to the holder
+
+        Parameters
+        ----------
+        arrayName : str
+            Array name
+        elementNames : list[str]
+            List of magnet names
+        """
+        self._peer._fill_array(
+            arrayName,
+            elementNames,
+            self._peer.combined_function_magnet.get,
+            CombinedFunctionMagnetArray,
+            self._peer._CFM_MAGNET_ARRAYS,
+        )
+
+    def __getitem__(self, key):
+        return self.get().__getitem__(key)

pyaml/common/element_holder.py → pyaml/common/holders/element_holder.py

@@ -7,37 +7,39 @@
 from abc import ABCMeta, abstractmethod
 from typing import TYPE_CHECKING
 
-from ..arrays.bpm_array import BPMArray
-from ..arrays.cfm_magnet_array import CombinedFunctionMagnetArray
-from ..arrays.element_array import ElementArray
-from ..arrays.magnet_array import MagnetArray
-from ..arrays.serialized_magnet_array import SerializedMagnetsArray
-from ..bpm.bpm import BPM
-from ..common.abstract_aggregator import ScalarAggregator
-from ..common.exception import PyAMLException
-from ..diagnostics.tune_monitor import BetatronTuneMonitor
-from ..magnet.cfm_magnet import CombinedFunctionMagnet
-from ..magnet.magnet import Magnet
-from ..magnet.serialized_magnet import SerializedMagnets
-from ..rf.rf_plant import RFPlant
-from ..rf.rf_transmitter import RFTransmitter
-from ..tuning_tools.chromaticity_monitor import ChomaticityMonitor
-from .element import Element
+from ...arrays.bpm_array import BPMArray
+from ...arrays.cfm_magnet_array import CombinedFunctionMagnetArray
+from ...arrays.element_array import ElementArray
+from ...arrays.magnet_array import MagnetArray
+from ...arrays.serialized_magnet_array import SerializedMagnetsArray
+from ...bpm.bpm import BPM
+from ...diagnostics.tune_monitor import BetatronTuneMonitor
+from ...magnet.cfm_magnet import CombinedFunctionMagnet
+from ...magnet.magnet import Magnet
+from ...magnet.serialized_magnet import SerializedMagnets
+from ...rf.rf_plant import RFPlant
+from ...rf.rf_transmitter import RFTransmitter
+from ...tuning_tools.chromaticity_monitor import ChomaticityMonitor
+from ..abstract_aggregator import ScalarAggregator
+from ..element import Element
+from ..exception import PyAMLException
+from .combinded_function_magnet_holder import CombinedFunctionMagnetHolder
+from .combinded_function_magnets_holder import CombinedFunctionMagnetsHolder
 from .magnet_holder import MagnetHolder
 from .magnets_holder import MagnetsHolder
 from .serialized_magnet_holder import SerializedMagnetHolder
 from .serialized_magnets_holder import SerializedMagnetsHolder
 
 if TYPE_CHECKING:
-    from ..accelerator import Accelerator
-    from ..tuning_tools.bba import BBA
-    from ..tuning_tools.chromaticity import Chromaticity
-    from ..tuning_tools.chromaticity_response_matrix import ChromaticityResponseMatrix
-    from ..tuning_tools.dispersion import Dispersion
-    from ..tuning_tools.orbit import Orbit
-    from ..tuning_tools.orbit_response_matrix import OrbitResponseMatrix
-    from ..tuning_tools.tune import Tune
-    from ..tuning_tools.tune_response_matrix import TuneResponseMatrix
+    from ...accelerator import Accelerator
+    from ...tuning_tools.bba import BBA
+    from ...tuning_tools.chromaticity import Chromaticity
+    from ...tuning_tools.chromaticity_response_matrix import ChromaticityResponseMatrix
+    from ...tuning_tools.dispersion import Dispersion
+    from ...tuning_tools.orbit import Orbit
+    from ...tuning_tools.orbit_response_matrix import OrbitResponseMatrix
+    from ...tuning_tools.tune import Tune
+    from ...tuning_tools.tune_response_matrix import TuneResponseMatrix
 
 
 class ElementHolder(metaclass=ABCMeta):
@@ -79,6 +81,8 @@ def __init__(self):
         self._magnets_holder = MagnetsHolder(self)
         self._serialized_magnet_holder = SerializedMagnetHolder(self)
         self._serialized_magnets_holder = SerializedMagnetsHolder(self)
+        self._combined_function_magnet_holder = CombinedFunctionMagnetHolder(self)
+        self._combined_function_magnets_holder = CombinedFunctionMagnetsHolder(self)
 
     @property
     def peer(self) -> "Accelerator":
@@ -87,6 +91,8 @@ def peer(self) -> "Accelerator":
         """
         return self._peer
 
+    # Sub holders ----------------------------------------------------------------
+
     @property
     def magnet(self) -> MagnetHolder:
         return self._magnet_holder
@@ -103,6 +109,14 @@ def serialized_magnet(self) -> SerializedMagnetHolder:
     def serialized_magnets(self) -> SerializedMagnetsHolder:
         return self._serialized_magnets_holder
 
+    @property
+    def combined_function_magnet(self) -> CombinedFunctionMagnetHolder:
+        return self._combined_function_magnet_holder
+
+    @property
+    def combined_function_magnets(self) -> CombinedFunctionMagnetsHolder:
+        return self._combined_function_magnets_holder
+
     def post_init(self):
         """
         Method triggered after all initialisations are done
@@ -205,29 +219,6 @@ def get_elements(self, name: str) -> ElementArray:
     def get_all_elements(self) -> list[Element]:
         return [value for key, value in self._ALL.items()]
 
-    # Combined Function Magnets
-
-    def fill_cfm_magnet_array(self, arrayName: str, elementNames: list[str]):
-        self._fill_array(
-            arrayName,
-            elementNames,
-            self.get_cfm_magnet,
-            CombinedFunctionMagnetArray,
-            self._CFM_MAGNET_ARRAYS,
-        )
-
-    def get_cfm_magnet(self, name: str) -> Magnet:
-        return self._get("CombinedFunctionMagnet", name, self._CFM_MAGNETS)
-
-    def add_cfm_magnet(self, m: Magnet):
-        self._add(self._CFM_MAGNETS, m)
-
-    def get_cfm_magnets(self, name: str) -> CombinedFunctionMagnetArray:
-        return self._get("CombinedFunctionMagnet array", name, self._CFM_MAGNET_ARRAYS)
-
-    def get_all_cfm_magnets(self) -> list[CombinedFunctionMagnet]:
-        return [value for key, value in self._CFM_MAGNETS.items()]
-
     # BPMs
 
     def fill_bpm_array(self, arrayName: str, elementNames: list[str]):

pyaml/common/magnet_holder.py → pyaml/common/holders/magnet_holder.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
 
-from ..magnet.magnet import Magnet
+from ...magnet.magnet import Magnet
 
 if TYPE_CHECKING:
     from .element_holder import ElementHolder