From 550023d4ed70077efc0a6c0f58f4fb4261c8b682 Mon Sep 17 00:00:00 2001 From: PONS Date: Tue, 18 Aug 2026 09:25:17 +0200 Subject: [PATCH] New BPM holder API, holder factorization --- pyaml/apidoc/gen_api.py | 7 +- pyaml/arrays/bpm.py | 2 +- .../combinded_function_magnet_holder.py | 39 --------- .../combinded_function_magnets_holder.py | 47 ----------- pyaml/common/holders/element_holder.py | 49 +++++------ pyaml/common/holders/generic_array_holder.py | 67 +++++++++++++++ .../common/holders/generic_element_holder.py | 52 ++++++++++++ pyaml/common/holders/magnet_holder.py | 39 --------- pyaml/common/holders/magnets_holder.py | 41 --------- .../holders/serialized_magnet_holder.py | 39 --------- .../holders/serialized_magnets_holder.py | 47 ----------- pyaml/common/holders/sub_holders.py | 83 +++++++++++++++++++ pyaml/control/controlsystem.py | 2 +- pyaml/external/pySC_interface.py | 2 +- pyaml/lattice/simulator.py | 2 +- pyaml/tuning_tools/bba.py | 2 +- pyaml/tuning_tools/bba2.py | 4 +- pyaml/tuning_tools/chromaticity_monitor.py | 2 +- pyaml/tuning_tools/orbit_response_matrix.py | 2 +- tests/arrays/test_arrays.py | 24 +++--- tests/bpm/test_bpm.py | 14 ++-- tests/bpm/test_bpm_controlsystem.py | 10 +-- tests/common/test_errors.py | 2 +- tests/integration/test_dt4acc_twin_smoke.py | 2 +- tests/test_catalogs.py | 4 +- tests/test_load_conf_with_code.py | 2 +- tests/tuning_tools/test_bba.py | 2 +- tests/tuning_tools/test_tuning_dispersion.py | 2 +- .../test_tuning_orbit_correction.py | 2 +- tests/tuning_tools/test_tuning_orm.py | 2 +- 30 files changed, 265 insertions(+), 329 deletions(-) delete mode 100644 pyaml/common/holders/combinded_function_magnet_holder.py delete mode 100644 pyaml/common/holders/combinded_function_magnets_holder.py create mode 100644 pyaml/common/holders/generic_array_holder.py create mode 100644 pyaml/common/holders/generic_element_holder.py delete mode 100644 pyaml/common/holders/magnet_holder.py delete mode 100644 pyaml/common/holders/magnets_holder.py delete mode 100644 pyaml/common/holders/serialized_magnet_holder.py delete mode 100644 pyaml/common/holders/serialized_magnets_holder.py create mode 100644 pyaml/common/holders/sub_holders.py diff --git a/pyaml/apidoc/gen_api.py b/pyaml/apidoc/gen_api.py index 221511549..a0be9b7a5 100644 --- a/pyaml/apidoc/gen_api.py +++ b/pyaml/apidoc/gen_api.py @@ -28,12 +28,7 @@ "pyaml.common.element", "pyaml.common.exception", "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.common.holders.sub_holders", "pyaml.configuration.factory", "pyaml.configuration.fileloader", "pyaml.configuration.manager", diff --git a/pyaml/arrays/bpm.py b/pyaml/arrays/bpm.py index 65f50288c..2fac06c28 100644 --- a/pyaml/arrays/bpm.py +++ b/pyaml/arrays/bpm.py @@ -64,4 +64,4 @@ def fill_array(self, holder: ElementHolder): holder : ElementHolder The element holder to populate the :py:class:`.BPMArray` with. """ - holder.fill_bpm_array(self._name, self._elements) + holder.bpms.add(self._name, self._elements) diff --git a/pyaml/common/holders/combinded_function_magnet_holder.py b/pyaml/common/holders/combinded_function_magnet_holder.py deleted file mode 100644 index e657a38e7..000000000 --- a/pyaml/common/holders/combinded_function_magnet_holder.py +++ /dev/null @@ -1,39 +0,0 @@ -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) diff --git a/pyaml/common/holders/combinded_function_magnets_holder.py b/pyaml/common/holders/combinded_function_magnets_holder.py deleted file mode 100644 index 4015c69c5..000000000 --- a/pyaml/common/holders/combinded_function_magnets_holder.py +++ /dev/null @@ -1,47 +0,0 @@ -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) diff --git a/pyaml/common/holders/element_holder.py b/pyaml/common/holders/element_holder.py index 90b5d224c..0ea08a11b 100644 --- a/pyaml/common/holders/element_holder.py +++ b/pyaml/common/holders/element_holder.py @@ -23,12 +23,16 @@ 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 +from .sub_holders import ( + BPMHolder, + BPMsHolder, + CombinedFunctionMagnetHolder, + CombinedFunctionMagnetsHolder, + MagnetHolder, + MagnetsHolder, + SerializedMagnetHolder, + SerializedMagnetsHolder, +) if TYPE_CHECKING: from ...accelerator import Accelerator @@ -83,6 +87,8 @@ def __init__(self): self._serialized_magnets_holder = SerializedMagnetsHolder(self) self._combined_function_magnet_holder = CombinedFunctionMagnetHolder(self) self._combined_function_magnets_holder = CombinedFunctionMagnetsHolder(self) + self._bpm_holder = BPMHolder(self) + self._bpms_holder = BPMsHolder(self) @property def peer(self) -> "Accelerator": @@ -117,6 +123,14 @@ def combined_function_magnet(self) -> CombinedFunctionMagnetHolder: def combined_function_magnets(self) -> CombinedFunctionMagnetsHolder: return self._combined_function_magnets_holder + @property + def bpm(self) -> BPMHolder: + return self._bpm_holder + + @property + def bpms(self) -> BPMsHolder: + return self._bpms_holder + def post_init(self): """ Method triggered after all initialisations are done @@ -219,29 +233,6 @@ def get_elements(self, name: str) -> ElementArray: def get_all_elements(self) -> list[Element]: return [value for key, value in self._ALL.items()] - # BPMs - - def fill_bpm_array(self, arrayName: str, elementNames: list[str]): - self._fill_array( - arrayName, - elementNames, - self.get_bpm, - BPMArray, - self._BPM_ARRAYS, - ) - - def get_bpm(self, name: str) -> BPM: - return self._get("BPM", name, self._BPMS) - - def add_bpm(self, bpm: BPM): - self._add(self._BPMS, bpm) - - def get_bpms(self, name: str) -> BPMArray: - return self._get("BPM array", name, self._BPM_ARRAYS) - - def get_all_bpms(self) -> list[BPM]: - return [value for key, value in self._BPMS.items()] - # RF def get_rf_plant(self, name: str) -> RFPlant: diff --git a/pyaml/common/holders/generic_array_holder.py b/pyaml/common/holders/generic_array_holder.py new file mode 100644 index 000000000..1e9fa399f --- /dev/null +++ b/pyaml/common/holders/generic_array_holder.py @@ -0,0 +1,67 @@ +from collections.abc import Callable +from typing import TYPE_CHECKING, Generic, TypeVar + +from ..element import Element + +if TYPE_CHECKING: + from .element_holder import ElementHolder + +T = TypeVar("T", bound=Element) +A = TypeVar("A") + + +class GenericArrayHolder(Generic[T, A]): + """ + Generic holder for arrays of elements (e.g. magnet arrays, BPM arrays). + + Concrete holders (:class:`.MagnetsHolder`, :class:`.SerializedMagnetsHolder`, + :class:`.CombinedFunctionMagnetsHolder`, ...) subclass this with the + element type ``T`` and the array type ``A`` they handle, so callers keep + full static typing on :meth:`get`, :meth:`add` and :meth:`__getitem__`. + """ + + def __init__( + self, + peer: "ElementHolder", + array_store: dict[str, A], + all_func: Callable[[], list[T]], + get_func: Callable[[str], T], + constructor: Callable[[str, list[T]], A], + what: str, + ): + self._peer = peer + self._array_store = array_store + self._all_func = all_func + self._get_func = get_func + self._constructor = constructor + self._what = what + + def get(self, name: str | None = None) -> A: + """ + Returns the specified array or all elements if no name specified + + Parameters + ---------- + name : str + Name of the array + """ + if name is None: + return self._constructor("", self._all_func()) + else: + return self._peer._get(self._what, name, self._array_store) + + def add(self, arrayName: str, elementNames: list[str]): + """ + Adds the specified array to the holder + + Parameters + ---------- + arrayName : str + Array name + elementNames : list[str] + List of element names + """ + self._peer._fill_array(arrayName, elementNames, self._get_func, self._constructor, self._array_store) + + def __getitem__(self, key): + return self.get().__getitem__(key) diff --git a/pyaml/common/holders/generic_element_holder.py b/pyaml/common/holders/generic_element_holder.py new file mode 100644 index 000000000..a21bda13a --- /dev/null +++ b/pyaml/common/holders/generic_element_holder.py @@ -0,0 +1,52 @@ +from typing import TYPE_CHECKING, Generic, TypeVar + +from ..element import Element + +if TYPE_CHECKING: + from .element_holder import ElementHolder + +T = TypeVar("T", bound=Element) + + +class GenericElementHolder(Generic[T]): + """ + Generic holder for a single kind of element (e.g. magnets, BPMs). + + Concrete holders (:class:`.MagnetHolder`, :class:`.SerializedMagnetHolder`, + :class:`.CombinedFunctionMagnetHolder`, ...) subclass this with the + element type they handle, so callers keep full static typing on + :meth:`all`, :meth:`get` and :meth:`add`. + """ + + def __init__(self, peer: "ElementHolder", store: dict[str, T], what: str): + self._peer = peer + self._store = store + self._what = what + + def all(self) -> list[T]: + """ + Returns all elements as a list + """ + return [value for key, value in self._store.items()] + + def get(self, name: str) -> T: + """ + Returns the specified element + + Parameters + ---------- + name : str + Name of the element + """ + return self._peer._get(self._what, name, self._store) + + def add(self, m: T): + """ + Adds the specified element to the holder + + Parameters + ---------- + m : T + Element to be added + """ + self._peer._add(self._store, m) diff --git a/pyaml/common/holders/magnet_holder.py b/pyaml/common/holders/magnet_holder.py deleted file mode 100644 index 8e8a12b4a..000000000 --- a/pyaml/common/holders/magnet_holder.py +++ /dev/null @@ -1,39 +0,0 @@ -from typing import TYPE_CHECKING - -from ...magnet.magnet import Magnet - -if TYPE_CHECKING: - from .element_holder import ElementHolder - - -class MagnetHolder: - def __init__(self, peer: "ElementHolder"): - self._peer = peer - - def all(self) -> list[Magnet]: - """ - Returns all magnets as a list - """ - return [value for key, value in self._peer._MAGNETS.items()] - - def get(self, name: str) -> Magnet: - """ - Returns the specified magnet - - Parameters - ---------- - name : str - Name of the magnet - """ - return self._peer._get("Magnet", name, self._peer._MAGNETS) - - def add(self, m: Magnet): - """ - Adds the specified magnet to the holder - - Parameters - ---------- - m : Magnet - Magnet to be added - """ - self._peer._add(self._peer._MAGNETS, m) diff --git a/pyaml/common/holders/magnets_holder.py b/pyaml/common/holders/magnets_holder.py deleted file mode 100644 index afff96256..000000000 --- a/pyaml/common/holders/magnets_holder.py +++ /dev/null @@ -1,41 +0,0 @@ -from typing import TYPE_CHECKING - -from ...arrays.magnet_array import MagnetArray - -if TYPE_CHECKING: - from .element_holder import ElementHolder - - -class MagnetsHolder: - def __init__(self, peer: "ElementHolder"): - self._peer = peer - - def get(self, name: str = None) -> MagnetArray: - """ - Returns the specified magnet array or all magnets if no name specified - - Parameters - ---------- - name : str - Name of the magnet array - """ - if name is None: - return MagnetArray("", self._peer.magnet.all()) - else: - return self._peer._get("Magnet array", name, self._peer._MAGNET_ARRAYS) - - def add(self, arrayName: str, elementNames: list[str]): - """ - Adds the specified 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.magnet.get, MagnetArray, self._peer._MAGNET_ARRAYS) - - def __getitem__(self, key): - return self.get().__getitem__(key) diff --git a/pyaml/common/holders/serialized_magnet_holder.py b/pyaml/common/holders/serialized_magnet_holder.py deleted file mode 100644 index 375f38399..000000000 --- a/pyaml/common/holders/serialized_magnet_holder.py +++ /dev/null @@ -1,39 +0,0 @@ -from typing import TYPE_CHECKING - -from ...magnet.serialized_magnet import SerializedMagnets - -if TYPE_CHECKING: - from .element_holder import ElementHolder - - -class SerializedMagnetHolder: - def __init__(self, peer: "ElementHolder"): - self._peer = peer - - def all(self) -> list[SerializedMagnets]: - """ - Returns all serialized magnets as a list - """ - return [value for key, value in self._peer._SERIALIZED_MAGNETS.items()] - - def get(self, name: str) -> SerializedMagnets: - """ - Returns the specified magnet - - Parameters - ---------- - name : str - Name of the magnet - """ - return self._peer._get("Serialized magnet", name, self._peer._SERIALIZED_MAGNETS) - - def add(self, m: SerializedMagnets): - """ - Adds the specified magnet to the holder - - Parameters - ---------- - m : Magnet - Magnet to be added - """ - self._peer._add(self._peer._SERIALIZED_MAGNETS, m) diff --git a/pyaml/common/holders/serialized_magnets_holder.py b/pyaml/common/holders/serialized_magnets_holder.py deleted file mode 100644 index 8ed8dccc6..000000000 --- a/pyaml/common/holders/serialized_magnets_holder.py +++ /dev/null @@ -1,47 +0,0 @@ -from typing import TYPE_CHECKING - -from ...arrays.serialized_magnet_array import SerializedMagnetsArray - -if TYPE_CHECKING: - from .element_holder import ElementHolder - - -class SerializedMagnetsHolder: - def __init__(self, peer: "ElementHolder"): - self._peer = peer - - def get(self, name: str = None) -> SerializedMagnetsArray: - """ - Returns the specified serialized magnet array or all serialized magnets if no name specified - - Parameters - ---------- - name : str - Name of the serialized magnet array - """ - if name is None: - return SerializedMagnetsArray("", self._peer.serialized_magnet.all()) - else: - return self._peer._get("serialized Magnet array", name, self._peer._SERIALIZED_MAGNETS_ARRAYS) - - def add(self, arrayName: str, elementNames: list[str]): - """ - Adds the specified serialied 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.serialized_magnet.get, - SerializedMagnetsArray, - self._peer._SERIALIZED_MAGNETS_ARRAYS, - ) - - def __getitem__(self, key): - return self.get().__getitem__(key) diff --git a/pyaml/common/holders/sub_holders.py b/pyaml/common/holders/sub_holders.py new file mode 100644 index 000000000..391ffeba8 --- /dev/null +++ b/pyaml/common/holders/sub_holders.py @@ -0,0 +1,83 @@ +from typing import TYPE_CHECKING + +from ...arrays.bpm_array import BPMArray +from ...arrays.cfm_magnet_array import CombinedFunctionMagnetArray +from ...arrays.magnet_array import MagnetArray +from ...arrays.serialized_magnet_array import SerializedMagnetsArray +from ...bpm.bpm import BPM +from ...magnet.cfm_magnet import CombinedFunctionMagnet +from ...magnet.magnet import Magnet +from ...magnet.serialized_magnet import SerializedMagnets +from .generic_array_holder import GenericArrayHolder +from .generic_element_holder import GenericElementHolder + +if TYPE_CHECKING: + from .element_holder import ElementHolder + + +class MagnetHolder(GenericElementHolder[Magnet]): + def __init__(self, peer: "ElementHolder"): + super().__init__(peer, peer._MAGNETS, "Magnet") + + +class MagnetsHolder(GenericArrayHolder[Magnet, MagnetArray]): + def __init__(self, peer: "ElementHolder"): + super().__init__( + peer, + peer._MAGNET_ARRAYS, + peer.magnet.all, + peer.magnet.get, + MagnetArray, + "Magnet array", + ) + + +class CombinedFunctionMagnetHolder(GenericElementHolder[CombinedFunctionMagnet]): + def __init__(self, peer: "ElementHolder"): + super().__init__(peer, peer._CFM_MAGNETS, "Combined function magnet") + + +class CombinedFunctionMagnetsHolder(GenericArrayHolder[CombinedFunctionMagnet, CombinedFunctionMagnetArray]): + def __init__(self, peer: "ElementHolder"): + super().__init__( + peer, + peer._CFM_MAGNET_ARRAYS, + peer.combined_function_magnet.all, + peer.combined_function_magnet.get, + CombinedFunctionMagnetArray, + "Combined function magnet array", + ) + + +class SerializedMagnetHolder(GenericElementHolder[SerializedMagnets]): + def __init__(self, peer: "ElementHolder"): + super().__init__(peer, peer._SERIALIZED_MAGNETS, "Serialized magnet") + + +class SerializedMagnetsHolder(GenericArrayHolder[SerializedMagnets, SerializedMagnetsArray]): + def __init__(self, peer: "ElementHolder"): + super().__init__( + peer, + peer._SERIALIZED_MAGNETS_ARRAYS, + peer.serialized_magnet.all, + peer.serialized_magnet.get, + SerializedMagnetsArray, + "serialized magnet array", + ) + + +class BPMHolder(GenericElementHolder[BPM]): + def __init__(self, peer: "ElementHolder"): + super().__init__(peer, peer._BPMS, "BPM") + + +class BPMsHolder(GenericArrayHolder[BPM, BPMArray]): + def __init__(self, peer: "ElementHolder"): + super().__init__( + peer, + peer._BPM_ARRAYS, + peer.bpm.all, + peer.bpm.get, + BPMArray, + "BPM array", + ) diff --git a/pyaml/control/controlsystem.py b/pyaml/control/controlsystem.py index 36c322f0e..e6dd7f561 100644 --- a/pyaml/control/controlsystem.py +++ b/pyaml/control/controlsystem.py @@ -175,7 +175,7 @@ def fill_device(self, elements: list[Element]): tilt = RWBpmTiltScalar(tilt_devs[0]) offsets = RWBpmOffsetArray(offset_devs[0], offset_devs[1]) e = e.attach(self, positions, offsets, tilt) - self.add_bpm(e) + self.bpm.add(e) elif isinstance(e, RFPlant): attachedTrans: list[RFTransmitter] = [] diff --git a/pyaml/external/pySC_interface.py b/pyaml/external/pySC_interface.py index fc5b3256f..15294f88f 100644 --- a/pyaml/external/pySC_interface.py +++ b/pyaml/external/pySC_interface.py @@ -20,7 +20,7 @@ def __init__( ): self.element_holder = element_holder - self.bpm_array = element_holder.get_bpms(bpm_array_name) + self.bpm_array = element_holder.bpms.get(bpm_array_name) self.rf_plant_name = rf_plant_name if rf_plant_name is not None: diff --git a/pyaml/lattice/simulator.py b/pyaml/lattice/simulator.py index 5d529f59b..26774fd84 100644 --- a/pyaml/lattice/simulator.py +++ b/pyaml/lattice/simulator.py @@ -209,7 +209,7 @@ def fill_device(self, elements: list[Element]): offsets = RWBpmOffsetArray(bpm_elt) positions = RBpmArray(bpm_elt, self.ring) e = e.attach(self, positions, offsets, tilt) - self.add_bpm(e) + self.bpm.add(e) elif isinstance(e, RFPlant): if e.transmitters: diff --git a/pyaml/tuning_tools/bba.py b/pyaml/tuning_tools/bba.py index 747833e35..d1a710509 100644 --- a/pyaml/tuning_tools/bba.py +++ b/pyaml/tuning_tools/bba.py @@ -123,7 +123,7 @@ def measure( interface.set_wait_time = sleep_step interface.read_wait_time = sleep_meas - bpms_names = element_holder.get_bpms(self._cfg.bpm_array_name).names() + bpms_names = element_holder.bpms.get(self._cfg.bpm_array_name).names() bba_pySC_config = { "number": bpms_names.index(self._cfg.bpm_name), diff --git a/pyaml/tuning_tools/bba2.py b/pyaml/tuning_tools/bba2.py index b2a4531e8..084c49003 100644 --- a/pyaml/tuning_tools/bba2.py +++ b/pyaml/tuning_tools/bba2.py @@ -125,7 +125,7 @@ def _init_responses( quad = design.magnet.get(quadname) sth = design.magnet.get(steererhname) stv = design.magnet.get(steerervname) - orbit = design.get_bpms(bpmname).positions + orbit = design.bpms.get(bpmname).positions tune_design = design.get_tune_tuning(tunename) tune_live = self._peer.get_tune_tuning(tunename) @@ -340,7 +340,7 @@ def measure( self._h_steer = self.peer.magnet.get(self._cfg.hcorr_name) self._v_steer = self.peer.magnet.get(self._cfg.vcorr_name) self._quad = self.peer.magnet.get(self._cfg.quad_name) - self._bpms = self.peer.get_bpms(self._cfg.bpm_array_name) + self._bpms = self.peer.bpms.get(self._cfg.bpm_array_name) self._bpmi = self._bpms.names().index(self._cfg.bpm_name) # Initial values diff --git a/pyaml/tuning_tools/chromaticity_monitor.py b/pyaml/tuning_tools/chromaticity_monitor.py index 2d4c24d50..439e6aa98 100644 --- a/pyaml/tuning_tools/chromaticity_monitor.py +++ b/pyaml/tuning_tools/chromaticity_monitor.py @@ -251,7 +251,7 @@ def measure( orbit = None if fit_dispersion and fit_disp_order is not None and self.bpm_array_name is not None: # For dispersion fit - bpms = self.peer.get_bpms(self.bpm_array_name) + bpms = self.peer.bpms.get(self.bpm_array_name) n_bpm = len(bpms) f0 = rf.frequency.get() diff --git a/pyaml/tuning_tools/orbit_response_matrix.py b/pyaml/tuning_tools/orbit_response_matrix.py index 99d6a090f..2595b14b0 100644 --- a/pyaml/tuning_tools/orbit_response_matrix.py +++ b/pyaml/tuning_tools/orbit_response_matrix.py @@ -172,7 +172,7 @@ def _pySC_response_data_to_ORMData(self, data: dict) -> OrbitResponseMatrixDataC elif corr in all_vcorrector_names: variable_planes.append("V") - bpm_names = element_holder.get_bpms(self.bpm_array_name).names() + bpm_names = element_holder.bpms.get(self.bpm_array_name).names() # This is because we assume always dual-plane bpms now. len_b = len(bpm_names) observable_names = bpm_names * 2 diff --git a/tests/arrays/test_arrays.py b/tests/arrays/test_arrays.py index fbe8e91ec..7ae9b8710 100644 --- a/tests/arrays/test_arrays.py +++ b/tests/arrays/test_arrays.py @@ -128,32 +128,32 @@ def test_arrays(install_test_package): # Test BPMs array # Using aggregator - pos = sr.design.get_bpms("BPMS").positions.get() + pos = sr.design.bpms.get("BPMS").positions.get() assert np.abs(pos[0][0] - 7.22262850488348e-05) < 1e-10 assert np.abs(pos[0][1] - 3.4291613955705856e-05) < 1e-10 assert np.abs(pos[1][0] + 1.1696152238807462e-04) < 1e-10 assert np.abs(pos[1][1] - 7.4265634524358045e-06) < 1e-10 # Using aggregator (h and v) - pos_h = sr.design.get_bpms("BPMS").h.get() - pos_v = sr.design.get_bpms("BPMS").v.get() + pos_h = sr.design.bpms.get("BPMS").h.get() + pos_v = sr.design.bpms.get("BPMS").v.get() assert np.all(np.isclose(pos[:, 0], pos_h, rtol=1e-15, atol=1e-15)) assert np.all(np.isclose(pos[:, 1], pos_v, rtol=1e-15, atol=1e-15)) # Test BPM transformation matrices - sr.design.get_bpm("BPM_C04-01").offset.set([0.1, 0.2]) - sr.design.get_bpm("BPM_C04-02").offset.set([0.3, 0.4]) - pos = sr.design.get_bpms("BPMS").positions.get() + sr.design.bpm.get("BPM_C04-01").offset.set([0.1, 0.2]) + sr.design.bpm.get("BPM_C04-02").offset.set([0.3, 0.4]) + pos = sr.design.bpms.get("BPMS").positions.get() assert np.abs(pos[0][0] - 7.22262850488348e-05 - 0.1) < 1e-10 assert np.abs(pos[0][1] - 3.4291613955705856e-05 - 0.2) < 1e-10 assert np.abs(pos[1][0] + 1.1696152238807462e-04 - 0.3) < 1e-10 assert np.abs(pos[1][1] - 7.4265634524358045e-06 - 0.4) < 1e-10 - sr.design.get_bpm("BPM_C04-01").offset.set([0.0, 0.0]) - sr.design.get_bpm("BPM_C04-02").offset.set([0.0, 0.0]) + sr.design.bpm.get("BPM_C04-01").offset.set([0.0, 0.0]) + sr.design.bpm.get("BPM_C04-02").offset.set([0.0, 0.0]) # No aggregator bpms = [] - for b in sr.design.get_bpms("BPMS"): + for b in sr.design.bpms.get("BPMS"): bpms.append(b) bpms = BPMArray("BPM_noagg", bpms, use_aggregator=False) @@ -175,7 +175,7 @@ def test_arrays(install_test_package): assert len(allMags) == 7 # Create an array that contains all BPM - allBpms = BPMArray("AllBPMs", sr.design.get_all_bpms()) + allBpms = BPMArray("AllBPMs", sr.design.bpm.all()) assert len(allBpms) == 2 cfm = sr.design.combined_function_magnets.get("CFM") @@ -204,7 +204,7 @@ def test_arrays(install_test_package): assert np.abs(strHVSQ[4] + 0.000017) < 1e-10 # V assert np.abs(strHVSQ[5] - 1e-6) < 1e-10 # SQ - bpmsLive = BPMArray("", sr.live.get_all_bpms()) + bpmsLive = BPMArray("", sr.live.bpm.all()) bpmsLive.positions.get() # Test dynamic arrays @@ -232,7 +232,7 @@ def test_arrays(install_test_package): emptyBPM = BPM(name="emptyBPM", elements=[]) emptyBPM.fill_array(sr.design) # Attach the array - v = sr.design.get_bpms("emptyBPM").positions.get() # Ensure good attach + v = sr.design.bpms.get("emptyBPM").positions.get() # Ensure good attach assert np.shape(v) == (0,) emptyCFM = CombinedFunctionMagnet(name="emptyCFM", elements=[]) diff --git a/tests/bpm/test_bpm.py b/tests/bpm/test_bpm.py index bce9d82e1..93ac68ec5 100644 --- a/tests/bpm/test_bpm.py +++ b/tests/bpm/test_bpm.py @@ -9,7 +9,7 @@ def test_simulator_bpm_tilt(): sr.design.get_lattice().disable_6d() sr.design.magnet.get("SH1A-C01-H").strength.set(10e-6) # Add orbit sr.design.magnet.get("SH1A-C01-V").strength.set(10e-6) # Add orbit - bpm = sr.design.get_bpm("BPM_C01-01") + bpm = sr.design.bpm.get("BPM_C01-01") assert np.allclose(bpm.positions.get(), np.array([5.90809968e-05, 2.24832853e-05])) assert bpm.tilt.get() == 0 alpha = np.pi / 3 @@ -30,7 +30,7 @@ def test_simulator_bpm_tilt(): def test_simulator_bpm_offset(): sr: Accelerator = Accelerator.load("tests/config/bpms.yaml", ignore_external=True) sr.design.get_lattice().disable_6d() - bpm = sr.design.get_bpm("BPM_C01-01") + bpm = sr.design.bpm.get("BPM_C01-01") assert bpm.offset.get()[0] == 0 assert bpm.offset.get()[1] == 0 @@ -48,8 +48,8 @@ def test_simulator_bpm_offset(): def test_simulator_bpm_position(install_test_package): sr: Accelerator = Accelerator.load("tests/config/bpms.yaml") sr.design.get_lattice().disable_6d() - bpm = sr.design.get_bpm("BPM_C01-01") - bpm_simple = sr.live.get_bpm("BPM_C01-02") + bpm = sr.design.bpm.get("BPM_C01-01") + bpm_simple = sr.live.bpm.get("BPM_C01-02") assert np.allclose(bpm.positions.get(), np.array([0.0, 0.0])) assert np.allclose(bpm_simple.positions.get(), np.array([0.0, 0.0])) @@ -58,9 +58,9 @@ def test_simulator_bpm_position(install_test_package): def test_simulator_bpm_position_with_bad_corrector_strength(): sr: Accelerator = Accelerator.load("tests/config/bpms.yaml", ignore_external=True) sr.design.get_lattice().disable_6d() - bpm1 = sr.design.get_bpm("BPM_C01-01") - bpm_simple = sr.design.get_bpm("BPM_C01-02") - bpm3 = sr.design.get_bpm("BPM_C01-03") + bpm1 = sr.design.bpm.get("BPM_C01-01") + bpm_simple = sr.design.bpm.get("BPM_C01-02") + bpm3 = sr.design.bpm.get("BPM_C01-03") sr.design.magnet.get("SH1A-C01-H").strength.set(-1e-6) sr.design.magnet.get("SH1A-C01-V").strength.set(-1e-6) diff --git a/tests/bpm/test_bpm_controlsystem.py b/tests/bpm/test_bpm_controlsystem.py index ed3706e4f..13321ca12 100644 --- a/tests/bpm/test_bpm_controlsystem.py +++ b/tests/bpm/test_bpm_controlsystem.py @@ -11,7 +11,7 @@ ) def test_controlsystem_bpm_tilt(install_test_package): sr: Accelerator = Accelerator.load("tests/config/bpms.yaml") - bpm = sr.live.get_bpm("BPM_C01-01") + bpm = sr.live.bpm.get("BPM_C01-01") print(bpm.tilt.get()) assert bpm.tilt.get() == 0 @@ -26,7 +26,7 @@ def test_controlsystem_bpm_tilt(install_test_package): ) def test_controlsystem_bpm_offset(install_test_package): sr: Accelerator = Accelerator.load("tests/config/bpms.yaml") - bpm = sr.live.get_bpm("BPM_C01-01") + bpm = sr.live.bpm.get("BPM_C01-01") assert bpm.offset.get()[0] == 0 assert bpm.offset.get()[1] == 0 @@ -43,8 +43,8 @@ def test_controlsystem_bpm_offset(install_test_package): ) def test_controlsystem_bpm_position(install_test_package): sr: Accelerator = Accelerator.load("tests/config/bpms.yaml") - bpm = sr.live.get_bpm("BPM_C01-01") - bpm_simple = sr.live.get_bpm("BPM_C01-02") + bpm = sr.live.bpm.get("BPM_C01-01") + bpm_simple = sr.live.bpm.get("BPM_C01-02") assert np.allclose(bpm.positions.get(), np.array([0.0, 0.0])) assert np.allclose(bpm_simple.positions.get(), np.array([0.0, 0.0])) @@ -91,6 +91,6 @@ def test_controlsystem_bpm_position_indexed(install_test_package): set_attribute("srdiag/bpm/c01-04/Position", [0.0, 1.0], unit="mm") sr: Accelerator = Accelerator.load("tests/config/bpms.yaml") - bpm = sr.live.get_bpm("BPM_C01-04") + bpm = sr.live.bpm.get("BPM_C01-04") assert np.allclose(bpm.positions.get(), np.array([0.0, 1.0])) diff --git a/tests/common/test_errors.py b/tests/common/test_errors.py index bd41bf087..67d888b6d 100644 --- a/tests/common/test_errors.py +++ b/tests/common/test_errors.py @@ -43,7 +43,7 @@ def test_tune(install_test_package): assert "Magnet QF1A-C05XX not defined" in str(exc.value) with pytest.raises(PyAMLException) as exc: - m2 = sr.design.get_bpm("QF1A-C05XX") + m2 = sr.design.bpm.get("QF1A-C05XX") assert "BPM QF1A-C05XX not defined" in str(exc.value) diff --git a/tests/integration/test_dt4acc_twin_smoke.py b/tests/integration/test_dt4acc_twin_smoke.py index af6426653..c216dbb5b 100644 --- a/tests/integration/test_dt4acc_twin_smoke.py +++ b/tests/integration/test_dt4acc_twin_smoke.py @@ -156,7 +156,7 @@ def deactivated_test_orbit_correction(root_folder: Path, config_files: dict[str, try: accelerator = _build_accelerator(root_folder, config_files) control_mode = accelerator.live - bpms = control_mode.get_bpms("bpms") + bpms = control_mode.bpms.get("bpms") orbit_response_matrix = control_mode.get_orm_tuning("DEFAULT_ORBIT_RESPONSE_MATRIX") orbit_correction = control_mode.get_orbit_tuning("DEFAULT_ORBIT_CORRECTION") orbit_response_matrix.measure() diff --git a/tests/test_catalogs.py b/tests/test_catalogs.py index 17841ceb2..828627aa5 100644 --- a/tests/test_catalogs.py +++ b/tests/test_catalogs.py @@ -59,7 +59,7 @@ def test_inline_catalog_is_supported(install_test_package): } ) - bpm = sr.live.get_bpm("BPM_C02-01") + bpm = sr.live.bpm.get("BPM_C02-01") assert np.allclose(bpm.positions.get(), np.array([0.0, 0.0])) @@ -184,7 +184,7 @@ def test_indexed_catalog_entry_extracts_scalar_from_vector_attribute(install_tes } ) - bpm = sr.live.get_bpm("BPM_TEST") + bpm = sr.live.bpm.get("BPM_TEST") positions = bpm.positions.get() assert np.isclose(positions[0], 1.5) assert np.isclose(positions[1], -0.3) diff --git a/tests/test_load_conf_with_code.py b/tests/test_load_conf_with_code.py index ceb4747d0..42286ba2c 100644 --- a/tests/test_load_conf_with_code.py +++ b/tests/test_load_conf_with_code.py @@ -8,6 +8,6 @@ def test_load_conf_with_code(): config_path = parent_folder.joinpath("config", "EBSOrbit.yaml").resolve() sr: Accelerator = Accelerator.load(config_path) - bpms = sr.live.get_bpms("BPM") + bpms = sr.live.bpms.get("BPM") assert bpms is not None assert len(bpms) == 320 diff --git a/tests/tuning_tools/test_bba.py b/tests/tuning_tools/test_bba.py index 24485c920..aaeb6a751 100644 --- a/tests/tuning_tools/test_bba.py +++ b/tests/tuning_tools/test_bba.py @@ -9,7 +9,7 @@ def test_bba(): SR = sr.design # Add a misalignement - SR.get_bpm("BPM_C04-04").offset.set([20e-6, -15e-6]) + SR.bpm.get("BPM_C04-04").offset.set([20e-6, -15e-6]) # BBA (standard bow tie, model independant) bba = SR.get_bba("BBA-BPM_C04-04") diff --git a/tests/tuning_tools/test_tuning_dispersion.py b/tests/tuning_tools/test_tuning_dispersion.py index 7e877bcd2..16d2cd397 100644 --- a/tests/tuning_tools/test_tuning_dispersion.py +++ b/tests/tuning_tools/test_tuning_dispersion.py @@ -17,7 +17,7 @@ def test_tuning_orm(): dispersion.measure() dispersion_data = dispersion.get() - bpms = element_holder.get_bpms("BPM") + bpms = element_holder.bpms.get("BPM") assert len(dispersion_data["frequency_response_x"]) == len(bpms) assert len(dispersion_data["frequency_response_y"]) == len(bpms) diff --git a/tests/tuning_tools/test_tuning_orbit_correction.py b/tests/tuning_tools/test_tuning_orbit_correction.py index dce99c236..0e0f83696 100644 --- a/tests/tuning_tools/test_tuning_orbit_correction.py +++ b/tests/tuning_tools/test_tuning_orbit_correction.py @@ -21,7 +21,7 @@ def test_tuning_orbit_correction(): std_kick = 1e-6 hcorr = element_holder.magnets.get("HCorr") vcorr = element_holder.magnets.get("VCorr") - bpms = element_holder.get_bpms("BPM") + bpms = element_holder.bpms.get("BPM") x, y = bpms.positions.get().T # get reference orbit reference = np.concat((x, y)) diff --git a/tests/tuning_tools/test_tuning_orm.py b/tests/tuning_tools/test_tuning_orm.py index 9ccf3445a..faa8def0f 100644 --- a/tests/tuning_tools/test_tuning_orm.py +++ b/tests/tuning_tools/test_tuning_orm.py @@ -16,7 +16,7 @@ def test_tuning_orm(): orm = element_holder.orm - bpms = element_holder.get_bpms("BPM") + bpms = element_holder.bpms.get("BPM") hcorr_names = element_holder.magnets.get("HCorr").names()[:4] vcorr_names = element_holder.magnets.get("VCorr").names()[:4] orm.measure(corrector_names=hcorr_names + vcorr_names)