Implement flipper parsing

RE mantidproject#38524

Author: cailafinn

scripts/SANS/sans/user_file/toml_parsers/toml_v1_parser.py

@@ -5,6 +5,8 @@
 #     & Institut Laue - Langevin
 # SPDX - License - Identifier: GPL - 3.0 +
 
+from typing import Optional
+
 from sans.common.enums import SANSInstrument, ReductionMode, DetectorType, RangeStepType, FitModeForMerge, DataType, FitType, RebinType
 from sans.common.general_functions import get_bank_for_spectrum_number, get_detector_types_from_instrument
 from sans.state.IStateParser import IStateParser
@@ -16,7 +18,7 @@
 from sans.state.StateObjects.StateMaskDetectors import get_mask_builder, StateMaskDetectors
 from sans.state.StateObjects.StateMoveDetectors import get_move_builder
 from sans.state.StateObjects.StateNormalizeToMonitor import get_normalize_to_monitor_builder
-from sans.state.StateObjects.StatePolarization import StatePolarization
+from sans.state.StateObjects.StatePolarization import StatePolarization, StateComponent
 from sans.state.StateObjects.StateReductionMode import StateReductionMode
 from sans.state.StateObjects.StateSave import StateSave
 from sans.state.StateObjects.StateScale import StateScale
@@ -74,7 +76,7 @@ def get_state_normalize_to_monitor(self, _):
     def get_state_reduction_mode(self):
         return self._implementation.reduction_mode
 
-    def get_state_polarization(self):
+    def get_state_polarization(self) -> Optional[StatePolarization]:
         return self._implementation.polarization
 
     def get_state_save(self):
@@ -521,6 +523,24 @@ def _parse_polarization(self):
         polarization_dict = self.get_val("polarization")
         self.polarization.flipper_configuration = self.get_val("flipper_configuration", polarization_dict)
         self.polarization.spin_configuration = self.get_val("spin_configuration", polarization_dict)
+        flipper_dicts = self.get_val("flipper", polarization_dict)
+        if flipper_dicts:
+            for flipper_dict in flipper_dicts.values():
+                self.polarization.flippers.append(self._parse_component(flipper_dict))
+
+    def _parse_component(self, flipper_dict: dict) -> StateComponent:
+        flipper_state = StateComponent()
+        flipper_state.idf_component_name = self.get_val("idf_component_name", flipper_dict)
+        flipper_state.device_name = self.get_val("device_name", flipper_dict)
+        flipper_state.device_type = self.get_val("device_type", flipper_dict)
+        location_dict = self.get_val("location", flipper_dict)
+        if location_dict:
+            flipper_state.location_x = self.get_val("x", location_dict)
+            flipper_state.location_y = self.get_val("y", location_dict)
+            flipper_state.location_z = self.get_val("z", location_dict)
+        flipper_state.transmission = self.get_val("transmission", flipper_dict)
+        flipper_state.efficiency = self.get_val("efficiency", flipper_dict)
+        return flipper_state
 
     @staticmethod
     def _get_1d_min_max(one_d_binning: str):

scripts/SANS/sans/user_file/toml_parsers/toml_v1_schema.py

@@ -138,8 +138,20 @@ def _reference_schema():
         }
 
         polarization_keys = {
-            "flipper_configuration",
-            "spin_configuration",
+            "flipper_configuration": None,
+            "spin_configuration": None,
+            "flipper": {
+                "*": {
+                    "idf_component_name": None,
+                    "device_name": None,
+                    "device_type": None,
+                    "location": {"x", "y", "z"},
+                    "transmission": None,
+                    "efficiency": None,
+                    "empty_cell": None,
+                    "initial_polarization": None,
+                }
+            },
         }
 
         return {

scripts/test/SANS/user_file/toml_parsers/toml_v1_parser_test.py

@@ -705,6 +705,44 @@ def test_parse_polarization(self):
         self.assertEqual("00,11,01,10", polarization_state.flipper_configuration)
         self.assertEqual("-1-1,-1+1,+1-1,+1+1", polarization_state.spin_configuration)
 
+    def test_parse_flippers(self):
+        top_level_dict = {
+            "polarization": {
+                "flipper": {
+                    "polarizing": {
+                        "idf_component_name": "name_in_IDF",
+                        "device_name": "flipper1",
+                        "device_type": "coil",
+                        "location": {"x": 1.17, "y": 0.05, "z": 0.045},
+                        "transmission": "trans_ws",
+                        "efficiency": "eff_ws",
+                    },
+                    "analyzing": {
+                        "idf_component_name": "name_in_IDF_a",
+                        "device_name": "flipper2",
+                        "device_type": "coil",
+                        "location": {"x": 2.17, "y": 0.05, "z": 0.045},
+                        "transmission": "trans_ws",
+                        "efficiency": "eff_ws",
+                    },
+                }
+            }
+        }
+        parser_result = self._setup_parser(top_level_dict)
+        polarization_state = parser_result.get_state_polarization()
+        flippers = polarization_state.flippers
+        self.assertEqual(2, len(flippers))
+        self.assertEqual("flipper1", flippers[0].device_name)
+        self.assertEqual("flipper2", flippers[1].device_name)
+        self.assertEqual(1.17, flippers[0].location_x)
+        self.assertEqual(0.05, flippers[0].location_y)
+        self.assertEqual(0.045, flippers[0].location_z)
+        self.assertEqual(2.17, flippers[1].location_x)
+        self.assertEqual("name_in_IDF", flippers[0].idf_component_name)
+        self.assertEqual("coil", flippers[0].device_type)
+        self.assertEqual("trans_ws", flippers[0].transmission)
+        self.assertEqual("eff_ws", flippers[0].efficiency)
+
 
 if __name__ == "__main__":
     unittest.main()