Implement field parsing

Covers both the electric and magnetic field inputs.

RE mantidproject#38524

Author: cailafinn

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

@@ -18,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, StateComponent, StateFilter
+from sans.state.StateObjects.StatePolarization import StatePolarization, StateComponent, StateFilter, StateField
 from sans.state.StateObjects.StateReductionMode import StateReductionMode
 from sans.state.StateObjects.StateSave import StateSave
 from sans.state.StateObjects.StateScale import StateScale
@@ -531,6 +531,8 @@ def _parse_polarization(self):
                 self.polarization.flippers.append(self._parse_component(flipper_dict))
         self.polarization.polarizer = self._parse_filter(self.get_val("polarizer", polarization_dict))
         self.polarization.analyzer = self._parse_filter(self.get_val("analyzer", polarization_dict))
+        self.polarization.magnetic_field = self._parse_field(self.get_val("magnetic_field", polarization_dict))
+        self.polarization.electric_field = self._parse_field(self.get_val("electric_field", polarization_dict))
 
     def _parse_component(self, component_dict: dict) -> StateComponent:
         component_state = StateComponent()
@@ -557,6 +559,19 @@ def _parse_filter(self, filter_dict: dict) -> StateFilter:
         filter_state.gas_pressure = self.get_val("gas_pressure", filter_dict)
         return filter_state
 
+    def _parse_field(self, field_dict: dict) -> StateField:
+        field_state = StateField()
+        if field_dict is None:
+            return field_state
+        field_state.sample_strength_log = self.get_val("sample_strength_log", field_dict)
+        direction_dict = self.get_val("sample_direction", field_dict)
+        if direction_dict:
+            field_state.sample_direction_a = self.get_val("a", direction_dict)
+            field_state.sample_direction_p = self.get_val("p", direction_dict)
+            field_state.sample_direction_d = self.get_val("d", direction_dict)
+        field_state.sample_direction_log = self.get_val("sample_direction_log", field_dict)
+        return field_state
+
     @staticmethod
     def _get_1d_min_max(one_d_binning: str):
         # TODO: We have to do some special parsing for this type on behalf of the sans codebase

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

@@ -148,12 +148,19 @@ def _reference_schema():
             "initial_polarization": None,
         }
         filter_keys = dict(component_keys, **{"cell_length": None, "gas_pressure": None})
+        field_keys = {
+            "sample_strength_log": None,
+            "sample_direction": {"a", "p", "d"},
+            "sample_direction_log": None,
+        }
         polarization_keys = {
             "flipper_configuration": None,
             "spin_configuration": None,
             "flipper": {"*": component_keys},
             "polarizer": filter_keys,
             "analyzer": filter_keys,
+            "magnetic_field": field_keys,
+            "electric_field": field_keys,
         }
 
         return {

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

@@ -787,6 +787,34 @@ def test_parse_polarizer_and_analyzer(self):
         self.assertEqual("trans_ws", polarizer_state.transmission)
         self.assertEqual("eff_ws", polarizer_state.efficiency)
 
+    def test_parse_fields(self):
+        top_level_dict = {
+            "polarization": {
+                "magnetic_field": {
+                    "sample_strength_log": "nameoflog",
+                    "sample_direction": {"a": 0, "p": 2.3, "d": 0.002},
+                },
+                "electric_field": {
+                    "sample_strength_log": "nameofotherlog",
+                    "sample_direction_log": "nameofanotherlog",
+                },
+            }
+        }
+        parser_result = self._setup_parser(top_level_dict)
+        polarization_state = parser_result.get_state_polarization()
+        electric_state = polarization_state.electric_field
+        magnetic_state = polarization_state.magnetic_field
+        self.assertEqual("nameoflog", magnetic_state.sample_strength_log)
+        self.assertEqual(0, magnetic_state.sample_direction_a)
+        self.assertEqual(2.3, magnetic_state.sample_direction_p)
+        self.assertEqual(0.002, magnetic_state.sample_direction_d)
+        self.assertIsNone(magnetic_state.sample_direction_log)
+        self.assertEqual("nameofotherlog", electric_state.sample_strength_log)
+        self.assertEqual("nameofanotherlog", electric_state.sample_direction_log)
+        self.assertIsNone(electric_state.sample_direction_a)
+        self.assertIsNone(electric_state.sample_direction_p)
+        self.assertIsNone(electric_state.sample_direction_d)
+
 
 if __name__ == "__main__":
     unittest.main()