propagate material through workflow to mantid layer

Refs #21214

scripts/Diffraction/isis_powder/abstract_inst.py

@@ -49,7 +49,7 @@ class AbstractInst(object):
         return calibrate.create_van(instrument=self, run_details=run_details,
                                     absorb=do_absorb_corrections)
 
-    def _focus(self, run_number_string, do_van_normalisation, do_absorb_corrections):
+    def _focus(self, run_number_string, do_van_normalisation, do_absorb_corrections, sample_details=None):
         """
         Focuses the user specified run - should be called by the concrete instrument
         :param run_number_string: The run number(s) to be processed
@@ -58,7 +58,7 @@ class AbstractInst(object):
         """
         self._is_vanadium = False
         return focus.focus(run_number_string=run_number_string, perform_vanadium_norm=do_van_normalisation,
-                           instrument=self, absorb=do_absorb_corrections)
+                           instrument=self, absorb=do_absorb_corrections, sample_details=sample_details)
 
     # Mandatory overrides
 

scripts/Diffraction/isis_powder/polaris.py

@@ -28,7 +28,8 @@ class Polaris(AbstractInst):
         self._inst_settings.update_attributes(kwargs=kwargs)
         return self._focus(run_number_string=self._inst_settings.run_number,
                            do_van_normalisation=self._inst_settings.do_van_normalisation,
-                           do_absorb_corrections=self._inst_settings.do_absorb_corrections)
+                           do_absorb_corrections=self._inst_settings.do_absorb_corrections,
+                           sample_details=self._sample_details)
 
     def create_vanadium(self, **kwargs):
         self._switch_mode_specific_inst_settings(kwargs.get("mode"))

scripts/Diffraction/isis_powder/routines/absorb_corrections.py

@@ -85,19 +85,8 @@ def _calculate__cylinder_absorb_corrections(ws_to_correct, multiple_scattering,
 
 
 def _setup_sample_for_cylinder_absorb_corrections(ws_to_correct, sample_details_obj):
-    geometry_json = {'Shape': 'Cylinder',
-                     'Height': sample_details_obj.height(), 'Radius': sample_details_obj.radius(),
-                     'Center': sample_details_obj.center()}
-    material = sample_details_obj.material_object
-    # See SetSampleMaterial for documentation on this dictionary
-    material_json = {'ChemicalFormula': material.chemical_formula}
-    if material.number_density:
-        material_json["SampleNumberDensity"] = material.number_density
-    if material.absorption_cross_section:
-        material_json["AttenuationXSection"] = material.absorption_cross_section
-    if material.scattering_cross_section:
-        material_json["ScatteringXSection"] = material.scattering_cross_section
-
+    geometry_json = common.generate_sample_geometry(sample_details_obj)
+    material_json = common.generate_sample_material(sample_details_obj)
     mantid.SetSample(InputWorkspace=ws_to_correct, Geometry=geometry_json, Material=material_json)
 
 

scripts/Diffraction/isis_powder/routines/calibrate.py

@@ -31,6 +31,9 @@ def create_van(instrument, run_details, absorb):
     if absorb:
         corrected_van_ws = instrument._apply_absorb_corrections(run_details=run_details,
                                                                 ws_to_correct=corrected_van_ws)
+    else:
+        # Assume that create_van only uses Vanadium runs
+        mantid.SetSampleMaterial(InputWorkspace=corrected_van_ws, ChemicalFormula='V')
 
     aligned_ws = mantid.AlignDetectors(InputWorkspace=corrected_van_ws,
                                        CalibrationFile=run_details.offset_file_path)

scripts/Diffraction/isis_powder/routines/focus.py

@@ -7,18 +7,19 @@ from isis_powder.routines.common_enums import INPUT_BATCHING
 import os
 
 
-def focus(run_number_string, instrument, perform_vanadium_norm, absorb):
+def focus(run_number_string, instrument, perform_vanadium_norm, absorb, sample_details=None):
     input_batching = instrument._get_input_batching_mode()
     if input_batching == INPUT_BATCHING.Individual:
         return _individual_run_focusing(instrument=instrument, perform_vanadium_norm=perform_vanadium_norm,
-                                        run_number=run_number_string, absorb=absorb)
+                                        run_number=run_number_string, absorb=absorb, sample_details=sample_details)
     elif input_batching == INPUT_BATCHING.Summed:
-        return _batched_run_focusing(instrument, perform_vanadium_norm, run_number_string, absorb=absorb)
+        return _batched_run_focusing(instrument, perform_vanadium_norm, run_number_string, absorb=absorb,
+                                     sample_details=sample_details)
     else:
         raise ValueError("Input batching not passed through. Please contact development team.")
 
 
-def _focus_one_ws(ws, run_number, instrument, perform_vanadium_norm, absorb):
+def _focus_one_ws(ws, run_number, instrument, perform_vanadium_norm, absorb, sample_details):
     run_details = instrument._get_run_details(run_number_string=run_number)
     if perform_vanadium_norm:
         _test_splined_vanadium_exists(instrument, run_details)
@@ -38,7 +39,12 @@ def _focus_one_ws(ws, run_number, instrument, perform_vanadium_norm, absorb):
     # Correct for absorption / multiple scattering if required
     if absorb:
         input_workspace = instrument._apply_absorb_corrections(run_details=run_details, ws_to_correct=input_workspace)
-
+    else:
+        # Set sample material if specified by the user
+        if sample_details is not None:
+            mantid.SetSample(InputWorkspace=input_workspace,
+                             Geometry=common.generate_sample_geometry(sample_details),
+                             Material=common.generate_sample_material(sample_details))
     # Align
     aligned_ws = mantid.AlignDetectors(InputWorkspace=input_workspace,
                                        CalibrationFile=run_details.offset_file_path)
@@ -88,13 +94,14 @@ def _apply_vanadium_corrections(instrument, run_number, input_workspace, perform
     return processed_spectra
 
 
-def _batched_run_focusing(instrument, perform_vanadium_norm, run_number_string, absorb):
+def _batched_run_focusing(instrument, perform_vanadium_norm, run_number_string, absorb, sample_details):
     read_ws_list = common.load_current_normalised_ws_list(run_number_string=run_number_string,
                                                           instrument=instrument)
     output = None
     for ws in read_ws_list:
         output = _focus_one_ws(ws=ws, run_number=run_number_string, instrument=instrument,
-                               perform_vanadium_norm=perform_vanadium_norm, absorb=absorb)
+                               perform_vanadium_norm=perform_vanadium_norm, absorb=absorb,
+                               sample_details=sample_details)
     return output
 
 
@@ -109,14 +116,14 @@ def _divide_by_vanadium_splines(spectra_list, spline_file_path):
     return output_list
 
 
-def _individual_run_focusing(instrument, perform_vanadium_norm, run_number, absorb):
+def _individual_run_focusing(instrument, perform_vanadium_norm, run_number, absorb, sample_details):
     # Load and process one by one
     run_numbers = common.generate_run_numbers(run_number_string=run_number)
     output = None
     for run in run_numbers:
         ws = common.load_current_normalised_ws_list(run_number_string=run, instrument=instrument)
         output = _focus_one_ws(ws=ws[0], run_number=run, instrument=instrument, absorb=absorb,
-                               perform_vanadium_norm=perform_vanadium_norm)
+                               perform_vanadium_norm=perform_vanadium_norm, sample_details=sample_details)
     return output