diff --git a/pyaml/arrays/magnet.py b/pyaml/arrays/magnet.py index 3c2d40283..e69f0cd42 100644 --- a/pyaml/arrays/magnet.py +++ b/pyaml/arrays/magnet.py @@ -35,4 +35,4 @@ def fill_array(self, holder: ElementHolder): holder : ElementHolder The element holder to populate with magnet array """ - holder.fill_magnet_array(self._name, self._elements) + holder.magnets.add(self._name, self._elements) diff --git a/pyaml/common/element_holder.py b/pyaml/common/element_holder.py index db6b52151..471d6333b 100644 --- a/pyaml/common/element_holder.py +++ b/pyaml/common/element_holder.py @@ -23,6 +23,8 @@ from ..rf.rf_transmitter import RFTransmitter from ..tuning_tools.chromaticity_monitor import ChomaticityMonitor from .element import Element +from .magnet_holder import MagnetHolder +from .magnets_holder import MagnetsHolder if TYPE_CHECKING: from ..accelerator import Accelerator @@ -44,31 +46,35 @@ class ElementHolder(metaclass=ABCMeta): def __init__(self): # Device handle - self.__MAGNETS: dict[str, Magnet] = {} - self.__CFM_MAGNETS: dict[str, CombinedFunctionMagnet] = {} - self.__SERIALIZED_MAGNETS: dict[str, SerializedMagnets] = {} - self.__BPMS: dict[str, BPM] = {} - self.__RFPLANT: dict[str, RFPlant] = {} - self.__RFTRANSMITTER: dict[str, RFTransmitter] = {} - self.__DIAG: dict[str, Element] = {} - self.__TUNING_TOOLS: dict[str, Element] = {} - self.__ALL: dict[str, Element] = {} + self._MAGNETS: dict[str, Magnet] = {} + self._CFM_MAGNETS: dict[str, CombinedFunctionMagnet] = {} + self._SERIALIZED_MAGNETS: dict[str, SerializedMagnets] = {} + self._BPMS: dict[str, BPM] = {} + self._RFPLANT: dict[str, RFPlant] = {} + self._RFTRANSMITTER: dict[str, RFTransmitter] = {} + self._DIAG: dict[str, Element] = {} + self._TOOLS: dict[str, Element] = {} + self._ALL: dict[str, Element] = {} self.__by_class_elements: dict[type, dict] = { - Magnet: self.__MAGNETS, - CombinedFunctionMagnet: self.__CFM_MAGNETS, - SerializedMagnets: self.__SERIALIZED_MAGNETS, - BPM: self.__BPMS, - RFPlant: self.__RFPLANT, - RFTransmitter: self.__RFTRANSMITTER, + Magnet: self._MAGNETS, + CombinedFunctionMagnet: self._CFM_MAGNETS, + SerializedMagnets: self._SERIALIZED_MAGNETS, + BPM: self._BPMS, + RFPlant: self._RFPLANT, + RFTransmitter: self._RFTRANSMITTER, } # Array handle - self.__MAGNET_ARRAYS: dict = {} - self.__CFM_MAGNET_ARRAYS: dict = {} - self.__SERIALIZED_MAGNETS_ARRAYS: dict = {} - self.__BPM_ARRAYS: dict = {} - self.__ELEMENT_ARRAYS: dict = {} + self._MAGNET_ARRAYS: dict = {} + self._CFM_MAGNET_ARRAYS: dict = {} + self._SERIALIZED_MAGNETS_ARRAYS: dict = {} + self._BPM_ARRAYS: dict = {} + self._ELEMENT_ARRAYS: dict = {} + + # Sub holders + self._magnet_holder = MagnetHolder(self) + self._magnets_holder = MagnetsHolder(self) @property def peer(self) -> "Accelerator": @@ -77,6 +83,14 @@ def peer(self) -> "Accelerator": """ return self._peer + @property + def magnet(self) -> MagnetHolder: + return self._magnet_holder + + @property + def magnets(self) -> MagnetsHolder: + return self._magnets_holder + def post_init(self): """ Method triggered after all initialisations are done @@ -106,15 +120,15 @@ def create_bpm_aggregators(self, bpms: list[BPM]) -> list[ScalarAggregator | Non def find_elements(self, filter: str) -> list[str]: if filter.startswith("re:"): pattern = re.compile(rf"{filter[3:]}") - elements = [k for k in self.__ALL.keys() if pattern.fullmatch(k)] + elements = [k for k in self._ALL.keys() if pattern.fullmatch(k)] elif "*" in filter or "?" in filter: - elements = [k for k in self.__ALL.keys() if fnmatch.fnmatch(k, filter)] + elements = [k for k in self._ALL.keys() if fnmatch.fnmatch(k, filter)] else: elements = [filter] return elements - def fill_array( + def _fill_array( self, array_name: str, element_names: list[str], @@ -146,163 +160,146 @@ def fill_array( a.append(m) ARR[array_name] = constructor(array_name, a) - def __add(self, array, element: Element): - if element.get_name() in self.__ALL: # Ensure name unicity + def _add(self, array, element: Element): + if element.get_name() in self._ALL: # Ensure name unicity raise PyAMLException(f"Duplicate element {element.__class__.__name__} name {{element.get_name()}}") from None array[element.get_name()] = element - self.__ALL[element.get_name()] = element + self._ALL[element.get_name()] = element - def __get(self, what, name, array) -> Element: + def _get(self, what, name, array) -> Element: if name not in array: raise PyAMLException(f"{what} {name} not defined") return array[name] # Generic elements def fill_element_array(self, arrayName: str, elementNames: list[str]): - self.fill_array( + self._fill_array( arrayName, elementNames, self.get_element, ElementArray, - self.__ELEMENT_ARRAYS, + self._ELEMENT_ARRAYS, ) def add_element(self, element: Element): - self.__ALL[element.get_name()] = element + self._ALL[element.get_name()] = element def get_element(self, name: str) -> Element: - return self.__get("Element", name, self.__ALL) + return self._get("Element", name, self._ALL) def get_elements(self, name: str) -> ElementArray: - return self.__get("Element array", name, self.__ELEMENT_ARRAYS) + return self._get("Element array", name, self._ELEMENT_ARRAYS) def get_all_elements(self) -> list[Element]: - return [value for key, value in self.__ALL.items()] - - # Magnets - - def fill_magnet_array(self, arrayName: str, elementNames: list[str]): - self.fill_array(arrayName, elementNames, self.get_magnet, MagnetArray, self.__MAGNET_ARRAYS) - - def get_magnet(self, name: str) -> Magnet: - return self.__get("Magnet", name, self.__MAGNETS) - - def add_magnet(self, m: Magnet): - self.__add(self.__MAGNETS, m) - - def get_magnets(self, name: str) -> MagnetArray: - return self.__get("Magnet array", name, self.__MAGNET_ARRAYS) - - def get_all_magnets(self) -> list[Magnet]: - return [value for key, value in self.__MAGNETS.items()] + 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( + self._fill_array( arrayName, elementNames, self.get_cfm_magnet, CombinedFunctionMagnetArray, - self.__CFM_MAGNET_ARRAYS, + self._CFM_MAGNET_ARRAYS, ) def get_cfm_magnet(self, name: str) -> Magnet: - return self.__get("CombinedFunctionMagnet", name, self.__CFM_MAGNETS) + return self._get("CombinedFunctionMagnet", name, self._CFM_MAGNETS) def add_cfm_magnet(self, m: Magnet): - self.__add(self.__CFM_MAGNETS, m) + self._add(self._CFM_MAGNETS, m) def get_cfm_magnets(self, name: str) -> CombinedFunctionMagnetArray: - return self.__get("CombinedFunctionMagnet array", name, self.__CFM_MAGNET_ARRAYS) + 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()] + return [value for key, value in self._CFM_MAGNETS.items()] # Serialized magnets def fill_serialized_magnet_array(self, arrayName: str, elementNames: list[str]): - self.fill_array( + self._fill_array( arrayName, elementNames, self.get_serialized_magnet, SerializedMagnetsArray, - self.__SERIALIZED_MAGNETS_ARRAYS, + self._SERIALIZED_MAGNETS_ARRAYS, ) def get_serialized_magnet(self, name: str) -> Magnet: - return self.__get("SerializedMagnets", name, self.__SERIALIZED_MAGNETS) + return self._get("SerializedMagnets", name, self._SERIALIZED_MAGNETS) def add_serialized_magnet(self, m: Magnet): - self.__add(self.__SERIALIZED_MAGNETS, m) + self._add(self._SERIALIZED_MAGNETS, m) def get_serialized_magnets(self, name: str) -> SerializedMagnetsArray: - return self.__get("SerializedMagnets array", name, self.__SERIALIZED_MAGNETS_ARRAYS) + return self._get("SerializedMagnets array", name, self._SERIALIZED_MAGNETS_ARRAYS) def get_all_serialized_magnets(self) -> list[SerializedMagnets]: - return [value for key, value in self.__SERIALIZED_MAGNETS.items()] + return [value for key, value in self._SERIALIZED_MAGNETS.items()] # BPMs def fill_bpm_array(self, arrayName: str, elementNames: list[str]): - self.fill_array( + self._fill_array( arrayName, elementNames, self.get_bpm, BPMArray, - self.__BPM_ARRAYS, + self._BPM_ARRAYS, ) def get_bpm(self, name: str) -> BPM: - return self.__get("BPM", name, self.__BPMS) + return self._get("BPM", name, self._BPMS) def add_bpm(self, bpm: BPM): - self.__add(self.__BPMS, bpm) + self._add(self._BPMS, bpm) def get_bpms(self, name: str) -> BPMArray: - return self.__get("BPM array", name, self.__BPM_ARRAYS) + 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()] + return [value for key, value in self._BPMS.items()] # RF def get_rf_plant(self, name: str) -> RFPlant: - return self.__get("RFPlant", name, self.__RFPLANT) + return self._get("RFPlant", name, self._RFPLANT) def add_rf_plant(self, rf: RFPlant): - self.__add(self.__RFPLANT, rf) + self._add(self._RFPLANT, rf) def add_rf_transmitter(self, rf: RFTransmitter): - self.__add(self.__RFTRANSMITTER, rf) + self._add(self._RFTRANSMITTER, rf) def get_rf_trasnmitter(self, name: str) -> RFTransmitter: - return self.__get("RFTransmitter", name, self.__RFTRANSMITTER) + return self._get("RFTransmitter", name, self._RFTRANSMITTER) # Tune monitor def get_betatron_tune_monitor(self, name: str) -> BetatronTuneMonitor: - return self.__get("Diagnostic", name, self.__DIAG) + return self._get("Diagnostic", name, self._DIAG) def add_betatron_tune_monitor(self, tune_monitor: Element): - self.__add(self.__DIAG, tune_monitor) + self._add(self._DIAG, tune_monitor) # Tuning/Measurement tools def add_tool(self, tool: Element): - self.__add(self.__TUNING_TOOLS, tool) + self._add(self._TOOLS, tool) # ---- Chromaticity ------------------------------------------------- def get_chromaticity_monitor(self, name: str) -> ChomaticityMonitor: - obj = self.__get("Chomaticity monitor", name, self.__TUNING_TOOLS) + obj = self._get("Chomaticity monitor", name, self._TOOLS) return obj def get_chromaticity_tuning(self, name: str) -> "Chromaticity": - return self.__get("Chromaticity tool", name, self.__TUNING_TOOLS) + return self._get("Chromaticity tool", name, self._TOOLS) def get_crm_tuning(self, name: str) -> "ChromaticityResponseMatrix": - return self.__get("ChromaticityResponseMatrix tool", name, self.__TUNING_TOOLS) + return self._get("ChromaticityResponseMatrix tool", name, self._TOOLS) @property def chromaticity(self) -> "Chromaticity": @@ -315,14 +312,14 @@ def crm(self) -> "ChromaticityResponseMatrix": # ---- Tune --------------------------------------------------------- def get_tune_tuning(self, name: str) -> "Tune": - return self.__get("Tune tuning tool", name, self.__TUNING_TOOLS) + return self._get("Tune tuning tool", name, self._TOOLS) @property def tune(self) -> "Tune": return self.get_tune_tuning("DEFAULT_TUNE_CORRECTION") def get_trm_tuning(self, name: str) -> "TuneResponseMatrix": - return self.__get("TuneResponseMatrix tool", name, self.__TUNING_TOOLS) + return self._get("TuneResponseMatrix tool", name, self._TOOLS) @property def trm(self) -> "TuneResponseMatrix": @@ -331,14 +328,14 @@ def trm(self) -> "TuneResponseMatrix": # ---- Orbit -------------------------------------------------------- def get_orbit_tuning(self, name: str) -> "Orbit": - return self.__get("Orbit tuning tool", name, self.__TUNING_TOOLS) + return self._get("Orbit tuning tool", name, self._TOOLS) @property def orbit(self) -> "Orbit": return self.get_orbit_tuning("DEFAULT_ORBIT_CORRECTION") def get_orm_tuning(self, name: str) -> "OrbitResponseMatrix": - return self.__get("OrbitResponseMatrix tool", name, self.__TUNING_TOOLS) + return self._get("OrbitResponseMatrix tool", name, self._TOOLS) @property def orm(self) -> "OrbitResponseMatrix": @@ -347,12 +344,12 @@ def orm(self) -> "OrbitResponseMatrix": # ---- BBA -------------------------------------------------------- def get_bba(self, name: str) -> "BBA": - return self.__get("BBA tool", name, self.__TUNING_TOOLS) + return self._get("BBA tool", name, self._TOOLS) # ---- Dispersive orbit -------------------------------------------- def get_dispersion_tuning(self, name: str) -> "Dispersion": - return self.__get("Dispersion tool", name, self.__TUNING_TOOLS) + return self._get("Dispersion tool", name, self._TOOLS) @property def dispersion(self) -> "Dispersion": @@ -365,16 +362,16 @@ def _get_array(self, name: str): The method returns the array object referenced by 'name', regardless of its concrete type. """ - if name in self.__BPM_ARRAYS: - return self.__BPM_ARRAYS[name] - if name in self.__MAGNET_ARRAYS: - return self.__MAGNET_ARRAYS[name] - if name in self.__CFM_MAGNET_ARRAYS: - return self.__CFM_MAGNET_ARRAYS[name] - if name in self.__SERIALIZED_MAGNETS_ARRAYS: - return self.__SERIALIZED_MAGNETS_ARRAYS[name] - if name in self.__ELEMENT_ARRAYS: - return self.__ELEMENT_ARRAYS[name] + if name in self._BPM_ARRAYS: + return self._BPM_ARRAYS[name] + if name in self._MAGNET_ARRAYS: + return self._MAGNET_ARRAYS[name] + if name in self._CFM_MAGNET_ARRAYS: + return self._CFM_MAGNET_ARRAYS[name] + if name in self._SERIALIZED_MAGNETS_ARRAYS: + return self._SERIALIZED_MAGNETS_ARRAYS[name] + if name in self._ELEMENT_ARRAYS: + return self._ELEMENT_ARRAYS[name] raise PyAMLException(f"Array {name} not defined") @@ -382,41 +379,41 @@ def _get_tool(self, name: str): """ Generic tuning tool resolver used by YellowPages. """ - if name not in self.__TUNING_TOOLS: + if name not in self._TOOLS: raise PyAMLException(f"Tool {name} not defined") - return self.__TUNING_TOOLS[name] + return self._TOOLS[name] def _get_diagnostic(self, name: str): """ Generic diagnostic resolver used by YellowPages. """ - if name not in self.__DIAG: + if name not in self._DIAG: raise PyAMLException(f"Diagnostic {name} not defined") - return self.__DIAG[name] + return self._DIAG[name] def _list_arrays(self) -> list[str]: """ Return all array identifiers available in this holder. """ arrays: list[str] = [] - arrays.extend(self.__BPM_ARRAYS.keys()) - arrays.extend(self.__MAGNET_ARRAYS.keys()) - arrays.extend(self.__CFM_MAGNET_ARRAYS.keys()) - arrays.extend(self.__SERIALIZED_MAGNETS_ARRAYS.keys()) - arrays.extend(self.__ELEMENT_ARRAYS.keys()) + arrays.extend(self._BPM_ARRAYS.keys()) + arrays.extend(self._MAGNET_ARRAYS.keys()) + arrays.extend(self._CFM_MAGNET_ARRAYS.keys()) + arrays.extend(self._SERIALIZED_MAGNETS_ARRAYS.keys()) + arrays.extend(self._ELEMENT_ARRAYS.keys()) return arrays def _list_tools(self) -> list[str]: """ Return all tuning tool identifiers available in this holder. """ - return list(self.__TUNING_TOOLS.keys()) + return list(self._TOOLS.keys()) def _list_diagnostics(self) -> list[str]: """ Return all diagnostic identifiers available in this holder. """ - return list(self.__DIAG.keys()) + return list(self._DIAG.keys()) def _set_energy(self, E: float): """ diff --git a/pyaml/common/magnet_holder.py b/pyaml/common/magnet_holder.py new file mode 100644 index 000000000..61dcec821 --- /dev/null +++ b/pyaml/common/magnet_holder.py @@ -0,0 +1,39 @@ +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/magnets_holder.py b/pyaml/common/magnets_holder.py new file mode 100644 index 000000000..aeeb01d32 --- /dev/null +++ b/pyaml/common/magnets_holder.py @@ -0,0 +1,41 @@ +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/control/controlsystem.py b/pyaml/control/controlsystem.py index fd96c4d62..85798d983 100644 --- a/pyaml/control/controlsystem.py +++ b/pyaml/control/controlsystem.py @@ -138,7 +138,7 @@ def fill_device(self, elements: list[Element]): strength = RWStrengthScalar(e.model, dev) if e.model.has_physics() else None # Create a unique ref for this control system m = e.attach(self, strength, current) - self.add_magnet(m) + self.magnet.add(m) elif isinstance(e, CombinedFunctionMagnet): devs = self.get_devices_access(e.model.get_device_names()) @@ -149,7 +149,7 @@ def fill_device(self, elements: list[Element]): ms = e.attach(self, strengths, currents) self.add_cfm_magnet(ms[0]) for m in ms[1:]: - self.add_magnet(m) + self.magnet.add(m) elif isinstance(e, SerializedMagnets): devs = self.get_devices_access(e.model.get_device_names()) @@ -165,7 +165,7 @@ def fill_device(self, elements: list[Element]): ms = e.attach(self, strengths, currents) self.add_serialized_magnet(ms[0]) for m in ms[1:]: - self.add_magnet(m) + self.magnet.add(m) elif isinstance(e, BPM): pos_devs = self.get_devices_access(e.get_pos_devices()) diff --git a/pyaml/external/pySC_interface.py b/pyaml/external/pySC_interface.py index d6b6fd996..f39b2c5ca 100644 --- a/pyaml/external/pySC_interface.py +++ b/pyaml/external/pySC_interface.py @@ -34,11 +34,11 @@ def get_orbit(self) -> Tuple[np.array, np.array]: return positions[:, 0], positions[:, 1] def get(self, name: str) -> float: - magnet = self.element_holder.get_magnet(name=name) + magnet = self.element_holder.magnet.get(name=name) return magnet.strength.get() def set(self, name: str, value: float) -> None: - magnet = self.element_holder.get_magnet(name=name) + magnet = self.element_holder.magnet.get(name=name) magnet.strength.set(value=value) # ideally set_and_wait but not implemented time.sleep(self.set_wait_time) return diff --git a/pyaml/lattice/simulator.py b/pyaml/lattice/simulator.py index e518731a1..339bb8578 100644 --- a/pyaml/lattice/simulator.py +++ b/pyaml/lattice/simulator.py @@ -142,7 +142,7 @@ def fill_device(self, elements: list[Element]): strength = RWStrengthScalar(self.get_at_elems(e), e.polynom, e.model) if e.model.has_physics() else None # Create a unique ref for this simulator m = e.attach(self, strength, current) - self.add_magnet(m) + self.magnet.add(m) elif isinstance(e, CombinedFunctionMagnet): currents = RWHardwareArray(self.get_at_elems(e), e.polynoms, e.model) if e.model.has_physics() else None @@ -151,7 +151,7 @@ def fill_device(self, elements: list[Element]): ms = e.attach(self, strengths, currents) self.add_cfm_magnet(ms[0]) for m in ms[1:]: - self.add_magnet(m) + self.magnet.add(m) elif isinstance(e, SerializedMagnets): currents = [] @@ -190,7 +190,7 @@ def fill_device(self, elements: list[Element]): ms = e.attach(self, linked_strengths, linked_currents) self.add_serialized_magnet(ms[0]) for m in ms[1:]: - self.add_magnet(m) + self.magnet.add(m) elif isinstance(e, BPM): # This assumes unique BPM names in the pyAT lattice diff --git a/pyaml/tuning_tools/bba2.py b/pyaml/tuning_tools/bba2.py index 88093967a..b2a4531e8 100644 --- a/pyaml/tuning_tools/bba2.py +++ b/pyaml/tuning_tools/bba2.py @@ -122,9 +122,9 @@ def _init_responses( design = self.peer.peer.design # handles - quad = design.get_magnet(quadname) - sth = design.get_magnet(steererhname) - stv = design.get_magnet(steerervname) + quad = design.magnet.get(quadname) + sth = design.magnet.get(steererhname) + stv = design.magnet.get(steerervname) orbit = design.get_bpms(bpmname).positions tune_design = design.get_tune_tuning(tunename) tune_live = self._peer.get_tune_tuning(tunename) @@ -337,9 +337,9 @@ def measure( # Device handles self.check_peer() - self._h_steer = self.peer.get_magnet(self._cfg.hcorr_name) - self._v_steer = self.peer.get_magnet(self._cfg.vcorr_name) - self._quad = self.peer.get_magnet(self._cfg.quad_name) + 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._bpmi = self._bpms.names().index(self._cfg.bpm_name) diff --git a/pyaml/tuning_tools/chromaticity.py b/pyaml/tuning_tools/chromaticity.py index e75b282df..51617b039 100644 --- a/pyaml/tuning_tools/chromaticity.py +++ b/pyaml/tuning_tools/chromaticity.py @@ -95,7 +95,7 @@ def _cm(self) -> "ChomaticityMonitor": @property def _sextu(self) -> "MagnetArray": self.check_peer() - return self.peer.get_magnets(self.sextu_array_name) + return self.peer.magnets.get(self.sextu_array_name) def get(self): """ diff --git a/pyaml/tuning_tools/chromaticity_response_matrix.py b/pyaml/tuning_tools/chromaticity_response_matrix.py index ab0e23d72..7996978d6 100644 --- a/pyaml/tuning_tools/chromaticity_response_matrix.py +++ b/pyaml/tuning_tools/chromaticity_response_matrix.py @@ -163,7 +163,7 @@ def callback(action: Action, data:dict): """ # Get devices self.check_peer() - sextus = self._peer.get_magnets(self.sextu_array_name) + sextus = self._peer.magnets.get(self.sextu_array_name) cm = self._peer.get_chromaticity_monitor(self.chromaticity_name) self._register_callback(callback) diff --git a/pyaml/tuning_tools/orbit.py b/pyaml/tuning_tools/orbit.py index 6baa1f884..3fc07110f 100644 --- a/pyaml/tuning_tools/orbit.py +++ b/pyaml/tuning_tools/orbit.py @@ -312,8 +312,8 @@ def get_rf_weight(self) -> float: return self._pySC_response_matrix.rf_weight def post_init(self): - self._hcorr = self.peer.get_magnets(self._cfg.hcorr_array_name) - self._vcorr = self.peer.get_magnets(self._cfg.vcorr_array_name) + self._hcorr = self.peer.magnets.get(self._cfg.hcorr_array_name) + self._vcorr = self.peer.magnets.get(self._cfg.vcorr_array_name) hvElts = [] hvElts.extend(self._hcorr) hvElts.extend(self._vcorr) diff --git a/pyaml/tuning_tools/orbit_response_matrix.py b/pyaml/tuning_tools/orbit_response_matrix.py index 68d26fbac..99d6a090f 100644 --- a/pyaml/tuning_tools/orbit_response_matrix.py +++ b/pyaml/tuning_tools/orbit_response_matrix.py @@ -105,8 +105,8 @@ def measure( if corrector_names is None: logger.info(f"Measuring correctors from the default arrays: {self.hcorr_array_name} and {self.vcorr_array_name}.") - hcorrector_names = element_holder.get_magnets(self.hcorr_array_name).names() - vcorrector_names = element_holder.get_magnets(self.vcorr_array_name).names() + hcorrector_names = element_holder.magnets.get(self.hcorr_array_name).names() + vcorrector_names = element_holder.magnets.get(self.vcorr_array_name).names() corrector_names = hcorrector_names + vcorrector_names generator = measure_ORM( @@ -163,8 +163,8 @@ def _pySC_response_data_to_ORMData(self, data: dict) -> OrbitResponseMatrixDataC # all metadata is discarded here. Should we keep something? element_holder = self._peer - all_hcorrector_names = element_holder.get_magnets(self.hcorr_array_name).names() - all_vcorrector_names = element_holder.get_magnets(self.vcorr_array_name).names() + all_hcorrector_names = element_holder.magnets.get(self.hcorr_array_name).names() + all_vcorrector_names = element_holder.magnets.get(self.vcorr_array_name).names() variable_planes = [] for corr in data["input_names"]: if corr in all_hcorrector_names: diff --git a/pyaml/tuning_tools/tune.py b/pyaml/tuning_tools/tune.py index db267725e..2b6d8e69f 100644 --- a/pyaml/tuning_tools/tune.py +++ b/pyaml/tuning_tools/tune.py @@ -109,7 +109,7 @@ def _tm(self) -> "BetatronTuneMonitor": @property def _quads(self) -> "MagnetArray": self.check_peer() - return self.peer.get_magnets(self._cfg.quad_array_name) + return self.peer.magnets.get(self._cfg.quad_array_name) def get(self): """ diff --git a/pyaml/tuning_tools/tune_response_matrix.py b/pyaml/tuning_tools/tune_response_matrix.py index 15f432dc0..fe4ffb625 100644 --- a/pyaml/tuning_tools/tune_response_matrix.py +++ b/pyaml/tuning_tools/tune_response_matrix.py @@ -114,7 +114,7 @@ def callback(action: Action, data:dict): """ # Get devices self.check_peer() - quads = self._peer.get_magnets(self._cfg.quad_array_name) + quads = self._peer.magnets.get(self._cfg.quad_array_name) tm = self._peer.get_betatron_tune_monitor(self._cfg.betatron_tune_name) tunemat = np.zeros((len(quads), 2)) diff --git a/tests/arrays/test_arrays.py b/tests/arrays/test_arrays.py index a523f091e..cc8cff7aa 100644 --- a/tests/arrays/test_arrays.py +++ b/tests/arrays/test_arrays.py @@ -23,8 +23,8 @@ def test_arrays(install_test_package): # Test on model - sr.design.get_magnet("SH1A-C01-H").strength.set(0.000010) - sr.design.get_magnet("SH1A-C01-V").strength.set(0.000015) + sr.design.magnet.get("SH1A-C01-H").strength.set(0.000010) + sr.design.magnet.get("SH1A-C01-V").strength.set(0.000015) o, _ = sr.design.get_lattice().find_orbit() assert np.abs(o[0] - 9.90267693e-05) < 1e-10 @@ -32,8 +32,8 @@ def test_arrays(install_test_package): assert np.abs(o[2] + 1.59928207e-06) < 1e-10 assert np.abs(o[3] + 1.74771216e-05) < 1e-10 - sr.design.get_magnet("SH1A-C02-H").strength.set(-0.000008) - sr.design.get_magnet("SH1A-C02-V").strength.set(-0.000017) + sr.design.magnet.get("SH1A-C02-H").strength.set(-0.000008) + sr.design.magnet.get("SH1A-C02-V").strength.set(-0.000017) o, _ = sr.design.get_lattice().find_orbit() assert np.abs(o[0] - 1.60555804e-04) < 1e-10 @@ -41,8 +41,8 @@ def test_arrays(install_test_package): assert np.abs(o[2] - 3.62695844e-05) < 1e-10 assert np.abs(o[3] + 5.97692290e-06) < 1e-10 - sr.design.get_magnets("HCORR").strengths.set([0.000010, -0.000008]) - sr.design.get_magnets("VCORR").strengths.set([0.000015, -0.000017]) + sr.design.magnets.get("HCORR").strengths.set([0.000010, -0.000008]) + sr.design.magnets.get("VCORR").strengths.set([0.000015, -0.000017]) o, _ = sr.design.get_lattice().find_orbit() assert np.abs(o[0] - 1.60555804e-04) < 1e-10 @@ -53,7 +53,7 @@ def test_arrays(install_test_package): p0 = o[0] # Test kick angle (small angle, no change from above) - sr.design.get_magnet("SH1A-C02-H").angle.set(-0.000008) + sr.design.magnet.get("SH1A-C02-H").angle.set(-0.000008) o, _ = sr.design.get_lattice().find_orbit() assert np.abs(o[0] - 1.60555804e-04) < 1e-10 assert np.abs(o[1] + 2.37234366e-06) < 1e-10 @@ -67,11 +67,11 @@ def test_arrays(install_test_package): # Test on control system # Assert that the virtual magnet share the same model - assert sr.live.get_magnet("SH1A-C01-H").model == sr.live.get_magnet("SH1A-C01-V").model - assert sr.live.get_magnet("SH1A-C02-H").model == sr.live.get_magnet("SH1A-C02-V").model + assert sr.live.magnet.get("SH1A-C01-H").model == sr.live.magnet.get("SH1A-C01-V").model + assert sr.live.magnet.get("SH1A-C02-H").model == sr.live.magnet.get("SH1A-C02-V").model # Using aggregators - sr.live.get_magnets("HCORR").strengths.set([0.000010, -0.000008]) + sr.live.magnets.get("HCORR").strengths.set([0.000010, -0.000008]) ps1 = sr.live.get_cfm_magnet("SH1A-C01").hardwares.get() ps2 = sr.live.get_cfm_magnet("SH1A-C02").hardwares.get() assert np.abs(ps1[0] - 0.02956737880874648) < 1e-10 @@ -80,7 +80,7 @@ def test_arrays(install_test_package): assert np.abs(ps2[0] + 0.02365390304699716) < 1e-10 assert np.abs(ps2[1] - 0) < 1e-10 assert np.abs(ps2[2] - 0) < 1e-10 - sr.live.get_magnets("VCORR").strengths.set([0.000015, -0.000017]) + sr.live.magnets.get("VCORR").strengths.set([0.000015, -0.000017]) ps1 = sr.live.get_cfm_magnet("SH1A-C01").hardwares.get() ps2 = sr.live.get_cfm_magnet("SH1A-C02").hardwares.get() assert np.abs(ps1[0] - 0.02956737880874648) < 1e-10 @@ -90,7 +90,7 @@ def test_arrays(install_test_package): assert np.abs(ps2[1] - 0.06600571179092833) < 1e-10 assert np.abs(ps2[2] + 0.0634854407797858) < 1e-10 - strHV = sr.live.get_magnets("HVCORR").strengths.get() + strHV = sr.live.magnets.get("HVCORR").strengths.get() assert np.abs(strHV[0] - 0.000010) < 1e-10 assert np.abs(strHV[1] + 0.000008) < 1e-10 assert np.abs(strHV[2] - 0.000015) < 1e-10 @@ -99,7 +99,7 @@ def test_arrays(install_test_package): # Reset to 0 ma = importlib.import_module("tango.pyaml.multi_attribute") ma.LAST_NB_WRITTEN = 0 # Total number of setpoints done by multi_attribute - sr.live.get_magnets("HVCORR").strengths.set(0.0) + sr.live.magnets.get("HVCORR").strengths.set(0.0) assert ma.LAST_NB_WRITTEN == 6 # 6 power supply setpoints are needed ps1 = sr.live.get_cfm_magnet("SH1A-C01").hardwares.get() ps2 = sr.live.get_cfm_magnet("SH1A-C02").hardwares.get() @@ -112,7 +112,7 @@ def test_arrays(install_test_package): # Check that the behavior is the same without aggregator mags = [] - for m in sr.live.get_magnets("HVCORR"): + for m in sr.live.magnets.get("HVCORR"): mags.append(m) array = MagnetArray("HVCOOR_noagg", mags, use_aggregator=False) array.strengths.set([0.000010, -0.000008, 0.000015, -0.000017]) @@ -171,7 +171,7 @@ def test_arrays(install_test_package): assert len(allElts) == 11 # Create an array that contains all elements - allMags = MagnetArray("AllMagnets", sr.design.get_all_magnets()) + allMags = MagnetArray("AllMagnets", sr.design.magnets.get()) assert len(allMags) == 7 # Create an array that contains all BPM @@ -227,7 +227,7 @@ def test_arrays(install_test_package): # Empty arrays emptyMag = Magnet(name="EmptyMag", elements=[]) emptyMag.fill_array(sr.design) # Attach the array - v = sr.design.get_magnets("EmptyMag").strengths.get() # Ensure good attach + v = sr.design.magnets.get("EmptyMag").strengths.get() # Ensure good attach assert np.shape(v) == (0,) emptyBPM = BPM(name="emptyBPM", elements=[]) diff --git a/tests/arrays/test_arrays_ops.py b/tests/arrays/test_arrays_ops.py index 7027c761a..5fd706e2c 100644 --- a/tests/arrays/test_arrays_ops.py +++ b/tests/arrays/test_arrays_ops.py @@ -18,8 +18,8 @@ def test_element_array_and_array_intersection_is_autotyped( sr = accelerator_from_fragments(*sr_configuration_fragments) sr.design.get_lattice().disable_6d() - hcorr = sr.live.get_magnets("HCORR") - hvcorr = sr.live.get_magnets("HVCORR") + hcorr = sr.live.magnets.get("HCORR") + hvcorr = sr.live.magnets.get("HVCORR") inter = hvcorr & hcorr @@ -203,8 +203,8 @@ def test_element_array_or_union_is_unique_stable_and_autotyped( sr = accelerator_from_fragments(*sr_configuration_fragments) sr.design.get_lattice().disable_6d() - hcorr = sr.live.get_magnets("HCORR") - vcorr = sr.live.get_magnets("VCORR") + hcorr = sr.live.magnets.get("HCORR") + vcorr = sr.live.magnets.get("VCORR") u = hcorr | vcorr @@ -230,8 +230,8 @@ def test_element_array_add_is_alias_of_union(install_test_package, accelerator_f sr = accelerator_from_fragments(*sr_configuration_fragments) sr.design.get_lattice().disable_6d() - hcorr = sr.live.get_magnets("HCORR") - vcorr = sr.live.get_magnets("VCORR") + hcorr = sr.live.magnets.get("HCORR") + vcorr = sr.live.magnets.get("VCORR") u1 = hcorr | vcorr u2 = hcorr + vcorr diff --git a/tests/arrays/test_patterns.py b/tests/arrays/test_patterns.py index 79dbe8359..9b7ba7329 100644 --- a/tests/arrays/test_patterns.py +++ b/tests/arrays/test_patterns.py @@ -8,11 +8,11 @@ def test_tune(): sr: Accelerator = Accelerator.load("tests/config/EBSTune-patterns.yaml", ignore_external=True) sr.design.get_lattice().disable_6d() - quadForTune = sr.design.get_magnets("QForTune") + quadForTune = sr.design.magnets.get("QForTune") assert len(quadForTune.names()) == 124 - quadForTest = sr.design.get_magnets("QForTest") - assert sr.design.get_magnet("QF1E-C06") is not None - assert sr.design.get_magnet("QF1E-C05") is not None + quadForTest = sr.design.magnets.get("QForTest") + assert sr.design.magnet.get("QF1E-C06") is not None + assert sr.design.magnet.get("QF1E-C05") is not None assert "QF1E-C05" not in quadForTest.names() assert all([not (name.startswith("Q") and name.endswith("-C06")) for name in quadForTest.names()]) diff --git a/tests/arrays/test_ranges_array.py b/tests/arrays/test_ranges_array.py index 56e0ad375..77c8c6d9c 100644 --- a/tests/arrays/test_ranges_array.py +++ b/tests/arrays/test_ranges_array.py @@ -11,10 +11,10 @@ ) def test_ranges_array(install_test_package): sr: Accelerator = Accelerator.load("tests/config/EBSTune.yaml") - mag_cur = sr.live.get_magnets("QForTune").hardwares + mag_cur = sr.live.magnets.get("QForTune").hardwares mag_cur.set(mag_cur.get() + 50) - mag = sr.live.get_magnets("QForTune").strengths + mag = sr.live.magnets.get("QForTune").strengths with pytest.raises(pyaml.PyAMLException, match="out of range") as excinfo: mag.set(mag.get() * 1000.0) diff --git a/tests/bpm/test_bpm.py b/tests/bpm/test_bpm.py index de0c85771..bce9d82e1 100644 --- a/tests/bpm/test_bpm.py +++ b/tests/bpm/test_bpm.py @@ -7,8 +7,8 @@ def test_simulator_bpm_tilt(): sr: Accelerator = Accelerator.load("tests/config/bpms.yaml", ignore_external=True) sr.design.get_lattice().disable_6d() - sr.design.get_magnet("SH1A-C01-H").strength.set(10e-6) # Add orbit - sr.design.get_magnet("SH1A-C01-V").strength.set(10e-6) # Add orbit + 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") assert np.allclose(bpm.positions.get(), np.array([5.90809968e-05, 2.24832853e-05])) assert bpm.tilt.get() == 0 @@ -62,8 +62,8 @@ def test_simulator_bpm_position_with_bad_corrector_strength(): bpm_simple = sr.design.get_bpm("BPM_C01-02") bpm3 = sr.design.get_bpm("BPM_C01-03") - sr.design.get_magnet("SH1A-C01-H").strength.set(-1e-6) - sr.design.get_magnet("SH1A-C01-V").strength.set(-1e-6) + sr.design.magnet.get("SH1A-C01-H").strength.set(-1e-6) + sr.design.magnet.get("SH1A-C01-V").strength.set(-1e-6) for bpm in [bpm1, bpm_simple, bpm3]: assert bpm.positions.get()[0] != 0.0 assert bpm.positions.get()[1] != 0.0 diff --git a/tests/common/test_errors.py b/tests/common/test_errors.py index 1912847e8..a19602065 100644 --- a/tests/common/test_errors.py +++ b/tests/common/test_errors.py @@ -31,14 +31,14 @@ def test_tune(install_test_package): assert "MagnetArray HCORR : duplicate name SH1A-C02-H @index 2" in str(exc.value) sr: Accelerator = Accelerator.load("tests/config/EBSTune.yaml", include_locations=True, validate=True) - m1 = sr.live.get_magnet("QF1E-C04") - m2 = sr.design.get_magnet("QF1A-C05") + m1 = sr.live.magnet.get("QF1E-C04") + m2 = sr.design.magnet.get("QF1A-C05") with pytest.raises(PyAMLException) as exc: ma = MagnetArray("Test", [m1, m2]) assert "MagnetArray Test: All elements must be attached to the same instance" in str(exc.value) with pytest.raises(PyAMLException) as exc: - m2 = sr.design.get_magnet("QF1A-C05XX") + m2 = sr.design.magnet.get("QF1A-C05XX") assert "Magnet QF1A-C05XX not defined" in str(exc.value) with pytest.raises(PyAMLException) as exc: diff --git a/tests/integration/test_dt4acc_twin_smoke.py b/tests/integration/test_dt4acc_twin_smoke.py index 2d6d757e5..4d0b63da0 100644 --- a/tests/integration/test_dt4acc_twin_smoke.py +++ b/tests/integration/test_dt4acc_twin_smoke.py @@ -86,7 +86,7 @@ def test_dt4acc_twin_accelerator_instantiates_and_reads_live_values(root_folder: assert np.isfinite(reference_frequency), f"RF reference frequency is not finite: {reference_frequency!r}" assert reference_frequency > 0.0, f"RF reference frequency should be positive, got {reference_frequency!r}" - accelerator.live.get_magnet(QF_001) + accelerator.live.magnet.get(QF_001) magnetic_strength = _readback_value(accelerator.live.get_device_access(QF_001_STRENGTH)) assert np.isfinite(magnetic_strength), f"{QF_001} magnetic strength is not finite: {magnetic_strength!r}" @@ -100,7 +100,7 @@ def test_dt4acc_twin_accelerator_instantiates_and_reads_live_values(root_folder: ) def test_dt4acc_twin_reads_all_declared_magnetic_strengths(root_folder: Path, config_files: dict[str, str]): accelerator = _build_accelerator(root_folder, config_files) - magnets = [magnet for magnet in accelerator.live.get_all_magnets() if magnet.get_model_name() == magnet.get_name()] + magnets = [magnet for magnet in accelerator.live.magnets.get() if magnet.get_model_name() == magnet.get_name()] combined_function_magnets = accelerator.live.get_all_cfm_magnets() assert magnets or combined_function_magnets @@ -164,8 +164,8 @@ def deactivated_test_orbit_correction(root_folder: Path, config_files: dict[str, orbit_response_matrix.save("orm.json") orbit_correction.load("orm.json") std_kick = 1e-6 - hcorr = control_mode.get_magnets("hcorrectors") - vcorr = control_mode.get_magnets("vcorrectors") + hcorr = control_mode.magnets.get("hcorrectors") + vcorr = control_mode.magnets.get("vcorrectors") print(f"HCORR={hcorr.strengths.get()}") print(f"VCORR={vcorr.strengths.get()}") ref_h, ref_v = bpms.positions.get().T diff --git a/tests/lattice/test_linkers.py b/tests/lattice/test_linkers.py index 5384ddcaa..676038e51 100644 --- a/tests/lattice/test_linkers.py +++ b/tests/lattice/test_linkers.py @@ -28,7 +28,7 @@ def get_name(self) -> str: def test_conf_with_linker(): sr: Accelerator = Accelerator.load("tests/config/sr-attribute-linker.yaml") assert sr is not None - magnet = sr.design.get_magnet("SH1A-C01-H") + magnet = sr.design.magnet.get("SH1A-C01-H") assert magnet is not None @@ -101,7 +101,7 @@ def test_various_naming_addressing(): sr = Accelerator.load("tests/config/EBSNames.yaml", ignore_external=True) ring = sr.design.get_lattice() - elts = sr.design.get_magnet("QF1E").strength._elements + elts = sr.design.magnet.get("QF1E").strength._elements assert len(elts) == 31 check_index( ring, @@ -141,7 +141,7 @@ def test_various_naming_addressing(): ], ) - elts = sr.design.get_magnet("QF1E-ALL").strength._elements + elts = sr.design.magnet.get("QF1E-ALL").strength._elements assert len(elts) == 32 check_index( ring, @@ -182,18 +182,18 @@ def test_various_naming_addressing(): ], ) - elts = sr.design.get_magnet("QF1E-C05").strength._elements + elts = sr.design.magnet.get("QF1E-C05").strength._elements assert len(elts) == 1 check_index(ring, elts, [290]) - elts = sr.design.get_magnet("QF1E-C04-C05-C06").strength._elements + elts = sr.design.magnet.get("QF1E-C04-C05-C06").strength._elements assert len(elts) == 3 check_index(ring, elts, [140, 290, 424]) - elts = sr.design.get_magnet("QF1E-C04-C05-C06-2").strength._elements + elts = sr.design.magnet.get("QF1E-C04-C05-C06-2").strength._elements assert len(elts) == 3 check_index(ring, elts, [140, 290, 424]) - elts = sr.design.get_magnet("QF1E-C04-C05-C06-3").strength._elements + elts = sr.design.magnet.get("QF1E-C04-C05-C06-3").strength._elements assert len(elts) == 3 check_index(ring, elts, [140, 290, 424]) diff --git a/tests/magnet/test_ident_models.py b/tests/magnet/test_ident_models.py index 03582404d..7fa5f0d2e 100644 --- a/tests/magnet/test_ident_models.py +++ b/tests/magnet/test_ident_models.py @@ -20,14 +20,14 @@ def test_cfm_magnets(magnet_file, install_test_package): sr: Accelerator = Accelerator.load(magnet_file) sr.design.get_lattice().disable_6d() - # magnet_design = sr.design.get_magnet("SH1A-C01") - # magnet_live = sr.live.get_magnet("SH1A-C01") + # magnet_design = sr.design.magnet.get("SH1A-C01") + # magnet_live = sr.live.magnet.get("SH1A-C01") # assert isinstance(magnet_design, CombinedFunctionMagnet) # assert isinstance(magnet_live, CombinedFunctionMagnet) - magnet_h_design = sr.design.get_magnet("SH1A-C01-H") - magnet_v_design = sr.design.get_magnet("SH1A-C01-V") - magnet_h_live = sr.live.get_magnet("SH1A-C01-H") - magnet_v_live = sr.live.get_magnet("SH1A-C01-V") + magnet_h_design = sr.design.magnet.get("SH1A-C01-H") + magnet_v_design = sr.design.magnet.get("SH1A-C01-V") + magnet_h_live = sr.live.magnet.get("SH1A-C01-H") + magnet_v_live = sr.live.magnet.get("SH1A-C01-V") assert isinstance(magnet_h_design, HCorrector) assert isinstance(magnet_v_design, VCorrector) assert isinstance(magnet_h_live, HCorrector) diff --git a/tests/tuning_tools/test_tune.py b/tests/tuning_tools/test_tune.py index 0b9542f40..a114230cf 100644 --- a/tests/tuning_tools/test_tune.py +++ b/tests/tuning_tools/test_tune.py @@ -8,12 +8,12 @@ def test_tune(): sr: Accelerator = Accelerator.load("tests/config/EBSTune.yaml", ignore_external=False) assert sr.get_description() == "Accelerator configuration for EBS storage ring" - assert sr.design.get_magnet("QF1E-C04").get_description() == "QF1E-C04 quadrupole" + assert sr.design.magnet.get("QF1E-C04").get_description() == "QF1E-C04 quadrupole" assert sr.design.get_description() == "EBS lattice" sr.design.get_lattice().disable_6d() - quadForTuneDesign = sr.design.get_magnets("QForTune") + quadForTuneDesign = sr.design.magnets.get("QForTune") tune_monitor = sr.design.get_betatron_tune_monitor("BETATRON_TUNE") # Build tune response matrix tune = tune_monitor.tune.get() @@ -47,7 +47,7 @@ def test_tune(): if False: # Correct the tune on live (need a Virutal Accelerator) - quadForTuneLive = sr.live.get_magnets("QForTune") + quadForTuneLive = sr.live.magnets.get("QForTune") strs = quadForTuneLive.strengths.get() strs += np.matmul(correctionmat, [0.1, 0.05]) # Ask for correction [dqx,dqy] quadForTuneLive.strengths.set(strs) diff --git a/tests/tuning_tools/test_tune_hardware.py b/tests/tuning_tools/test_tune_hardware.py index 638bc8397..8e83197df 100644 --- a/tests/tuning_tools/test_tune_hardware.py +++ b/tests/tuning_tools/test_tune_hardware.py @@ -8,7 +8,7 @@ def test_tune(): sr: Accelerator = Accelerator.load("tests/config/EBSTune.yaml", ignore_external=True) sr.design.get_lattice().disable_6d() - quadForTuneDesign = sr.design.get_magnets("QForTune") + quadForTuneDesign = sr.design.magnets.get("QForTune") # Build tune response matrix (hardware units) diff --git a/tests/tuning_tools/test_tuning_orbit_correction.py b/tests/tuning_tools/test_tuning_orbit_correction.py index f41e2ffc5..dce99c236 100644 --- a/tests/tuning_tools/test_tuning_orbit_correction.py +++ b/tests/tuning_tools/test_tuning_orbit_correction.py @@ -19,8 +19,8 @@ def test_tuning_orbit_correction(): ## generate some orbit np.random.seed(42) std_kick = 1e-6 - hcorr = element_holder.get_magnets("HCorr") - vcorr = element_holder.get_magnets("VCorr") + hcorr = element_holder.magnets.get("HCorr") + vcorr = element_holder.magnets.get("VCorr") bpms = element_holder.get_bpms("BPM") x, y = bpms.positions.get().T # get reference orbit diff --git a/tests/tuning_tools/test_tuning_orm.py b/tests/tuning_tools/test_tuning_orm.py index e68152621..9ccf3445a 100644 --- a/tests/tuning_tools/test_tuning_orm.py +++ b/tests/tuning_tools/test_tuning_orm.py @@ -17,8 +17,8 @@ def test_tuning_orm(): orm = element_holder.orm bpms = element_holder.get_bpms("BPM") - hcorr_names = element_holder.get_magnets("HCorr").names()[:4] - vcorr_names = element_holder.get_magnets("VCorr").names()[:4] + 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) orm_data = orm.get()