def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
self.reset()
dom = xml.dom.minidom.parseString(xml_str)
# # Get Mantid version
# mtd_version = BaseScriptElement.getMantidBuildVersion(dom)
element_list = dom.getElementsByTagName("Normalization")
if len(element_list)>0:
instrument_dom = element_list[0]
#Peak from/to pixels
self.NormPeakPixels[0] = BaseScriptElement.getStringElement(instrument_dom, "from_peak_pixels")
self.NormPeakPixels[1] = BaseScriptElement.getStringElement(instrument_dom, "to_peak_pixels")
#background flag
self.NormBackgroundFlag = BaseScriptElement.getBoolElement(instrument_dom, "background_flag")
#background from/to pixels
self.NormBackgroundRoi[0] = BaseScriptElement.getStringElement(instrument_dom, "from_back_pixels")
self.NormBackgroundRoi[1] = BaseScriptElement.getStringElement(instrument_dom, "to_back_pixels")
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("PdAndScConversion")
if len(element_list) > 0:
instrument_dom = element_list[0]
self.do_pd_convert = BaseScriptElement.getBoolElement(
instrument_dom,
"do_powder_conversion",
default=PdAndScConversionScript.do_pd_convert)
self.pd_q_range_low = BaseScriptElement.getStringElement(
instrument_dom,
"pd_q_range/low",
default=PdAndScConversionScript.pd_q_range_low)
self.pd_q_range_width = BaseScriptElement.getStringElement(
instrument_dom,
"pd_q_range/width",
default=PdAndScConversionScript.pd_q_range_width)
self.pd_q_range_high = BaseScriptElement.getStringElement(
instrument_dom,
"pd_q_range/high",
default=PdAndScConversionScript.pd_q_range_high)
self.save_powder_nxs = BaseScriptElement.getBoolElement(
instrument_dom,
"save_powder_nexus",
default=PdAndScConversionScript.save_powder_nxs)
self.save_powder_nxs_file = BaseScriptElement.getStringElement(
instrument_dom,
"save_powder_nexus_filename",
default=PdAndScConversionScript.save_powder_nxs_file)
def from_setup_info(self, xml_str):
"""
Read in data from XML using the string representation of the setup algorithm used
to prepare the reduction properties.
@param xml_str: text to read the data from
"""
self.reset()
from mantid.api import Algorithm
dom = xml.dom.minidom.parseString(xml_str)
process_dom = dom.getElementsByTagName("SASProcess")[0]
setup_alg_str = BaseScriptElement.getStringElement(process_dom, 'SetupInfo')
alg=Algorithm.fromString(str(setup_alg_str))
# Transmission
self.transmission = BaseScriptElement.getPropertyValue(alg, "TransmissionValue", default=SampleData.transmission)
self.transmission_spread = BaseScriptElement.getPropertyValue(alg, "TransmissionError", default=SampleData.transmission_spread)
self.dark_current = BaseScriptElement.getPropertyValue(alg, "TransmissionDarkCurrentFile", default='')
self.theta_dependent = BaseScriptElement.getPropertyValue(alg, "ThetaDependentTransmission",
default = SampleData.theta_dependent)
self.sample_thickness = BaseScriptElement.getPropertyValue(alg, "SampleThickness",
default = SampleData.sample_thickness)
trans_method = BaseScriptElement.getPropertyValue(alg, "TransmissionMethod", default='Value')
self.calculate_transmission = trans_method in ['DirectBeam', 'BeamSpreader']
if trans_method=='DirectBeam':
self.calculation_method = SampleData.DirectBeam()
self.calculation_method.from_setup_info(xml_str)
elif trans_method=='BeamSpreader':
self.calculation_method = SampleData.BeamSpreader()
self.calculation_method.from_setup_info(xml_str)
# Data file section
self.data_files = [BaseScriptElement.getStringElement(process_dom, 'Filename', '')]
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("PdAndScConversion")
if len(element_list)>0:
instrument_dom = element_list[0]
self.do_pd_convert = BaseScriptElement.getBoolElement(instrument_dom,
"do_powder_conversion",
default=PdAndScConversionScript.do_pd_convert)
self.pd_q_range_low = BaseScriptElement.getStringElement(instrument_dom,
"pd_q_range/low",
default=PdAndScConversionScript.pd_q_range_low)
self.pd_q_range_width = BaseScriptElement.getStringElement(instrument_dom,
"pd_q_range/width",
default=PdAndScConversionScript.pd_q_range_width)
self.pd_q_range_high = BaseScriptElement.getStringElement(instrument_dom,
"pd_q_range/high",
default=PdAndScConversionScript.pd_q_range_high)
self.save_powder_nxs = BaseScriptElement.getBoolElement(instrument_dom,
"save_powder_nexus",
default=PdAndScConversionScript.save_powder_nxs)
self.save_powder_nxs_file = BaseScriptElement.getStringElement(instrument_dom,
"save_powder_nexus_filename",
default=PdAndScConversionScript.save_powder_nxs_file)
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
self.reset()
dom = xml.dom.minidom.parseString(xml_str)
# # Get Mantid version
# mtd_version = BaseScriptElement.getMantidBuildVersion(dom)
element_list = dom.getElementsByTagName("Advanced")
if len(element_list)>0:
instrument_dom = element_list[0]
#general
self.FilteringDataFlag = BaseScriptElement.getBoolElement(instrument_dom, "filtering_data_flag")
self.DtOverTFlag = BaseScriptElement.getBoolElement(instrument_dom, "dt_over_t_flag")
self.AutoCleanupFlag = BaseScriptElement.getBoolElement(instrument_dom, "auto_cleanup_flag")
self.PercentageQToRemove = BaseScriptElement.getStringElement(instrument_dom, "percentage_q_to_remove")
self.OverwriteDataGeometryFlag = BaseScriptElement.getBoolElement(instrument_dom, "overwrite_data_geometry")
self.DataGeometryFileName = BaseScriptElement.getStringElement(instrument_dom, "data_geometry_file_name")
self.OverwriteNormGeometryFlag = BaseScriptElement.getBoolElement(instrument_dom, "overwrite_norm_geometry")
self.DataCombinedBckFlag = BaseScriptElement.getBoolElement(instrument_dom, "data_combined_bck_flag")
self.DataCombinedSpecularFlag = BaseScriptElement.getBoolElement(instrument_dom, "data_combined_specular_flag")
self.DataCombinedSubtractedFlag = BaseScriptElement.getBoolElement(instrument_dom, "data_combined_subtracted_flag")
self.NormCombinedBckFlag = BaseScriptElement.getBoolElement(instrument_dom, "norm_combined_bck_flag")
self.NormCombinedSpecularFlag = BaseScriptElement.getBoolElement(instrument_dom, "norm_combined_specular_flag")
self.NormCombinedSubtractedFlag = BaseScriptElement.getBoolElement(instrument_dom, "norm_combined_subtracted_flag")
self.RvsTOFFlag = BaseScriptElement.getBoolElement(instrument_dom, "r_vs_tof_flag")
self.RvsTOFCombinedFlag = BaseScriptElement.getBoolElement(instrument_dom, "r_vs_tof_combined_flag")
self.RvsQFlag = BaseScriptElement.getBoolElement(instrument_dom, "r_vs_q_flag")
self.RvsQRebinningFlag = BaseScriptElement.getBoolElement(instrument_dom, "r_vs_q_rebinning_flag")
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("Background")
if len(element_list) > 0:
instrument_dom = element_list[0]
self.sample_thickness = BaseScriptElement.getFloatElement(
instrument_dom,
"sample_thickness",
default=Background.sample_thickness)
self.dark_current_corr = BaseScriptElement.getBoolElement(
instrument_dom,
"dark_current_corr",
default=Background.dark_current_corr)
self.dark_current_file = BaseScriptElement.getStringElement(
instrument_dom, "dark_current_file")
self.background_corr = BaseScriptElement.getBoolElement(
instrument_dom,
"background_corr",
default=Background.background_corr)
self.background_file = BaseScriptElement.getStringElement(
instrument_dom, "background_file")
self.bck_transmission_enabled = BaseScriptElement.getBoolElement(
instrument_dom,
"bck_trans_enabled",
default=Background.bck_transmission_enabled)
self.bck_transmission = BaseScriptElement.getFloatElement(
instrument_dom,
"bck_trans",
default=Background.bck_transmission)
self.bck_transmission_spread = BaseScriptElement.getFloatElement(
instrument_dom,
"bck_trans_spread",
default=Background.bck_transmission_spread)
self.calculate_transmission = BaseScriptElement.getBoolElement(
instrument_dom,
"calculate_trans",
default=Background.calculate_transmission)
self.theta_dependent = BaseScriptElement.getBoolElement(
instrument_dom,
"theta_dependent",
default=Background.theta_dependent)
self.trans_dark_current = BaseScriptElement.getStringElement(
instrument_dom, "trans_dark_current")
for m in [Background.DirectBeam, Background.BeamSpreader]:
method = m()
if method.find(instrument_dom):
method.from_xml(instrument_dom)
self.trans_calculation_method = method
break
def from_xml(self, xml_str):
""" 'Public' method to read in data from XML
@param xml_str: text to read the data from
"""
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("AdvancedSetup")
if len(element_list)>0:
instrument_dom = element_list[0]
self.unwrapref = getFloatElement(instrument_dom, "unwrapref",
AdvancedSetupScript.unwrapref)
self.lowresref = getFloatElement(instrument_dom, "lowresref",
AdvancedSetupScript.lowresref)
self.cropwavelengthmin = getFloatElement(instrument_dom, "cropwavelengthmin",
AdvancedSetupScript.cropwavelengthmin)
self.removepropmppulsewidth = getFloatElement(instrument_dom, "removepromptpulsewidth",
AdvancedSetupScript.removepropmppulsewidth)
try:
self.maxchunksize = BaseScriptElement.getIntElement(instrument_dom,
"maxchunksize", default=AdvancedSetupScript.maxchunksize)
except ValueError:
self.maxchunksize = AdvancedSetupScript.maxchunksize
self.filterbadpulses = getFloatElement(instrument_dom,
"filterbadpulses", AdvancedSetupScript.filterbadpulses)
self.pushdatapositive = BaseScriptElement.getStringElement(instrument_dom,
"pushdatapositive", default=AdvancedSetupScript.pushdatapositive)
self.stripvanadiumpeaks = getBooleanElement(instrument_dom,
"stripvanadiumpeaks", AdvancedSetupScript.stripvanadiumpeaks)
self.vanadiumfwhm = getFloatElement(instrument_dom, "vanadiumfwhm",
AdvancedSetupScript.vanadiumfwhm)
self.vanadiumpeaktol = getFloatElement(instrument_dom, "vanadiumpeaktol",
AdvancedSetupScript.vanadiumpeaktol)
self.vanadiumsmoothparams = BaseScriptElement.getStringElement(instrument_dom,
"vanadiumsmoothparams", default=AdvancedSetupScript.vanadiumsmoothparams)
self.extension = BaseScriptElement.getStringElement(instrument_dom,
"extension", default=AdvancedSetupScript.extension)
self.preserveevents = getBooleanElement(instrument_dom, "preserveevents",
default=AdvancedSetupScript.preserveevents)
self.outputfileprefix = BaseScriptElement.getStringElement(instrument_dom,
"outputfileprefix", default = AdvancedSetupScript.outputfileprefix)
self.scaledata = getFloatElement(instrument_dom, "scaledata",
AdvancedSetupScript.scaledata)
return
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
self.reset()
dom = xml.dom.minidom.parseString(xml_str)
# Get Mantid version
mtd_version = BaseScriptElement.getMantidBuildVersion(dom)
# Sensitivity correction
element_list = dom.getElementsByTagName("Sensitivity")
if len(element_list)>0:
instrument_dom = element_list[0]
self.sensitivity_corr = BaseScriptElement.getBoolElement(instrument_dom, "sensitivity_corr",
default = Detector.sensitivity_corr)
self.sensitivity_data = BaseScriptElement.getStringElement(instrument_dom, "sensitivity_data")
self.sensitivity_dark = BaseScriptElement.getStringElement(instrument_dom, "sensitivity_dark")
self.use_sample_dark = BaseScriptElement.getBoolElement(instrument_dom, "use_sample_dark",
default = Detector.use_sample_dark)
self.min_sensitivity = BaseScriptElement.getFloatElement(instrument_dom, "sensitivity_min",
default=Detector.min_sensitivity)
self.max_sensitivity = BaseScriptElement.getFloatElement(instrument_dom, "sensitivity_max",
default=Detector.max_sensitivity)
self.use_sample_beam_center = BaseScriptElement.getBoolElement(instrument_dom, "use_sample_beam_center",
default = Detector.use_sample_beam_center)
beam_center_list = instrument_dom.getElementsByTagName("FloodBeamFinder")
if len(beam_center_list)>0:
beam_finder_dom = beam_center_list[0]
self.flood_x_position = BaseScriptElement.getFloatElement(beam_finder_dom, "x",
default=Detector.flood_x_position)
self.flood_y_position = BaseScriptElement.getFloatElement(beam_finder_dom, "y",
default=Detector.flood_y_position)
self.flood_use_finder = BaseScriptElement.getBoolElement(beam_finder_dom, "use_finder",
default = Detector.flood_use_finder)
self.flood_beam_file = BaseScriptElement.getStringElement(beam_finder_dom, "beam_file")
self.flood_beam_radius = BaseScriptElement.getFloatElement(beam_finder_dom, "beam_radius",
default=Detector.flood_beam_radius)
self.flood_use_direct_beam = BaseScriptElement.getBoolElement(beam_finder_dom, "use_direct_beam",
default = Detector.flood_use_direct_beam)
element_list = dom.getElementsByTagName("BeamFinder")
if len(element_list)>0:
beam_finder_dom = element_list[0]
self.x_position = BaseScriptElement.getFloatElement(beam_finder_dom, "x",
default=Detector.x_position)
self.y_position = BaseScriptElement.getFloatElement(beam_finder_dom, "y",
default=Detector.y_position)
self.use_finder = BaseScriptElement.getBoolElement(beam_finder_dom, "use_finder",
default = Detector.use_finder)
self.beam_file = BaseScriptElement.getStringElement(beam_finder_dom, "beam_file")
self.beam_radius = BaseScriptElement.getFloatElement(beam_finder_dom, "beam_radius",
default=Detector.beam_radius)
self.use_direct_beam = BaseScriptElement.getBoolElement(beam_finder_dom, "use_direct_beam",
default = Detector.use_direct_beam)
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("AbsoluteUnits")
if len(element_list)>0:
instrument_dom = element_list[0]
self.find_bad_detectors = BaseScriptElement.getBoolElement(instrument_dom,
"do_absolute_units",
default=AbsoluteUnitsScript.do_absolute_units)
self.absunits_vanadium = BaseScriptElement.getStringElement(instrument_dom,
"absunits_vanadium",
default=AbsoluteUnitsScript.absunits_vanadium)
self.grouping_file = BaseScriptElement.getStringElement(instrument_dom,
"grouping_file",
default=AbsoluteUnitsScript.grouping_file)
self.absunits_detector_vanadium = BaseScriptElement.getStringElement(instrument_dom,
"absunits_detector_vanadium",
default=AbsoluteUnitsScript.absunits_detector_vanadium)
self.incident_energy = BaseScriptElement.getStringElement(instrument_dom,
"incident_energy",
default=AbsoluteUnitsScript.incident_energy)
self.emin = BaseScriptElement.getFloatElement(instrument_dom,
"minimum_energy",
default=AbsoluteUnitsScript.emin)
self.emax = BaseScriptElement.getFloatElement(instrument_dom,
"maximum_energy",
default=AbsoluteUnitsScript.emax)
self.vanadium_mass = BaseScriptElement.getFloatElement(instrument_dom,
"vanadium_mass",
default=AbsoluteUnitsScript.vanadium_mass)
self.sample_mass = BaseScriptElement.getFloatElement(instrument_dom,
"sample_mass",
default=AbsoluteUnitsScript.sample_mass)
self.sample_rmm = BaseScriptElement.getFloatElement(instrument_dom,
"sample_rmm",
default=AbsoluteUnitsScript.sample_rmm)
self.absunits_median_test_out_low = BaseScriptElement.getFloatElement(instrument_dom,
"median_test_out_low",
default=AbsoluteUnitsScript.absunits_median_test_out_low)
self.absunits_median_test_out_high = BaseScriptElement.getFloatElement(instrument_dom,
"median_test_out_high",
default=AbsoluteUnitsScript.absunits_median_test_out_high)# noqa
self.absunits_median_test_low = BaseScriptElement.getFloatElement(instrument_dom,
"median_test_low",
default=AbsoluteUnitsScript.absunits_median_test_low)
self.absunits_median_test_high = BaseScriptElement.getFloatElement(instrument_dom,
"median_test_high",
default=AbsoluteUnitsScript.absunits_median_test_high)
self.absunits_errorbar_criterion = BaseScriptElement.getFloatElement(instrument_dom,
"errorbar_criterion",
default=AbsoluteUnitsScript.absunits_errorbar_criterion)
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
self.reset()
dom = xml.dom.minidom.parseString(xml_str)
# Sensitivity correction
element_list = dom.getElementsByTagName("Sensitivity")
if len(element_list)>0:
instrument_dom = element_list[0]
self.sensitivity_corr = BaseScriptElement.getBoolElement(instrument_dom, "sensitivity_corr",
default = Detector.sensitivity_corr)
self.sensitivity_data = BaseScriptElement.getStringElement(instrument_dom, "sensitivity_data")
self.sensitivity_dark = BaseScriptElement.getStringElement(instrument_dom, "sensitivity_dark")
self.use_sample_dark = BaseScriptElement.getBoolElement(instrument_dom, "use_sample_dark",
default = Detector.use_sample_dark)
self.min_sensitivity = BaseScriptElement.getFloatElement(instrument_dom, "sensitivity_min",
default=Detector.min_sensitivity)
self.max_sensitivity = BaseScriptElement.getFloatElement(instrument_dom, "sensitivity_max",
default=Detector.max_sensitivity)
self.use_sample_beam_center = BaseScriptElement.getBoolElement(instrument_dom, "use_sample_beam_center",
default = Detector.use_sample_beam_center)
beam_center_list = instrument_dom.getElementsByTagName("FloodBeamFinder")
if len(beam_center_list)>0:
beam_finder_dom = beam_center_list[0]
self.flood_x_position = BaseScriptElement.getFloatElement(beam_finder_dom, "x",
default=Detector.flood_x_position)
self.flood_y_position = BaseScriptElement.getFloatElement(beam_finder_dom, "y",
default=Detector.flood_y_position)
self.flood_use_finder = BaseScriptElement.getBoolElement(beam_finder_dom, "use_finder",
default = Detector.flood_use_finder)
self.flood_beam_file = BaseScriptElement.getStringElement(beam_finder_dom, "beam_file")
self.flood_beam_radius = BaseScriptElement.getFloatElement(beam_finder_dom, "beam_radius",
default=Detector.flood_beam_radius)
self.flood_use_direct_beam = BaseScriptElement.getBoolElement(beam_finder_dom, "use_direct_beam",
default = Detector.flood_use_direct_beam)
element_list = dom.getElementsByTagName("BeamFinder")
if len(element_list)>0:
beam_finder_dom = element_list[0]
self.x_position = BaseScriptElement.getFloatElement(beam_finder_dom, "x",
default=Detector.x_position)
self.y_position = BaseScriptElement.getFloatElement(beam_finder_dom, "y",
default=Detector.y_position)
self.use_finder = BaseScriptElement.getBoolElement(beam_finder_dom, "use_finder",
default = Detector.use_finder)
self.beam_file = BaseScriptElement.getStringElement(beam_finder_dom, "beam_file")
self.beam_radius = BaseScriptElement.getFloatElement(beam_finder_dom, "beam_radius",
default=Detector.beam_radius)
self.use_direct_beam = BaseScriptElement.getBoolElement(beam_finder_dom, "use_direct_beam",
default = Detector.use_direct_beam)
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("AbsoluteUnits")
if len(element_list)>0:
instrument_dom = element_list[0]
self.find_bad_detectors = BaseScriptElement.getBoolElement(instrument_dom,
"do_absolute_units",
default=AbsoluteUnitsScript.do_absolute_units)
self.absunits_vanadium = BaseScriptElement.getStringElement(instrument_dom,
"absunits_vanadium",
default=AbsoluteUnitsScript.absunits_vanadium)
self.grouping_file = BaseScriptElement.getStringElement(instrument_dom,
"grouping_file",
default=AbsoluteUnitsScript.grouping_file)
self.absunits_detector_vanadium = BaseScriptElement.getStringElement(instrument_dom,
"absunits_detector_vanadium",
default=AbsoluteUnitsScript.absunits_detector_vanadium)
self.incident_energy = BaseScriptElement.getStringElement(instrument_dom,
"incident_energy",
default=AbsoluteUnitsScript.incident_energy)
self.emin = BaseScriptElement.getFloatElement(instrument_dom,
"minimum_energy",
default=AbsoluteUnitsScript.emin)
self.emax = BaseScriptElement.getFloatElement(instrument_dom,
"maximum_energy",
default=AbsoluteUnitsScript.emax)
self.vanadium_mass = BaseScriptElement.getFloatElement(instrument_dom,
"vanadium_mass",
default=AbsoluteUnitsScript.vanadium_mass)
self.sample_mass = BaseScriptElement.getFloatElement(instrument_dom,
"sample_mass",
default=AbsoluteUnitsScript.sample_mass)
self.sample_rmm = BaseScriptElement.getFloatElement(instrument_dom,
"sample_rmm",
default=AbsoluteUnitsScript.sample_rmm)
self.absunits_median_test_out_low = BaseScriptElement.getFloatElement(instrument_dom,
"median_test_out_low",
default=AbsoluteUnitsScript.absunits_median_test_out_low)
self.absunits_median_test_out_high = BaseScriptElement.getFloatElement(instrument_dom,
"median_test_out_high",
default=AbsoluteUnitsScript.absunits_median_test_out_high)# noqa
self.absunits_median_test_low = BaseScriptElement.getFloatElement(instrument_dom,
"median_test_low",
default=AbsoluteUnitsScript.absunits_median_test_low)
self.absunits_median_test_high = BaseScriptElement.getFloatElement(instrument_dom,
"median_test_high",
default=AbsoluteUnitsScript.absunits_median_test_high)
self.absunits_errorbar_criterion = BaseScriptElement.getFloatElement(instrument_dom,
"errorbar_criterion",
default=AbsoluteUnitsScript.absunits_errorbar_criterion)
def from_xml(self, dom):
"""
Read in data from XML
@param dom: text to read the data from
"""
element_list = dom.getElementsByTagName("DirectBeam")
if len(element_list)>0:
instrument_dom = element_list[0]
self.sample_file = BaseScriptElement.getStringElement(instrument_dom, "sample_file")
self.direct_beam = BaseScriptElement.getStringElement(instrument_dom, "direct_beam")
self.beam_radius = BaseScriptElement.getFloatElement(instrument_dom, "beam_radius",
default=SampleData.DirectBeam.beam_radius)
def from_xml(self, dom):
"""
Read in data from XML
@param dom: text to read the data from
"""
element_list = dom.getElementsByTagName("DirectBeam")
if len(element_list)>0:
instrument_dom = element_list[0]
self.sample_file = BaseScriptElement.getStringElement(instrument_dom, "sample_file")
self.direct_beam = BaseScriptElement.getStringElement(instrument_dom, "direct_beam")
self.beam_radius = BaseScriptElement.getFloatElement(instrument_dom, "beam_radius",
default=SampleData.DirectBeam.beam_radius)
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("SampleSetup")
if len(element_list)>0:
instrument_dom = element_list[0]
self.sample_file = BaseScriptElement.getStringElement(instrument_dom,
"sample_input_file",
default=SampleSetupScript.sample_file)
self.output_wsname = BaseScriptElement.getStringElement(instrument_dom,
"output_wsname",
default=SampleSetupScript.output_wsname)
self.detcal_file = BaseScriptElement.getStringElement(instrument_dom,
"detcal_file",
default=SampleSetupScript.detcal_file)
self.relocate_dets = BaseScriptElement.getBoolElement(instrument_dom,
"relocate_dets",
default=SampleSetupScript.relocate_dets)
self.incident_energy_guess = BaseScriptElement.getStringElement(instrument_dom,
"incident_energy_guess",
default=SampleSetupScript.incident_energy_guess)
self.use_ei_guess = BaseScriptElement.getBoolElement(instrument_dom,
"use_ei_guess",
default=SampleSetupScript.use_ei_guess)
self.tzero_guess = BaseScriptElement.getFloatElement(instrument_dom,
"tzero_guess",
default=SampleSetupScript.tzero_guess)
self.monitor1_specid = BaseScriptElement.getIntElement(instrument_dom,
"monitor1_specid",
default=SampleSetupScript.monitor1_specid)
self.monitor2_specid = BaseScriptElement.getIntElement(instrument_dom,
"monitor2_specid",
default=SampleSetupScript.monitor2_specid)
self.et_range_low = BaseScriptElement.getStringElement(instrument_dom,
"et_range/low",
default=SampleSetupScript.et_range_low)
self.et_range_width = BaseScriptElement.getStringElement(instrument_dom,
"et_range/width",
default=SampleSetupScript.et_range_width)
self.et_range_high = BaseScriptElement.getStringElement(instrument_dom,
"et_range/high",
default=SampleSetupScript.et_range_high)
self.et_is_distribution = BaseScriptElement.getBoolElement(instrument_dom,
"sofphie_is_distribution",
default=SampleSetupScript.et_is_distribution)
self.hardmask_file = BaseScriptElement.getStringElement(instrument_dom,
"hardmask_file",
default=SampleSetupScript.hardmask_file)
self.grouping_file = BaseScriptElement.getStringElement(instrument_dom,
"grouping_file",
default=SampleSetupScript.grouping_file)
self.show_workspaces = BaseScriptElement.getBoolElement(instrument_dom,
"show_workspaces",
default=SampleSetupScript.show_workspaces)
def from_xml(self, dom):
"""
Read in data from XML
@param dom: text to read the data from
"""
element_list = dom.getElementsByTagName("BeamSpreader")
if len(element_list)>0:
instrument_dom = element_list[0]
self.sample_scatt = BaseScriptElement.getStringElement(instrument_dom, "sample_scatt")
self.sample_spreader = BaseScriptElement.getStringElement(instrument_dom, "sample_spreader")
self.direct_scatt = BaseScriptElement.getStringElement(instrument_dom, "direct_scatt")
self.direct_spreader = BaseScriptElement.getStringElement(instrument_dom, "direct_spreader")
self.spreader_trans = BaseScriptElement.getFloatElement(instrument_dom, "spreader_trans",
default=SampleData.BeamSpreader.spreader_trans)
self.spreader_trans_spread = BaseScriptElement.getFloatElement(instrument_dom, "spreader_trans_spread",
default=SampleData.BeamSpreader.spreader_trans_spread)
def getStringElement(self, instrument_dom, xmlname, default):
""" Get a float value from xml
"""
value = BaseScriptElement.getStringElement(instrument_dom, xmlname,
default)
return value
def getStringElement(self, instrument_dom, xmlname, default):
""" Get a float value from xml
"""
value = BaseScriptElement.getStringElement(instrument_dom, xmlname,
default)
return value
def from_setup_info(self, xml_str):
"""
Read in data from XML using the string representation of the setup algorithm used
to prepare the reduction properties.
@param xml_str: text to read the data from
"""
self.reset()
from mantid.api import Algorithm
dom = xml.dom.minidom.parseString(xml_str)
process_dom = dom.getElementsByTagName("SASProcess")[0]
setup_alg_str = BaseScriptElement.getStringElement(
process_dom, 'SetupInfo')
alg = Algorithm.fromString(str(setup_alg_str))
self.sample_scatt = BaseScriptElement.getPropertyValue(
alg, "BckTransSampleScatteringFilename", default='')
self.sample_spreader = BaseScriptElement.getPropertyValue(
alg, "BckTransSampleSpreaderFilename", default='')
self.direct_scatt = BaseScriptElement.getPropertyValue(
alg, "BckTransDirectScatteringFilename", default='')
self.direct_spreader = BaseScriptElement.getPropertyValue(
alg, "BckTransDirectSpreaderFilename", default='')
self.spreader_trans = BaseScriptElement.getPropertyValue(
alg,
"BckSpreaderTransmissionValue",
default=SampleData.BeamSpreader.spreader_trans)
self.spreader_trans_spread = BaseScriptElement.getPropertyValue(
alg,
"BckSpreaderTransmissionError",
default=SampleData.BeamSpreader.spreader_trans_spread)
def from_xml(self, dom):
"""
Read in data from XML
@param dom: text to read the data from
"""
element_list = dom.getElementsByTagName("BeamSpreader")
if len(element_list)>0:
instrument_dom = element_list[0]
self.sample_scatt = BaseScriptElement.getStringElement(instrument_dom, "sample_scatt")
self.sample_spreader = BaseScriptElement.getStringElement(instrument_dom, "sample_spreader")
self.direct_scatt = BaseScriptElement.getStringElement(instrument_dom, "direct_scatt")
self.direct_spreader = BaseScriptElement.getStringElement(instrument_dom, "direct_spreader")
self.spreader_trans = BaseScriptElement.getFloatElement(instrument_dom, "spreader_trans",
default=SampleData.BeamSpreader.spreader_trans)
self.spreader_trans_spread = BaseScriptElement.getFloatElement(instrument_dom, "spreader_trans_spread",
default=SampleData.BeamSpreader.spreader_trans_spread)
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
self.reset()
super(ReductionOptions, self).from_xml(xml_str)
dom = xml.dom.minidom.parseString(xml_str)
instrument_dom = dom.getElementsByTagName("Instrument")[0]
self.detector_offset = BaseScriptElement.getFloatElement(
instrument_dom,
"detector_offset",
default=ReductionOptions.default_detector_offset)
# TOF cutoff and correction
element_list = dom.getElementsByTagName("TOFcorr")
if len(element_list) > 0:
tof_dom = element_list[0]
self.use_config_cutoff = BaseScriptElement.getBoolElement(
tof_dom,
"use_config_cutoff",
default=ReductionOptions.use_config_cutoff)
self.correct_for_flight_path = BaseScriptElement.getBoolElement(
tof_dom,
"perform_flight_path_corr",
default=ReductionOptions.correct_for_flight_path)
self.low_TOF_cut = BaseScriptElement.getFloatElement(
tof_dom, "low_tof_cut", default=ReductionOptions.low_TOF_cut)
self.high_TOF_cut = BaseScriptElement.getFloatElement(
tof_dom, "high_tof_cut", default=ReductionOptions.high_TOF_cut)
# Mask
self.use_config_mask = BaseScriptElement.getBoolElement(
dom, "UseConfigMask", default=ReductionOptions.use_config_mask)
# Resolution
self.compute_resolution = BaseScriptElement.getBoolElement(
dom,
"ComputeResolution",
default=ReductionOptions.compute_resolution)
self.sample_aperture_diameter = BaseScriptElement.getFloatElement(
dom,
"SampleApertureDiameter",
default=ReductionOptions.sample_aperture_diameter)
# TOF correction
self.perform_TOF_correction = BaseScriptElement.getBoolElement(
dom,
"PerformTOFCorrection",
default=ReductionOptions.perform_TOF_correction)
# Normalization option
self.use_beam_monitor = BaseScriptElement.getBoolElement(
dom, "UseBeamMonitor", default=ReductionOptions.use_beam_monitor)
self.beam_monitor_reference = BaseScriptElement.getStringElement(
dom,
"BeamMonitorRef",
default=ReductionOptions.beam_monitor_reference)
def from_setup_info(self, xml_str):
"""
Read in data from XML using the string representation of the setup algorithm used
to prepare the reduction properties.
@param xml_str: text to read the data from
"""
self.reset()
super(ReductionOptions, self).from_setup_info(xml_str)
from mantid.api import Algorithm
dom = xml.dom.minidom.parseString(xml_str)
process_dom = dom.getElementsByTagName("SASProcess")[0]
setup_alg_str = BaseScriptElement.getStringElement(process_dom, 'SetupInfo')
alg=Algorithm.fromString(str(setup_alg_str))
self.use_config_cutoff = BaseScriptElement.getPropertyValue(alg, "UseConfigTOFCuts",
default=ReductionOptions.use_config_cutoff)
self.correct_for_flight_path = BaseScriptElement.getPropertyValue(alg, "CorrectForFlightPath",
default=ReductionOptions.correct_for_flight_path)
self.low_TOF_cut = BaseScriptElement.getPropertyValue(alg, "LowTOFCut",
default=ReductionOptions.low_TOF_cut)
self.high_TOF_cut = BaseScriptElement.getPropertyValue(alg, "HighTOFCut",
default=ReductionOptions.high_TOF_cut)
self.use_config_mask = BaseScriptElement.getPropertyValue(alg, "UseConfigMask",
default=ReductionOptions.use_config_mask)
self.compute_resolution = BaseScriptElement.getPropertyValue(alg, "ComputeResolution",
default=ReductionOptions.compute_resolution)
self.sample_aperture_diameter = BaseScriptElement.getPropertyValue(alg, "SampleApertureDiameter",
default=ReductionOptions.sample_aperture_diameter)
self.perform_TOF_correction = not BaseScriptElement.getPropertyValue(alg, "SkipTOFCorrection",
default=False)
norm_option = BaseScriptElement.getPropertyValue(alg, "Normalisation", default = 'Monitor')
self.use_beam_monitor = norm_option=='Monitor'
self.beam_monitor_reference = BaseScriptElement.getPropertyValue(alg, "MonitorReferenceFile",
default=ReductionOptions.beam_monitor_reference)
def from_setup_info(self, xml_str):
"""
Read in data from XML using the string representation of the setup algorithm used
to prepare the reduction properties.
@param xml_str: text to read the data from
"""
self.reset()
from mantid.api import Algorithm
dom = xml.dom.minidom.parseString(xml_str)
process_dom = dom.getElementsByTagName("SASProcess")[0]
setup_alg_str = BaseScriptElement.getStringElement(
process_dom, 'SetupInfo')
alg = Algorithm.fromString(str(setup_alg_str))
# Sensitivity correction
self.sensitivity_data = BaseScriptElement.getPropertyValue(
alg, "SensitivityFile", default='')
self.sensitivity_corr = len(self.sensitivity_data) > 0
self.sensitivity_dark = BaseScriptElement.getPropertyValue(
alg, "SensitivityDarkCurrentFile", default='')
self.use_sample_dark = BaseScriptElement.getPropertyValue(
alg, "UseDefaultDC", default=Detector.use_sample_dark)
self.min_sensitivity = BaseScriptElement.getPropertyValue(
alg, "MinEfficiency", default=Detector.min_sensitivity)
self.max_sensitivity = BaseScriptElement.getPropertyValue(
alg, "MaxEfficiency", default=Detector.max_sensitivity)
sensitivity_center_method = BaseScriptElement.getPropertyValue(
alg, "SensitivityBeamCenterMethod", default='None')
self.flood_use_finder = sensitivity_center_method in [
'DirectBeam', 'Scattering'
]
self.flood_use_direct_beam = sensitivity_center_method == 'DirectBeam'
self.use_sample_beam_center = sensitivity_center_method == 'None'
self.flood_x_position = BaseScriptElement.getPropertyValue(
alg, "SensitivityBeamCenterX", default=Detector.flood_x_position)
self.flood_y_position = BaseScriptElement.getPropertyValue(
alg, "SensitivityBeamCenterY", default=Detector.flood_y_position)
self.flood_beam_file = BaseScriptElement.getPropertyValue(
alg, "SensitivityBeamCenterFile", default='')
self.flood_beam_radius = BaseScriptElement.getPropertyValue(alg, "SensitivityBeamCenterRadius",\
default=Detector.flood_beam_radius)
# Beam center
center_method = BaseScriptElement.getPropertyValue(alg,
"BeamCenterMethod",
default='None')
self.use_finder = center_method in ['DirectBeam', 'Scattering']
self.use_direct_beam = center_method == 'DirectBeam'
self.x_position = BaseScriptElement.getPropertyValue(alg, "BeamCenterX",\
default=Detector.x_position)
self.y_position = BaseScriptElement.getPropertyValue(alg, "BeamCenterY",\
default=Detector.y_position)
self.beam_file = BaseScriptElement.getPropertyValue(alg,
"BeamCenterFile",
default='')
self.beam_radius = BaseScriptElement.getPropertyValue(alg, "BeamRadius",\
default=Detector.beam_radius)
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("Background")
if len(element_list)>0:
instrument_dom = element_list[0]
self.sample_thickness = BaseScriptElement.getFloatElement(instrument_dom, "sample_thickness",
default=Background.sample_thickness)
self.dark_current_corr = BaseScriptElement.getBoolElement(instrument_dom, "dark_current_corr",
default = Background.dark_current_corr)
self.dark_current_file = BaseScriptElement.getStringElement(instrument_dom, "dark_current_file")
self.background_corr = BaseScriptElement.getBoolElement(instrument_dom, "background_corr",
default = Background.background_corr)
self.background_file = BaseScriptElement.getStringElement(instrument_dom, "background_file")
self.bck_transmission_enabled = BaseScriptElement.getBoolElement(instrument_dom, "bck_trans_enabled",
default = Background.bck_transmission_enabled)
self.bck_transmission = BaseScriptElement.getFloatElement(instrument_dom, "bck_trans",
default=Background.bck_transmission)
self.bck_transmission_spread = BaseScriptElement.getFloatElement(instrument_dom, "bck_trans_spread",
default=Background.bck_transmission_spread)
self.calculate_transmission = BaseScriptElement.getBoolElement(instrument_dom, "calculate_trans",
default = Background.calculate_transmission)
self.theta_dependent = BaseScriptElement.getBoolElement(instrument_dom, "theta_dependent",
default = Background.theta_dependent)
self.trans_dark_current = BaseScriptElement.getStringElement(instrument_dom, "trans_dark_current")
for m in [Background.DirectBeam, Background.BeamSpreader]:
method = m()
if method.find(instrument_dom):
method.from_xml(instrument_dom)
self.trans_calculation_method = method
break
def getIntegerElement(self, instrument_dom, xmlname, default):
""" Get a float value from xml
"""
integerstr = BaseScriptElement.getStringElement(instrument_dom, xmlname, default)
if integerstr != "" and integerstr is not None and integerstr != "None":
try:
value = int(integerstr)
except ValueError:
print "Warning! XML field %s value %s cannot be converted to integer" % (xmlname, integerstr)
value = None
else:
value = None
return value
def getIntegerElement(self, instrument_dom, xmlname, default):
""" Get a float value from xml
"""
integerstr = BaseScriptElement.getStringElement(instrument_dom, xmlname, default)
if integerstr != "" and integerstr is not None and integerstr != "None":
try:
value = int(integerstr)
except ValueError:
print ("Warning! XML field %s value %s cannot be converted to integer" % (xmlname, integerstr))
value = None
else:
value = None
return value
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("DataCorrections")
if len(element_list)>0:
instrument_dom = element_list[0]
self.filter_bad_pulses = BaseScriptElement.getBoolElement(instrument_dom,
"filter_bad_pulses",
default=DataCorrectionsScript.filter_bad_pulses)
self.incident_beam_norm = BaseScriptElement.getStringElement(instrument_dom,
"incident_beam_norm",
default=DataCorrectionsScript.incident_beam_norm)
self.monitor_int_low = BaseScriptElement.getIntElement(instrument_dom,
"monint_range_low",
default=DataCorrectionsScript.monitor_int_low)
self.monitor_int_high = BaseScriptElement.getIntElement(instrument_dom,
"monint_range_high",
default=DataCorrectionsScript.monitor_int_high)
self.tib_subtraction = BaseScriptElement.getBoolElement(instrument_dom,
"timeindepbkg_sub",
default=DataCorrectionsScript.tib_subtraction)
self.tib_tof_start = BaseScriptElement.getIntElement(instrument_dom,
"tib_tof_range_start",
default=DataCorrectionsScript.tib_tof_start)
self.tib_tof_end = BaseScriptElement.getIntElement(instrument_dom,
"tib_tof_range_end",
default=DataCorrectionsScript.tib_tof_end)
self.correct_kikf = BaseScriptElement.getBoolElement(instrument_dom,
"correct_kikf",
default=DataCorrectionsScript.correct_kikf)
self.detector_vanadium = BaseScriptElement.getStringElement(instrument_dom,
"detector_vanadium",
default=DataCorrectionsScript.detector_vanadium)
self.detvan_integration = BaseScriptElement.getBoolElement(instrument_dom,
"use_bounds_detvan",
default=DataCorrectionsScript.detvan_integration)
self.detvan_int_range_low = BaseScriptElement.getStringElement(instrument_dom,
"detvan_range_low",
default=DataCorrectionsScript.detvan_int_range_low)
self.detvan_int_range_high = BaseScriptElement.getStringElement(instrument_dom,
"detvan_range_high",
default=DataCorrectionsScript.detvan_int_range_high)
self.detvan_int_range_units = BaseScriptElement.getStringElement(instrument_dom,
"detvan_range_units",
default=DataCorrectionsScript.detvan_int_range_units)
self.save_proc_detvan = BaseScriptElement.getBoolElement(instrument_dom,
"save_proc_detvan",
default=DataCorrectionsScript.save_proc_detvan)
self.save_proc_detvan_file = BaseScriptElement.getStringElement(instrument_dom,
"save_proc_detvan_filename",
default=DataCorrectionsScript.save_proc_detvan_file)
self.use_proc_detvan = BaseScriptElement.getBoolElement(instrument_dom,
"use_proc_detvan",
default=DataCorrectionsScript.use_proc_detvan)
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("DataCorrections")
if len(element_list)>0:
instrument_dom = element_list[0]
self.filter_bad_pulses = BaseScriptElement.getBoolElement(instrument_dom,
"filter_bad_pulses",
default=DataCorrectionsScript.filter_bad_pulses)
self.incident_beam_norm = BaseScriptElement.getStringElement(instrument_dom,
"incident_beam_norm",
default=DataCorrectionsScript.incident_beam_norm)
self.monitor_int_low = BaseScriptElement.getIntElement(instrument_dom,
"monint_range_low",
default=DataCorrectionsScript.monitor_int_low)
self.monitor_int_high = BaseScriptElement.getIntElement(instrument_dom,
"monint_range_high",
default=DataCorrectionsScript.monitor_int_high)
self.tib_subtraction = BaseScriptElement.getBoolElement(instrument_dom,
"timeindepbkg_sub",
default=DataCorrectionsScript.tib_subtraction)
self.tib_tof_start = BaseScriptElement.getIntElement(instrument_dom,
"tib_tof_range_start",
default=DataCorrectionsScript.tib_tof_start)
self.tib_tof_end = BaseScriptElement.getIntElement(instrument_dom,
"tib_tof_range_end",
default=DataCorrectionsScript.tib_tof_end)
self.correct_kikf = BaseScriptElement.getBoolElement(instrument_dom,
"correct_kikf",
default=DataCorrectionsScript.correct_kikf)
self.detector_vanadium = BaseScriptElement.getStringElement(instrument_dom,
"detector_vanadium",
default=DataCorrectionsScript.detector_vanadium)
self.detvan_integration = BaseScriptElement.getBoolElement(instrument_dom,
"use_bounds_detvan",
default=DataCorrectionsScript.detvan_integration)
self.detvan_int_range_low = BaseScriptElement.getStringElement(instrument_dom,
"detvan_range_low",
default=DataCorrectionsScript.detvan_int_range_low)
self.detvan_int_range_high = BaseScriptElement.getStringElement(instrument_dom,
"detvan_range_high",
default=DataCorrectionsScript.detvan_int_range_high)
self.detvan_int_range_units = BaseScriptElement.getStringElement(instrument_dom,
"detvan_range_units",
default=DataCorrectionsScript.detvan_int_range_units)
self.save_proc_detvan = BaseScriptElement.getBoolElement(instrument_dom,
"save_proc_detvan",
default=DataCorrectionsScript.save_proc_detvan)
self.save_proc_detvan_file = BaseScriptElement.getStringElement(instrument_dom,
"save_proc_detvan_filename",
default=DataCorrectionsScript.save_proc_detvan_file)
self.use_proc_detvan = BaseScriptElement.getBoolElement(instrument_dom,
"use_proc_detvan",
default=DataCorrectionsScript.use_proc_detvan)
def from_setup_info(self, xml_str):
"""
Read in data from XML using the string representation of the setup algorithm used
to prepare the reduction properties.
@param xml_str: text to read the data from
"""
self.reset()
from mantid.api import Algorithm
dom = xml.dom.minidom.parseString(xml_str)
process_dom = dom.getElementsByTagName("SASProcess")[0]
setup_alg_str = BaseScriptElement.getStringElement(process_dom, 'SetupInfo')
alg=Algorithm.fromString(str(setup_alg_str))
# Sensitivity correction
self.sensitivity_data = BaseScriptElement.getPropertyValue(alg, "SensitivityFile", default='')
self.sensitivity_corr = len(self.sensitivity_data)>0
self.sensitivity_dark = BaseScriptElement.getPropertyValue(alg, "SensitivityDarkCurrentFile", default='')
self.use_sample_dark = BaseScriptElement.getPropertyValue(alg, "UseDefaultDC",
default = Detector.use_sample_dark)
self.min_sensitivity = BaseScriptElement.getPropertyValue(alg, "MinEfficiency",
default=Detector.min_sensitivity)
self.max_sensitivity = BaseScriptElement.getPropertyValue(alg, "MaxEfficiency",
default=Detector.max_sensitivity)
sensitivity_center_method = BaseScriptElement.getPropertyValue(alg, "SensitivityBeamCenterMethod",
default='None')
self.flood_use_finder = sensitivity_center_method in ['DirectBeam', 'Scattering']
self.flood_use_direct_beam = sensitivity_center_method=='DirectBeam'
self.use_sample_beam_center = sensitivity_center_method=='None'
self.flood_x_position = BaseScriptElement.getPropertyValue(alg, "SensitivityBeamCenterX",
default=Detector.flood_x_position)
self.flood_y_position = BaseScriptElement.getPropertyValue(alg, "SensitivityBeamCenterY",
default=Detector.flood_y_position)
self.flood_beam_file = BaseScriptElement.getPropertyValue(alg, "SensitivityBeamCenterFile", default='')
self.flood_beam_radius = BaseScriptElement.getPropertyValue(alg, "SensitivityBeamCenterRadius",\
default=Detector.flood_beam_radius)
# Beam center
center_method = BaseScriptElement.getPropertyValue(alg, "BeamCenterMethod", default='None')
self.use_finder = center_method in ['DirectBeam', 'Scattering']
self.use_direct_beam = center_method=='DirectBeam'
self.x_position = BaseScriptElement.getPropertyValue(alg, "BeamCenterX",\
default=Detector.x_position)
self.y_position = BaseScriptElement.getPropertyValue(alg, "BeamCenterY",\
default=Detector.y_position)
self.beam_file = BaseScriptElement.getPropertyValue(alg, "BeamCenterFile", default='')
self.beam_radius = BaseScriptElement.getPropertyValue(alg, "BeamRadius",\
default=Detector.beam_radius)
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
self.reset()
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("Transmission")
if len(element_list) > 0:
instrument_dom = element_list[0]
self.transmission = BaseScriptElement.getFloatElement(
instrument_dom, "trans", default=SampleData.transmission)
self.transmission_spread = BaseScriptElement.getFloatElement(
instrument_dom,
"trans_spread",
default=SampleData.transmission_spread)
self.calculate_transmission = BaseScriptElement.getBoolElement(
instrument_dom,
"calculate_trans",
default=SampleData.calculate_transmission)
self.theta_dependent = BaseScriptElement.getBoolElement(
instrument_dom,
"theta_dependent",
default=SampleData.theta_dependent)
self.dark_current = BaseScriptElement.getStringElement(
instrument_dom, "dark_current")
for m in self.option_list:
method = m()
if method.find(instrument_dom):
method.from_xml(instrument_dom)
self.calculation_method = method
break
# Data file section
element_list = dom.getElementsByTagName("SampleData")
if len(element_list) > 0:
sample_data_dom = element_list[0]
self.data_files = BaseScriptElement.getStringList(
sample_data_dom, "data_file")
self.sample_thickness = BaseScriptElement.getFloatElement(
sample_data_dom,
"sample_thickness",
default=SampleData.sample_thickness)
self.separate_jobs = BaseScriptElement.getBoolElement(
sample_data_dom,
"separate_jobs",
default=SampleData.separate_jobs)
def getBooleanElement(instrument_dom, keyname, default):
""" Get a boolean value from an element.
Boolean can be recorded as
(1) True/False
(2) 1/0
"""
tempbool = BaseScriptElement.getStringElement(instrument_dom,
keyname, default=default)
if tempbool == "True":
tempbool = 1
elif tempbool == "False":
tempbool = 0
return bool(int(tempbool))
def getBooleanElement(instrument_dom, keyname, default):
""" Get a boolean value from an element.
Boolean can be recorded as
(1) True/False
(2) 1/0
"""
tempbool = BaseScriptElement.getStringElement(instrument_dom,\
keyname, default=default)
if tempbool == "True":
tempbool = 1
elif tempbool == "False":
tempbool = 0
return bool(int(tempbool))
def getFloatElement(self, instrument_dom, xmlname, default):
""" Get a float value from xml
"""
floatstr = BaseScriptElement.getStringElement(instrument_dom, xmlname, default)
if floatstr != "" and floatstr is not None and floatstr != "None":
try:
value = float(floatstr)
except ValueError:
print ("Warning! XML field %s value %s cannot be converted to float" % (xmlname, floatstr))
value = None
else:
value = None
return value
def getFloatElement(self, instrument_dom, xmlname, default):
""" Get a float value from xml
"""
floatstr = BaseScriptElement.getStringElement(instrument_dom, xmlname, default)
if floatstr != "" and floatstr is not None and floatstr != "None":
try:
value = float(floatstr)
except ValueError:
print "Warning! XML field %s value %s cannot be converted to float" % (xmlname, floatstr)
value = None
else:
value = None
return value
def from_setup_info(self, xml_str):
"""
Read in data from XML using the string representation of the setup algorithm used
to prepare the reduction properties.
@param xml_str: text to read the data from
"""
self.reset()
super(ReductionOptions, self).from_setup_info(xml_str)
from mantid.api import Algorithm
dom = xml.dom.minidom.parseString(xml_str)
process_dom = dom.getElementsByTagName("SASProcess")[0]
setup_alg_str = BaseScriptElement.getStringElement(
process_dom, 'SetupInfo')
alg = Algorithm.fromString(str(setup_alg_str))
self.use_config_cutoff = BaseScriptElement.getPropertyValue(
alg,
"UseConfigTOFCuts",
default=ReductionOptions.use_config_cutoff)
self.correct_for_flight_path = BaseScriptElement.getPropertyValue(
alg,
"CorrectForFlightPath",
default=ReductionOptions.correct_for_flight_path)
self.low_TOF_cut = BaseScriptElement.getPropertyValue(
alg, "LowTOFCut", default=ReductionOptions.low_TOF_cut)
self.high_TOF_cut = BaseScriptElement.getPropertyValue(
alg, "HighTOFCut", default=ReductionOptions.high_TOF_cut)
self.use_config_mask = BaseScriptElement.getPropertyValue(
alg, "UseConfigMask", default=ReductionOptions.use_config_mask)
self.compute_resolution = BaseScriptElement.getPropertyValue(
alg,
"ComputeResolution",
default=ReductionOptions.compute_resolution)
self.sample_aperture_diameter = BaseScriptElement.getPropertyValue(
alg,
"SampleApertureDiameter",
default=ReductionOptions.sample_aperture_diameter)
self.perform_TOF_correction = not BaseScriptElement.getPropertyValue(
alg, "SkipTOFCorrection", default=False)
norm_option = BaseScriptElement.getPropertyValue(alg,
"Normalisation",
default='Monitor')
self.use_beam_monitor = norm_option == 'Monitor'
self.beam_monitor_reference = BaseScriptElement.getPropertyValue(
alg,
"MonitorReferenceFile",
default=ReductionOptions.beam_monitor_reference)
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
self.reset()
super(ReductionOptions, self).from_xml(xml_str)
dom = xml.dom.minidom.parseString(xml_str)
instrument_dom = dom.getElementsByTagName("Instrument")[0]
self.detector_offset = BaseScriptElement.getFloatElement(instrument_dom, "detector_offset",
default=ReductionOptions.default_detector_offset)
# TOF cutoff and correction
element_list = dom.getElementsByTagName("TOFcorr")
if len(element_list)>0:
tof_dom = element_list[0]
self.use_config_cutoff = BaseScriptElement.getBoolElement(tof_dom, "use_config_cutoff",
default = ReductionOptions.use_config_cutoff)
self.correct_for_flight_path = BaseScriptElement.getBoolElement(tof_dom, "perform_flight_path_corr",
default = ReductionOptions.correct_for_flight_path)
self.low_TOF_cut = BaseScriptElement.getFloatElement(tof_dom, "low_tof_cut",
default=ReductionOptions.low_TOF_cut)
self.high_TOF_cut = BaseScriptElement.getFloatElement(tof_dom, "high_tof_cut",
default=ReductionOptions.high_TOF_cut)
# Mask
self.use_config_mask = BaseScriptElement.getBoolElement(dom, "UseConfigMask",
default = ReductionOptions.use_config_mask)
# Resolution
self.compute_resolution = BaseScriptElement.getBoolElement(dom, "ComputeResolution",
default = ReductionOptions.compute_resolution)
self.sample_aperture_diameter = BaseScriptElement.getFloatElement(dom, "SampleApertureDiameter",\
default = ReductionOptions.sample_aperture_diameter)
# TOF correction
self.perform_TOF_correction = BaseScriptElement.getBoolElement(dom, "PerformTOFCorrection",
default = ReductionOptions.perform_TOF_correction)
# Normalization option
self.use_beam_monitor = BaseScriptElement.getBoolElement(dom, "UseBeamMonitor",
default = ReductionOptions.use_beam_monitor)
self.beam_monitor_reference = BaseScriptElement.getStringElement(dom, "BeamMonitorRef",
default = ReductionOptions.beam_monitor_reference)
def from_setup_info(self, xml_str):
"""
Read in data from XML using the string representation of the setup algorithm used
to prepare the reduction properties.
@param xml_str: text to read the data from
"""
self.reset()
super(SampleData, self).from_setup_info(xml_str)
from mantid.api import Algorithm
dom = xml.dom.minidom.parseString(xml_str)
process_dom = dom.getElementsByTagName("SASProcess")[0]
setup_alg_str = BaseScriptElement.getStringElement(process_dom, 'SetupInfo')
alg=Algorithm.fromString(str(setup_alg_str))
self.combine_transmission_frames = BaseScriptElement.getPropertyValue(alg, "FitFramesTogether",
default=SampleData.combine_transmission_frames)
def from_xml_element(self, instrument_dom):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
# incident medium
self.incident_medium_list = BaseScriptElement.getStringList(
instrument_dom, "incident_medium_list")
self.incident_medium_index_selected = BaseScriptElement.getIntElement(
instrument_dom, "incident_medium_index_selected")
self.tof_min = BaseScriptElement.getFloatElement(
instrument_dom, "tof_min")
self.tof_max = BaseScriptElement.getFloatElement(
instrument_dom, "tof_max")
# run number
self.data_file = BaseScriptElement.getIntElement(
instrument_dom, "data_file")
# number of attenuator
self.number_attenuator = BaseScriptElement.getIntElement(
instrument_dom, "number_attenuator")
# peak selection from and to
self.peak_selection = [
BaseScriptElement.getIntElement(instrument_dom,
"peak_selection_from_pixel"),
BaseScriptElement.getIntElement(instrument_dom,
"peak_selection_to_pixel")
]
# background flag and selection from and to
self.back_selection = [
BaseScriptElement.getIntElement(instrument_dom,
"back_selection_from_pixel"),
BaseScriptElement.getIntElement(instrument_dom,
"back_selection_to_pixel")
]
# lambda requested
self.lambda_requested = BaseScriptElement.getStringElement(
instrument_dom, "lambda_requested")
# s1h, s2h, s1w, s2w
self.s1h = BaseScriptElement.getStringElement(instrument_dom, "s1h")
self.s2h = BaseScriptElement.getStringElement(instrument_dom, "s2h")
self.s1w = BaseScriptElement.getStringElement(instrument_dom, "s1w")
self.s2w = BaseScriptElement.getStringElement(instrument_dom, "s2w")
# scaling factor file
self.scaling_factor_file = BaseScriptElement.getStringElement(
instrument_dom, "scaling_factor_file")
def from_setup_info(self, xml_str):
"""
Read in data from XML using the string representation of the setup algorithm used
to prepare the reduction properties.
@param xml_str: text to read the data from
"""
self.reset()
from mantid.api import Algorithm
dom = xml.dom.minidom.parseString(xml_str)
process_dom = dom.getElementsByTagName("SASProcess")[0]
setup_alg_str = BaseScriptElement.getStringElement(process_dom, 'SetupInfo')
alg=Algorithm.fromString(str(setup_alg_str))
self.sample_file = BaseScriptElement.getPropertyValue(alg, "BckTransmissionSampleDataFile", default='')
self.direct_beam = BaseScriptElement.getPropertyValue(alg, "BckTransmissionEmptyDataFile", default='')
self.beam_radius = BaseScriptElement.getPropertyValue(alg, "BckTransmissionBeamRadius",
default=SampleData.DirectBeam.beam_radius)
def from_setup_info(self, xml_str):
"""
Read in data from XML using the string representation of the setup algorithm used
to prepare the reduction properties.
@param xml_str: text to read the data from
"""
self.reset()
from mantid.api import Algorithm
dom = xml.dom.minidom.parseString(xml_str)
process_dom = dom.getElementsByTagName("SASProcess")[0]
setup_alg_str = BaseScriptElement.getStringElement(process_dom, 'SetupInfo')
alg=Algorithm.fromString(str(setup_alg_str))
self.sample_file = BaseScriptElement.getPropertyValue(alg, "TransmissionSampleDataFile", default='')
self.direct_beam = BaseScriptElement.getPropertyValue(alg, "TransmissionEmptyDataFile", default='')
self.beam_radius = BaseScriptElement.getPropertyValue(alg, "TransmissionBeamRadius",
default=SampleData.DirectBeam.beam_radius)
def from_setup_info(self, xml_str):
"""
Read in data from XML using the string representation of the setup algorithm used
to prepare the reduction properties.
@param xml_str: text to read the data from
"""
self.reset()
super(Background, self).from_setup_info(xml_str)
from mantid.api import Algorithm
dom = xml.dom.minidom.parseString(xml_str)
process_dom = dom.getElementsByTagName("SASProcess")[0]
setup_alg_str = BaseScriptElement.getStringElement(
process_dom, 'SetupInfo')
alg = Algorithm.fromString(str(setup_alg_str))
self.combine_transmission_frames = BaseScriptElement.getPropertyValue(
alg,
"BckFitFramesTogether",
default=SampleData.combine_transmission_frames)
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
self.reset()
dom = xml.dom.minidom.parseString(xml_str)
# Get Mantid version
mtd_version = BaseScriptElement.getMantidBuildVersion(dom)
element_list = dom.getElementsByTagName("Transmission")
if len(element_list)>0:
instrument_dom = element_list[0]
self.transmission = BaseScriptElement.getFloatElement(instrument_dom, "trans",
default=SampleData.transmission)
self.transmission_spread = BaseScriptElement.getFloatElement(instrument_dom, "trans_spread",
default=SampleData.transmission_spread)
self.calculate_transmission = BaseScriptElement.getBoolElement(instrument_dom, "calculate_trans",
default = SampleData.calculate_transmission)
self.theta_dependent = BaseScriptElement.getBoolElement(instrument_dom, "theta_dependent",
default = SampleData.theta_dependent)
self.dark_current = BaseScriptElement.getStringElement(instrument_dom, "dark_current")
for m in self.option_list:
method = m()
if method.find(instrument_dom):
method.from_xml(instrument_dom)
self.calculation_method = method
break
# Data file section - take care of backward compatibility
if mtd_version!=0 and mtd_version<BaseScriptElement.UPDATE_1_CHANGESET_CUTOFF:
element_list = dom.getElementsByTagName("Instrument")
else:
element_list = dom.getElementsByTagName("SampleData")
if len(element_list)>0:
sample_data_dom = element_list[0]
self.data_files = BaseScriptElement.getStringList(sample_data_dom, "data_file")
self.sample_thickness = BaseScriptElement.getFloatElement(sample_data_dom, "sample_thickness",
default=SampleData.sample_thickness)
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
self.reset()
dom = xml.dom.minidom.parseString(xml_str)
# # Get Mantid version
# mtd_version = BaseScriptElement.getMantidBuildVersion(dom)
element_list = dom.getElementsByTagName("Data")
if len(element_list)>0:
instrument_dom = element_list[0]
#Peak selection
self.DataPeakSelectionType = BaseScriptElement.getStringElement(instrument_dom, "peak_selection_type")
#Peak from/to pixels
self.DataPeakPixels[0] = BaseScriptElement.getIntElement(instrument_dom, "from_peak_pixels")
self.DataPeakPixels[1] = BaseScriptElement.getIntElement(instrument_dom, "to_peak_pixels")
#discrete selection string
self.DataBackgroundFlag = BaseScriptElement.getStringElement(instrument_dom, "peak_discrete_selection")
#background flag
self.DataBackgroundFlag = BaseScriptElement.getBoolElement(instrument_dom, "background_flag")
#background from/to pixels
self.DataBackgroundRoi[0] = BaseScriptElement.getStringElement(instrument_dom, "back_roi1_from")
self.DataBackgroundRoi[1] = BaseScriptElement.getStringElement(instrument_dom, "back_roi1_to")
self.DataBackgroundRoi[2] = BaseScriptElement.getStringElement(instrument_dom, "back_roi2_from")
self.DataBackgroundRoi[3] = BaseScriptElement.getStringElement(instrument_dom, "back_roi2_to")
#from TOF and to TOF
self.DataTofRange[0] = BaseScriptElement.getStringElement(instrument_dom, "from_tof_range")
self.DataTofRange[1] = BaseScriptElement.getStringElement(instrument_dom, "to_tof_range")
def from_setup_info(self, xml_str):
"""
Read in data from XML using the string representation of the setup algorithm used
to prepare the reduction properties.
@param xml_str: text to read the data from
"""
self.reset()
from mantid.api import Algorithm
dom = xml.dom.minidom.parseString(xml_str)
process_dom = dom.getElementsByTagName("SASProcess")[0]
setup_alg_str = BaseScriptElement.getStringElement(process_dom, 'SetupInfo')
alg=Algorithm.fromString(str(setup_alg_str))
self.sample_scatt = BaseScriptElement.getPropertyValue(alg, "BckTransSampleScatteringFilename", default='')
self.sample_spreader = BaseScriptElement.getPropertyValue(alg, "BckTransSampleSpreaderFilename", default='')
self.direct_scatt = BaseScriptElement.getPropertyValue(alg, "BckTransDirectScatteringFilename", default='')
self.direct_spreader = BaseScriptElement.getPropertyValue(alg, "BckTransDirectSpreaderFilename", default='')
self.spreader_trans = BaseScriptElement.getPropertyValue(alg, "BckSpreaderTransmissionValue",
default=SampleData.BeamSpreader.spreader_trans)
self.spreader_trans_spread = BaseScriptElement.getPropertyValue(alg, "BckSpreaderTransmissionError",
default=SampleData.BeamSpreader.spreader_trans_spread)
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
self.reset()
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("Transmission")
if len(element_list)>0:
instrument_dom = element_list[0]
self.transmission = BaseScriptElement.getFloatElement(instrument_dom, "trans",
default=SampleData.transmission)
self.transmission_spread = BaseScriptElement.getFloatElement(instrument_dom, "trans_spread",
default=SampleData.transmission_spread)
self.calculate_transmission = BaseScriptElement.getBoolElement(instrument_dom, "calculate_trans",
default = SampleData.calculate_transmission)
self.theta_dependent = BaseScriptElement.getBoolElement(instrument_dom, "theta_dependent",
default = SampleData.theta_dependent)
self.dark_current = BaseScriptElement.getStringElement(instrument_dom, "dark_current")
for m in self.option_list:
method = m()
if method.find(instrument_dom):
method.from_xml(instrument_dom)
self.calculation_method = method
break
# Data file section
element_list = dom.getElementsByTagName("SampleData")
if len(element_list)>0:
sample_data_dom = element_list[0]
self.data_files = BaseScriptElement.getStringList(sample_data_dom, "data_file")
self.sample_thickness = BaseScriptElement.getFloatElement(sample_data_dom, "sample_thickness",
default=SampleData.sample_thickness)
self.separate_jobs = BaseScriptElement.getBoolElement(sample_data_dom, "separate_jobs",
default = SampleData.separate_jobs)
def from_xml_element(self, instrument_dom):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
#incident medium
self.incident_medium_list = BaseScriptElement.getStringList(instrument_dom, "incident_medium_list")
self.incident_medium_index_selected = BaseScriptElement.getIntElement(instrument_dom, "incident_medium_index_selected")
self.tof_min = BaseScriptElement.getFloatElement(instrument_dom, "tof_min")
self.tof_max = BaseScriptElement.getFloatElement(instrument_dom, "tof_max")
#run number
self.data_file = BaseScriptElement.getIntElement(instrument_dom, "data_file")
#number of attenuator
self.number_attenuator = BaseScriptElement.getIntElement(instrument_dom, "number_attenuator")
#peak selection from and to
self.peak_selection = [BaseScriptElement.getIntElement(instrument_dom, "peak_selection_from_pixel"),
BaseScriptElement.getIntElement(instrument_dom, "peak_selection_to_pixel")]
#background flag and selection from and to
self.back_selection = [BaseScriptElement.getIntElement(instrument_dom, "back_selection_from_pixel"),
BaseScriptElement.getIntElement(instrument_dom, "back_selection_to_pixel")]
#lambda requested
self.lambda_requested = BaseScriptElement.getStringElement(instrument_dom, "lambda_requested")
#s1h, s2h, s1w, s2w
self.s1h = BaseScriptElement.getStringElement(instrument_dom, "s1h")
self.s2h = BaseScriptElement.getStringElement(instrument_dom, "s2h")
self.s1w = BaseScriptElement.getStringElement(instrument_dom, "s1w")
self.s2w = BaseScriptElement.getStringElement(instrument_dom, "s2w")
#scaling factor file
self.scaling_factor_file = BaseScriptElement.getStringElement(instrument_dom, "scaling_factor_file")
def from_xml_element(self, instrument_dom):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
#Peak selection
self.DataPeakSelectionType = BaseScriptElement.getStringElement(instrument_dom, "peak_selection_type")
#Peak from/to pixels
self.DataPeakPixels = [BaseScriptElement.getIntElement(instrument_dom, "from_peak_pixels"),
BaseScriptElement.getIntElement(instrument_dom, "to_peak_pixels")]
#data metadata
_tthd_value = BaseScriptElement.getStringElement(instrument_dom, "tthd_value")
if (_tthd_value == ''):
_tthd_value = 'N/A'
self.tthd_value = _tthd_value
_ths_value = BaseScriptElement.getStringElement(instrument_dom, "ths_value")
if (_ths_value == ''):
_ths_value = 'N/A'
self.ths_value = _ths_value
#low resolution range
self.data_x_range_flag = BaseScriptElement.getBoolElement(instrument_dom, "x_range_flag",
default=DataSets.data_x_range_flag)
self.data_x_range = [BaseScriptElement.getIntElement(instrument_dom, "x_min_pixel"),
BaseScriptElement.getIntElement(instrument_dom, "x_max_pixel")]
self.norm_x_range_flag = BaseScriptElement.getBoolElement(instrument_dom, "norm_x_range_flag",
default=DataSets.norm_x_range_flag)
self.norm_x_range = [BaseScriptElement.getIntElement(instrument_dom, "norm_x_min"),
BaseScriptElement.getIntElement(instrument_dom, "norm_x_max")]
#discrete selection string
self.DataPeakDiscreteSelection = BaseScriptElement.getStringElement(instrument_dom, "peak_discrete_selection")
#background flag
self.DataBackgroundFlag = BaseScriptElement.getBoolElement(instrument_dom,
"background_flag",
default=DataSets.DataBackgroundFlag)
#background from/to pixels
self.DataBackgroundRoi = [BaseScriptElement.getIntElement(instrument_dom, "back_roi1_from"),
BaseScriptElement.getIntElement(instrument_dom, "back_roi1_to"),
BaseScriptElement.getIntElement(instrument_dom, "back_roi2_from"),
BaseScriptElement.getIntElement(instrument_dom, "back_roi2_to")]
#from TOF and to TOF
self.TofRangeFlag = BaseScriptElement.getBoolElement(instrument_dom, "tof_range_flag",
default=DataSets.TofRangeFlag)
self.DataTofRange = [BaseScriptElement.getFloatElement(instrument_dom, "from_tof_range"),
BaseScriptElement.getFloatElement(instrument_dom, "to_tof_range")]
self.data_files = BaseScriptElement.getIntList(instrument_dom, "data_sets")
#with or without norm
self.NormFlag = BaseScriptElement.getBoolElement(instrument_dom, "norm_flag",
default=DataSets.NormFlag)
#Peak from/to pixels
self.NormPeakPixels = [BaseScriptElement.getIntElement(instrument_dom, "norm_from_peak_pixels"),
BaseScriptElement.getIntElement(instrument_dom, "norm_to_peak_pixels")]
#background flag
self.NormBackgroundFlag = BaseScriptElement.getBoolElement(instrument_dom,
"norm_background_flag",
default=DataSets.NormBackgroundFlag)
#background from/to pixels
self.NormBackgroundRoi = [BaseScriptElement.getIntElement(instrument_dom, "norm_from_back_pixels"),
BaseScriptElement.getIntElement(instrument_dom, "norm_to_back_pixels")]
self.norm_file = BaseScriptElement.getIntElement(instrument_dom, "norm_dataset")
# Q cut
self.q_min = BaseScriptElement.getFloatElement(instrument_dom, "q_min", default=DataSets.q_min)
self.q_step = BaseScriptElement.getFloatElement(instrument_dom, "q_step", default=DataSets.q_step)
self.auto_q_binning = BaseScriptElement.getBoolElement(instrument_dom, "auto_q_binning", default=False)
# Angle offset
self.angle_offset = BaseScriptElement.getFloatElement(instrument_dom, "angle_offset", default=DataSets.angle_offset)
self.angle_offset_error = BaseScriptElement.getFloatElement(instrument_dom, "angle_offset_error", default=DataSets.angle_offset_error)
#scaling factor file and options
self.scaling_factor_file = BaseScriptElement.getStringElement(instrument_dom, "scaling_factor_file")
self.slits_width_flag = BaseScriptElement.getBoolElement(instrument_dom, "slits_width_flag")
self.scaling_factor_file_flag = BaseScriptElement.getBoolElement(instrument_dom, "scaling_factor_flag")
#incident medium selected
if BaseScriptElement.getStringList(instrument_dom, "incident_medium_list") != []:
self.incident_medium_list = BaseScriptElement.getStringList(instrument_dom, "incident_medium_list")
self.incident_medium_index_selected = BaseScriptElement.getIntElement(instrument_dom, "incident_medium_index_selected")
else:
self.incident_medium_list = ['H2O']
self.incident_medium_index_selected = 0
#fourth column (precision)
self.fourth_column_flag = BaseScriptElement.getBoolElement(instrument_dom, "fourth_column_flag")
self.fourth_column_dq0 = BaseScriptElement.getFloatElement(instrument_dom, "fourth_column_dq0")
self.fourth_column_dq_over_q = BaseScriptElement.getFloatElement(instrument_dom, "fourth_column_dq_over_q")
def get_optFloat(tag, default=None):
return OptionalFloat(BaseScriptElement.getStringElement(dom, tag, default=default))
def get_str(tag, default=''):
return BaseScriptElement.getStringElement(dom, tag, default=default)
def from_xml(self, xml_str):
""" 'Public' method to read in data from XML
@param xml_str: text to read the data from
"""
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("RunSetup")
if len(element_list)>0:
#
instrument_dom = element_list[0]
#
self.runnumbers = BaseScriptElement.getStringElement(instrument_dom,\
"runnumber", default=RunSetupScript.runnumbers)
tempbool = BaseScriptElement.getStringElement(instrument_dom,\
"sum", default=str(int(RunSetupScript.dosum)))
self.dosum = bool(int(tempbool))
self.calibfilename = BaseScriptElement.getStringElement(instrument_dom,\
"calibrationfile", default=RunSetupScript.calibfilename)
self.exp_ini_file_name = BaseScriptElement.getStringElement(instrument_dom,\
'expinifilename', default=RunSetupScript.exp_ini_file_name)
self.charfilename = BaseScriptElement.getStringElement(instrument_dom,\
"characterizationrunsfile", default=RunSetupScript.charfilename)
try:
self.binning = BaseScriptElement.getFloatElement(instrument_dom,\
"binning", default=RunSetupScript.binning)
except ValueError:
self.binning = ''
try:
self.resamplex = BaseScriptElement.getIntElement(instrument_dom,\
"resamplex", default=RunSetupScript.resamplex)
except ValueError:
self.resamplex = 0
self.doresamplex = BaseScriptElement.getIntElement(instrument_dom,\
"doresamplex", default=RunSetupScript.resamplex)
self.doresamplex = bool(self.doresamplex)
tempbool = BaseScriptElement.getStringElement(instrument_dom,\
"binindspace", default=str(int(RunSetupScript.binindspace)))
self.binindspace = bool(int(tempbool))
self.saveas = BaseScriptElement.getStringElement(instrument_dom,\
"saveas", default=RunSetupScript.saveas)
self.outputdir = BaseScriptElement.getStringElement(instrument_dom,\
"outputdirectory", default=RunSetupScript.outputdir)
self.finalunits = BaseScriptElement.getStringElement(instrument_dom,\
"finaldataunits", default=RunSetupScript.finalunits)
self.bkgdrunnumber = BaseScriptElement.getStringElement(instrument_dom,\
"backgroundnumber", default=RunSetupScript.bkgdrunnumber)
tempbool = BaseScriptElement.getStringElement(instrument_dom,\
"disablebackgroundcorrection", default=str(int(RunSetupScript.disablebkgdcorrection)))
self.disablebkgdcorrection = bool(int(tempbool))
self.vanrunnumber = BaseScriptElement.getStringElement(instrument_dom,\
"vanadiumnumber", default=RunSetupScript.vanrunnumber)
tempbool = BaseScriptElement.getStringElement(instrument_dom,\
"disablevanadiumcorrection", default=str(int(RunSetupScript.disablevancorrection)))
self.disablevancorrection = bool(int(tempbool))
self.vanbkgdrunnumber = BaseScriptElement.getStringElement(instrument_dom,\
"vanadiumbackgroundnumber", default=RunSetupScript.vanbkgdrunnumber)
tempbool = BaseScriptElement.getStringElement(instrument_dom,\
"disablevanadiumbackgroundcorrection", default=str(int(RunSetupScript.disablevanbkgdcorrection)))
self.disablevanbkgdcorrection = bool(int(tempbool))
# tempint = BaseScriptElement.getStringElement(instrument_dom,
# try:
# self.vannoiserunnumber = int(tempint)
# except ValueError:
# self.vannoiserunnumber = ""
return
def get_str(tag, default=''):
return BaseScriptElement.getStringElement(dom,
tag,
default=default)
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
self.reset()
dom = xml.dom.minidom.parseString(xml_str)
instrument_dom = dom.getElementsByTagName("Instrument")[0]
self.nx_pixels = BaseScriptElement.getIntElement(
instrument_dom, "nx_pixels", default=ReductionOptions.nx_pixels)
self.ny_pixels = BaseScriptElement.getIntElement(
instrument_dom, "ny_pixels", default=ReductionOptions.ny_pixels)
self.instrument_name = BaseScriptElement.getStringElement(
instrument_dom, "name")
self.pixel_size = BaseScriptElement.getFloatElement(
instrument_dom, "pixel_size", default=ReductionOptions.pixel_size)
self.sample_detector_distance = BaseScriptElement.getFloatElement(
instrument_dom,
"sample_det_dist",
default=ReductionOptions.sample_detector_distance)
self.detector_offset = BaseScriptElement.getFloatElement(
instrument_dom,
"detector_offset",
default=ReductionOptions.detector_offset)
self.wavelength = BaseScriptElement.getFloatElement(
instrument_dom, "wavelength", default=ReductionOptions.wavelength)
self.wavelength_spread = BaseScriptElement.getFloatElement(
instrument_dom,
"wavelength_spread",
default=ReductionOptions.wavelength_spread)
self.solid_angle_corr = BaseScriptElement.getBoolElement(
instrument_dom,
"solid_angle_corr",
default=ReductionOptions.solid_angle_corr)
# Output directory
self.use_data_directory = BaseScriptElement.getBoolElement(
instrument_dom,
"UseDataDirectory",
default=ReductionOptions.use_data_directory)
self.output_directory = BaseScriptElement.getStringElement(
instrument_dom,
"OutputDirectory",
default=ReductionOptions.output_directory)
# Dark current
self.dark_current_corr = BaseScriptElement.getBoolElement(
instrument_dom,
"dark_current_corr",
default=ReductionOptions.dark_current_corr)
self.dark_current_data = BaseScriptElement.getStringElement(
instrument_dom, "dark_current_data")
self.n_q_bins = BaseScriptElement.getIntElement(
instrument_dom, "n_q_bins", default=ReductionOptions.n_q_bins)
self.n_sub_pix = BaseScriptElement.getIntElement(
instrument_dom, "n_sub_pix", default=ReductionOptions.n_sub_pix)
self.log_binning = BaseScriptElement.getBoolElement(
instrument_dom,
"log_binning",
default=ReductionOptions.log_binning)
self.align_log_with_decades = BaseScriptElement.getBoolElement(
instrument_dom,
"align_log_with_decades",
default=ReductionOptions.align_log_with_decades)
self.error_weighting = BaseScriptElement.getBoolElement(
instrument_dom,
"error_weighting",
default=ReductionOptions.error_weighting)
self.n_wedges = BaseScriptElement.getIntElement(
instrument_dom, "n_wedges", default=ReductionOptions.n_wedges)
self.wedge_angle = BaseScriptElement.getFloatElement(
instrument_dom,
"wedge_angle",
default=ReductionOptions.wedge_angle)
self.wedge_offset = BaseScriptElement.getFloatElement(
instrument_dom,
"wedge_offset",
default=ReductionOptions.wedge_offset)
self.normalization = BaseScriptElement.getIntElement(
instrument_dom,
"normalization",
default=ReductionOptions.normalization)
# Mask
element_list = dom.getElementsByTagName("Mask")
if len(element_list) > 0:
mask_dom = element_list[0]
self.top = BaseScriptElement.getIntElement(
mask_dom, "mask_top", default=ReductionOptions.top)
self.bottom = BaseScriptElement.getIntElement(
mask_dom, "mask_bottom", default=ReductionOptions.bottom)
self.right = BaseScriptElement.getIntElement(
mask_dom, "mask_right", default=ReductionOptions.right)
self.left = BaseScriptElement.getIntElement(
mask_dom, "mask_left", default=ReductionOptions.left)
self.masked_side = BaseScriptElement.getStringElement(
mask_dom, "mask_side", default=ReductionOptions.masked_side)
self.shapes = []
shapes_dom_list = mask_dom.getElementsByTagName("Shapes")
if len(shapes_dom_list) > 0:
shapes_dom = shapes_dom_list[0]
for item in shapes_dom.getElementsByTagName("rect"):
x_min = float(item.getAttribute("x_min"))
x_max = float(item.getAttribute("x_max"))
y_min = float(item.getAttribute("y_min"))
y_max = float(item.getAttribute("y_max"))
self.shapes.append(
ReductionOptions.RectangleMask(x_min, x_max, y_min,
y_max))
self.detector_ids = BaseScriptElement.getIntList(mask_dom,
"DetectorIDs",
default=[])
self.mask_file = BaseScriptElement.getStringElement(
mask_dom, "mask_file")
self.use_mask_file = BaseScriptElement.getBoolElement(
mask_dom,
"use_mask_file",
default=ReductionOptions.use_mask_file)
# Absolute scaling
element_list = dom.getElementsByTagName("AbsScale")
if len(element_list) > 0:
scale_dom = element_list[0]
self.manual_beam_diam = BaseScriptElement.getBoolElement(
scale_dom,
"manual_beam_diam",
default=ReductionOptions.manual_beam_diam)
self.scaling_factor = BaseScriptElement.getFloatElement(
scale_dom,
"scaling_factor",
default=ReductionOptions.scaling_factor)
self.calculate_scale = BaseScriptElement.getBoolElement(
scale_dom,
"calculate_scale",
default=ReductionOptions.calculate_scale)
self.scaling_direct_file = BaseScriptElement.getStringElement(
scale_dom, "scaling_direct_file")
self.scaling_att_trans = BaseScriptElement.getFloatElement(
scale_dom,
"scaling_att_trans",
default=ReductionOptions.scaling_att_trans)
self.scaling_beam_diam = BaseScriptElement.getFloatElement(
scale_dom,
"scaling_beam_diam",
default=ReductionOptions.scaling_beam_diam)
def from_xml(self, xml_str):
""" 'Public' method to read in data from XML
@param xml_str: text to read the data from
"""
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("AdvancedSetup")
if len(element_list)>0:
instrument_dom = element_list[0]
self.unwrapref = getFloatElement(instrument_dom, "unwrapref",
AdvancedSetupScript.unwrapref)
self.lowresref = getFloatElement(instrument_dom, "lowresref",
AdvancedSetupScript.lowresref)
self.cropwavelengthmin = getFloatElement(instrument_dom, "cropwavelengthmin",
AdvancedSetupScript.cropwavelengthmin)
self.cropwavelengthmax = getFloatElement(instrument_dom, 'cropwavelengthmax',
AdvancedSetupScript.cropwavelengthmax)
self.removepropmppulsewidth = getFloatElement(instrument_dom, "removepromptpulsewidth",
AdvancedSetupScript.removepropmppulsewidth)
try:
self.maxchunksize = BaseScriptElement.getIntElement(
instrument_dom, 'maxchunksize', default=AdvancedSetupScript.maxchunksize)
except ValueError:
self.maxchunksize = AdvancedSetupScript.maxchunksize
self.filterbadpulses = getFloatElement(instrument_dom,
'filterbadpulses',
AdvancedSetupScript.filterbadpulses)
self.bkgdsmoothpars = BaseScriptElement.getStringElement(instrument_dom,
"backgroundsmoothparams", default=AdvancedSetupScript.bkgdsmoothpars)
self.pushdatapositive = BaseScriptElement.getStringElement(instrument_dom,
"pushdatapositive", default=AdvancedSetupScript.pushdatapositive)
self.stripvanadiumpeaks = getBooleanElement(instrument_dom,
"stripvanadiumpeaks", AdvancedSetupScript.stripvanadiumpeaks)
self.vanadiumfwhm = getFloatElement(instrument_dom, "vanadiumfwhm",
AdvancedSetupScript.vanadiumfwhm)
self.vanadiumpeaktol = getFloatElement(instrument_dom, "vanadiumpeaktol",
AdvancedSetupScript.vanadiumpeaktol)
self.vanadiumsmoothparams = BaseScriptElement.getStringElement(instrument_dom,
"vanadiumsmoothparams",
default=AdvancedSetupScript.vanadiumsmoothparams)
self.extension = BaseScriptElement.getStringElement(instrument_dom,
"extension", default=AdvancedSetupScript.extension)
self.preserveevents = getBooleanElement(instrument_dom, "preserveevents",
default=AdvancedSetupScript.preserveevents)
self.outputfileprefix = BaseScriptElement.getStringElement(instrument_dom,
"outputfileprefix", default = AdvancedSetupScript.outputfileprefix)
self.scaledata = getFloatElement(instrument_dom, "scaledata",
AdvancedSetupScript.scaledata)
return
def from_xml_element(self, instrument_dom):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
# Peak from/to pixels
self.DataPeakPixels = [BaseScriptElement.getIntElement(instrument_dom, "from_peak_pixels"),
BaseScriptElement.getIntElement(instrument_dom, "to_peak_pixels")]
# low resolution range
self.data_x_range_flag = BaseScriptElement.getBoolElement(instrument_dom, "x_range_flag",
default=DataSets.data_x_range_flag)
self.data_x_range = [BaseScriptElement.getIntElement(instrument_dom, "x_min_pixel"),
BaseScriptElement.getIntElement(instrument_dom, "x_max_pixel")]
self.norm_x_range_flag = BaseScriptElement.getBoolElement(instrument_dom, "norm_x_range_flag",
default=DataSets.norm_x_range_flag)
self.norm_x_range = [BaseScriptElement.getIntElement(instrument_dom, "norm_x_min"),
BaseScriptElement.getIntElement(instrument_dom, "norm_x_max")]
# discrete selection string
self.DataPeakDiscreteSelection = BaseScriptElement.getStringElement(instrument_dom, "peak_discrete_selection")
# background flag
self.DataBackgroundFlag = BaseScriptElement.getBoolElement(instrument_dom,
"background_flag",
default=DataSets.DataBackgroundFlag)
# background from/to pixels
self.DataBackgroundRoi = [BaseScriptElement.getIntElement(instrument_dom, "back_roi1_from"),
BaseScriptElement.getIntElement(instrument_dom, "back_roi1_to"),
BaseScriptElement.getIntElement(instrument_dom, "back_roi2_from"),
BaseScriptElement.getIntElement(instrument_dom, "back_roi2_to")]
# from TOF and to TOF
# self.crop_TOF_range = BaseScriptElement.getBoolElement(instrument_dom, "crop_tof",
# default=DataSets.crop_TOF_range)
self.DataTofRange = [BaseScriptElement.getFloatElement(instrument_dom, "from_tof_range"),
BaseScriptElement.getFloatElement(instrument_dom, "to_tof_range")]
self.TOFstep = BaseScriptElement.getFloatElement(instrument_dom, "tof_step",
default=DataSets.TOFstep)
self.data_files = BaseScriptElement.getStringList(instrument_dom, "data_sets")
# with or without norm
self.NormFlag = BaseScriptElement.getBoolElement(instrument_dom, "norm_flag",
default=DataSets.NormFlag)
# Peak from/to pixels
self.NormPeakPixels = [BaseScriptElement.getIntElement(instrument_dom, "norm_from_peak_pixels"),
BaseScriptElement.getIntElement(instrument_dom, "norm_to_peak_pixels")]
# background flag
self.NormBackgroundFlag = BaseScriptElement.getBoolElement(instrument_dom,
"norm_background_flag",
default=DataSets.NormBackgroundFlag)
# background from/to pixels
self.NormBackgroundRoi = [BaseScriptElement.getIntElement(instrument_dom, "norm_from_back_pixels"),
BaseScriptElement.getIntElement(instrument_dom, "norm_to_back_pixels")]
self.norm_file = BaseScriptElement.getStringElement(instrument_dom, "norm_dataset")
# Q cut
self.q_min = BaseScriptElement.getFloatElement(instrument_dom, "q_min", default=DataSets.q_min)
self.q_step = BaseScriptElement.getFloatElement(instrument_dom, "q_step", default=DataSets.q_step)
self.q_bins = BaseScriptElement.getIntElement(instrument_dom, "q_bins", default=DataSets.q_bins)
self.q_log = BaseScriptElement.getBoolElement(instrument_dom, "q_log", default=DataSets.q_log)
# scattering angle
self.theta = BaseScriptElement.getFloatElement(instrument_dom, "theta", default=DataSets.theta)
# self.use_center_pixel = BaseScriptElement.getBoolElement(instrument_dom,
# "use_center_pixel",
# default=DataSets.use_center_pixel)
# Sample log overwrites
self.set_detector_angle = BaseScriptElement.getBoolElement(instrument_dom,
"set_detector_angle",
default=DataSets.set_detector_angle)
self.detector_angle = BaseScriptElement.getFloatElement(instrument_dom,
"detector_angle",
default=DataSets.detector_angle)
self.set_detector_angle_offset = BaseScriptElement.getBoolElement(instrument_dom,
"set_detector_angle_offset",
default=DataSets.set_detector_angle_offset)
self.detector_angle_offset = BaseScriptElement.getFloatElement(instrument_dom,
"detector_angle_offset",
default=DataSets.detector_angle_offset)
self.set_direct_pixel = BaseScriptElement.getBoolElement(instrument_dom,
"set_direct_pixel",
default=DataSets.set_direct_pixel)
self.direct_pixel = BaseScriptElement.getFloatElement(instrument_dom,
"direct_pixel",
default=DataSets.direct_pixel)
self.output_dir = BaseScriptElement.getStringElement(instrument_dom,
"output_dir",
default=DataSets.output_dir)
def from_xml_element(self, instrument_dom):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
#Peak selection
self.DataPeakSelectionType = BaseScriptElement.getStringElement(
instrument_dom, "peak_selection_type")
#Peak from/to pixels
self.DataPeakPixels = [
BaseScriptElement.getIntElement(instrument_dom,
"from_peak_pixels"),
BaseScriptElement.getIntElement(instrument_dom, "to_peak_pixels")
]
#data metadata
_tthd_value = BaseScriptElement.getStringElement(
instrument_dom, "tthd_value")
if _tthd_value == '':
_tthd_value = 'N/A'
self.tthd_value = _tthd_value
_ths_value = BaseScriptElement.getStringElement(
instrument_dom, "ths_value")
if _ths_value == '':
_ths_value = 'N/A'
self.ths_value = _ths_value
#low resolution range
self.data_x_range_flag = BaseScriptElement.getBoolElement(
instrument_dom, "x_range_flag", default=DataSets.data_x_range_flag)
self.data_x_range = [
BaseScriptElement.getIntElement(instrument_dom, "x_min_pixel"),
BaseScriptElement.getIntElement(instrument_dom, "x_max_pixel")
]
self.norm_x_range_flag = BaseScriptElement.getBoolElement(
instrument_dom,
"norm_x_range_flag",
default=DataSets.norm_x_range_flag)
self.norm_x_range = [
BaseScriptElement.getIntElement(instrument_dom, "norm_x_min"),
BaseScriptElement.getIntElement(instrument_dom, "norm_x_max")
]
#discrete selection string
self.DataPeakDiscreteSelection = BaseScriptElement.getStringElement(
instrument_dom, "peak_discrete_selection")
#background flag
self.DataBackgroundFlag = BaseScriptElement.getBoolElement(
instrument_dom,
"background_flag",
default=DataSets.DataBackgroundFlag)
#background from/to pixels
self.DataBackgroundRoi = [
BaseScriptElement.getIntElement(instrument_dom, "back_roi1_from"),
BaseScriptElement.getIntElement(instrument_dom, "back_roi1_to"),
BaseScriptElement.getIntElement(instrument_dom, "back_roi2_from"),
BaseScriptElement.getIntElement(instrument_dom, "back_roi2_to")
]
#from TOF and to TOF
self.TofRangeFlag = BaseScriptElement.getBoolElement(
instrument_dom, "tof_range_flag", default=DataSets.TofRangeFlag)
self.DataTofRange = [
BaseScriptElement.getFloatElement(instrument_dom,
"from_tof_range"),
BaseScriptElement.getFloatElement(instrument_dom, "to_tof_range")
]
self.data_files = BaseScriptElement.getIntList(instrument_dom,
"data_sets")
#with or without norm
self.NormFlag = BaseScriptElement.getBoolElement(
instrument_dom, "norm_flag", default=DataSets.NormFlag)
#Peak from/to pixels
self.NormPeakPixels = [
BaseScriptElement.getIntElement(instrument_dom,
"norm_from_peak_pixels"),
BaseScriptElement.getIntElement(instrument_dom,
"norm_to_peak_pixels")
]
#background flag
self.NormBackgroundFlag = BaseScriptElement.getBoolElement(
instrument_dom,
"norm_background_flag",
default=DataSets.NormBackgroundFlag)
#background from/to pixels
self.NormBackgroundRoi = [
BaseScriptElement.getIntElement(instrument_dom,
"norm_from_back_pixels"),
BaseScriptElement.getIntElement(instrument_dom,
"norm_to_back_pixels")
]
self.norm_file = BaseScriptElement.getIntElement(
instrument_dom, "norm_dataset")
# Q cut
self.q_min = BaseScriptElement.getFloatElement(instrument_dom,
"q_min",
default=DataSets.q_min)
self.q_step = BaseScriptElement.getFloatElement(
instrument_dom, "q_step", default=DataSets.q_step)
self.auto_q_binning = BaseScriptElement.getBoolElement(
instrument_dom, "auto_q_binning", default=False)
# overlap_lowest_error
self.overlap_lowest_error = BaseScriptElement.getBoolElement(
instrument_dom, "overlap_lowest_error", default=True)
self.overlap_mean_value = BaseScriptElement.getBoolElement(
instrument_dom, "overlap_mean_value", default=False)
# Angle offset
self.angle_offset = BaseScriptElement.getFloatElement(
instrument_dom, "angle_offset", default=DataSets.angle_offset)
self.angle_offset_error = BaseScriptElement.getFloatElement(
instrument_dom,
"angle_offset_error",
default=DataSets.angle_offset_error)
#scaling factor file and options
self.scaling_factor_file = BaseScriptElement.getStringElement(
instrument_dom, "scaling_factor_file")
self.slits_width_flag = BaseScriptElement.getBoolElement(
instrument_dom, "slits_width_flag")
self.scaling_factor_file_flag = BaseScriptElement.getBoolElement(
instrument_dom, "scaling_factor_flag")
# geometry correction switch
self.geometry_correction_switch = BaseScriptElement.getBoolElement(
instrument_dom, "geometry_correction_switch")
#incident medium selected
if BaseScriptElement.getStringList(instrument_dom,
"incident_medium_list") != []:
self.incident_medium_list = BaseScriptElement.getStringList(
instrument_dom, "incident_medium_list")
self.incident_medium_index_selected = BaseScriptElement.getIntElement(
instrument_dom, "incident_medium_index_selected")
else:
self.incident_medium_list = ['H2O']
self.incident_medium_index_selected = 0
#fourth column (precision)
self.fourth_column_flag = BaseScriptElement.getBoolElement(
instrument_dom, "fourth_column_flag")
self.fourth_column_dq0 = BaseScriptElement.getFloatElement(
instrument_dom, "fourth_column_dq0")
self.fourth_column_dq_over_q = BaseScriptElement.getFloatElement(
instrument_dom, "fourth_column_dq_over_q")
# Primary fraction
self.clocking_from = BaseScriptElement.getIntElement(instrument_dom,
"clocking_from",
default=None)
self.clocking_to = BaseScriptElement.getIntElement(instrument_dom,
"clocking_to",
default=None)
def from_xml(self, xml_str):
""" 'Public' method to read in data from XML
@param xml_str: text to read the data from
"""
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("RunSetup")
if len(element_list) > 0:
#
instrument_dom = element_list[0]
#
self.runnumbers = BaseScriptElement.getStringElement(
instrument_dom, "runnumber", default=RunSetupScript.runnumbers)
tempbool = BaseScriptElement.getStringElement(
instrument_dom, "sum", default=str(int(RunSetupScript.dosum)))
self.dosum = bool(int(tempbool))
self.calibfilename = BaseScriptElement.getStringElement(
instrument_dom,
'calibrationfile',
default=RunSetupScript.calibfilename)
self.groupfilename = BaseScriptElement.getStringElement(
instrument_dom,
'groupingfile',
default=RunSetupScript.groupfilename)
self.exp_ini_file_name = BaseScriptElement.getStringElement(
instrument_dom,
'expinifilename',
default=RunSetupScript.exp_ini_file_name)
self.charfilename = BaseScriptElement.getStringElement(
instrument_dom,
'characterizationrunsfile',
default=RunSetupScript.charfilename)
try:
self.binning = BaseScriptElement.getFloatElement(
instrument_dom, 'binning', default=RunSetupScript.binning)
except ValueError:
self.binning = ''
try:
self.resamplex = BaseScriptElement.getIntElement(
instrument_dom,
'resamplex',
default=RunSetupScript.resamplex)
except ValueError:
self.resamplex = 0
self.doresamplex = BaseScriptElement.getIntElement(
instrument_dom,
"doresamplex",
default=RunSetupScript.resamplex)
self.doresamplex = bool(self.doresamplex)
tempbool = BaseScriptElement.getStringElement(
instrument_dom,
"binindspace",
default=str(int(RunSetupScript.binindspace)))
self.binindspace = bool(int(tempbool))
self.saveas = BaseScriptElement.getStringElement(
instrument_dom, "saveas", default=RunSetupScript.saveas)
self.outputdir = BaseScriptElement.getStringElement(
instrument_dom,
"outputdirectory",
default=RunSetupScript.outputdir)
self.finalunits = BaseScriptElement.getStringElement(
instrument_dom,
"finaldataunits",
default=RunSetupScript.finalunits)
self.bkgdrunnumber = BaseScriptElement.getStringElement(
instrument_dom,
"backgroundnumber",
default=RunSetupScript.bkgdrunnumber)
tempbool = BaseScriptElement.getStringElement(
instrument_dom,
"disablebackgroundcorrection",
default=str(int(RunSetupScript.disablebkgdcorrection)))
self.disablebkgdcorrection = bool(int(tempbool))
self.vanrunnumber = BaseScriptElement.getStringElement(
instrument_dom,
"vanadiumnumber",
default=RunSetupScript.vanrunnumber)
tempbool = BaseScriptElement.getStringElement(
instrument_dom,
"disablevanadiumcorrection",
default=str(int(RunSetupScript.disablevancorrection)))
self.disablevancorrection = bool(int(tempbool))
self.vanbkgdrunnumber = BaseScriptElement.getStringElement(
instrument_dom,
"vanadiumbackgroundnumber",
default=RunSetupScript.vanbkgdrunnumber)
tempbool = BaseScriptElement.getStringElement(
instrument_dom,
"disablevanadiumbackgroundcorrection",
default=str(int(RunSetupScript.disablevanbkgdcorrection)))
self.disablevanbkgdcorrection = bool(int(tempbool))
# tempint = BaseScriptElement.getStringElement(instrument_dom,
# try:
# self.vannoiserunnumber = int(tempint)
# except ValueError:
# self.vannoiserunnumber = ""
return
def from_xml(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("DiagnoseDetectors")
if len(element_list) > 0:
instrument_dom = element_list[0]
self.high_counts = BaseScriptElement.getFloatElement(
instrument_dom,
"high_counts",
default=DiagnoseDetectorsScript.high_counts)
self.low_counts = BaseScriptElement.getFloatElement(
instrument_dom,
"low_counts",
default=DiagnoseDetectorsScript.low_counts)
self.median_test_out_low = BaseScriptElement.getFloatElement(
instrument_dom,
"median_test_out_low",
default=DiagnoseDetectorsScript.median_test_out_low)
self.median_test_out_high = BaseScriptElement.getFloatElement(
instrument_dom,
"median_test_out_high",
default=DiagnoseDetectorsScript.median_test_out_high)
self.median_test_low = BaseScriptElement.getFloatElement(
instrument_dom,
"median_test_low",
default=DiagnoseDetectorsScript.median_test_low)
self.median_test_high = BaseScriptElement.getFloatElement(
instrument_dom,
"median_test_high",
default=DiagnoseDetectorsScript.median_test_high)
self.errorbar_criterion = BaseScriptElement.getFloatElement(
instrument_dom,
"errorbar_criterion",
default=DiagnoseDetectorsScript.errorbar_criterion)
self.det_van2 = BaseScriptElement.getStringElement(
instrument_dom,
"det_van2",
default=DiagnoseDetectorsScript.det_van2)
self.detvan_ratio_var = BaseScriptElement.getFloatElement(
instrument_dom,
"detvan_ratio_var",
default=DiagnoseDetectorsScript.detvan_ratio_var)
self.background_check = BaseScriptElement.getBoolElement(
instrument_dom,
"background_check",
default=DiagnoseDetectorsScript.background_check)
self.sambkg_median_test_low = BaseScriptElement.getFloatElement(
instrument_dom,
"sambkg_median_test_low",
default=DiagnoseDetectorsScript.sambkg_median_test_low)
self.sambkg_median_test_high = BaseScriptElement.getFloatElement(
instrument_dom,
"sambkg_median_test_high",
default=DiagnoseDetectorsScript.sambkg_median_test_high)
self.sambkg_errorbar_criterion = BaseScriptElement.getFloatElement(
instrument_dom,
"sambkg_errorbar_criterion",
default=DiagnoseDetectorsScript.sambkg_errorbar_criterion)
self.tof_start = BaseScriptElement.getIntElement(
instrument_dom,
"background_tof_start",
default=DiagnoseDetectorsScript.tof_start)
self.tof_end = BaseScriptElement.getIntElement(
instrument_dom,
"background_tof_end",
default=DiagnoseDetectorsScript.tof_end)
self.reject_zero_bkg = BaseScriptElement.getBoolElement(
instrument_dom,
"reject_zero_bkg",
default=DiagnoseDetectorsScript.reject_zero_bkg)
self.psd_bleed = BaseScriptElement.getBoolElement(
instrument_dom,
"psd_bleed",
default=DiagnoseDetectorsScript.psd_bleed)
self.max_framerate = BaseScriptElement.getStringElement(
instrument_dom,
"max_framerate",
default=DiagnoseDetectorsScript.max_framerate)
self.ignored_pixels = BaseScriptElement.getStringElement(
instrument_dom,
"ignored_pixels",
default=DiagnoseDetectorsScript.ignored_pixels)
def get_optFloat(tag, default=None):
return OptionalFloat(
BaseScriptElement.getStringElement(dom,
tag,
default=default))
def from_setup_info(self, xml_str):
"""
Read in data from XML using the string representation of the setup algorithm used
to prepare the reduction properties.
@param xml_str: text to read the data from
"""
self.reset()
from mantid.api import Algorithm
dom = xml.dom.minidom.parseString(xml_str)
process_dom = dom.getElementsByTagName("SASProcess")[0]
setup_alg_str = BaseScriptElement.getStringElement(
process_dom, 'SetupInfo')
alg = Algorithm.fromString(str(setup_alg_str))
self.sample_detector_distance = BaseScriptElement.getPropertyValue(
alg,
"SampleDetectorDistance",
default=ReductionOptions.sample_detector_distance)
self.detector_offset = BaseScriptElement.getPropertyValue(
alg,
"SampleDetectorDistanceOffset",
default=ReductionOptions.detector_offset)
self.wavelength = BaseScriptElement.getPropertyValue(
alg, "Wavelength", default=ReductionOptions.wavelength)
self.wavelength_spread = BaseScriptElement.getPropertyValue(
alg,
"WavelengthSpread",
default=ReductionOptions.wavelength_spread)
self.solid_angle_corr = BaseScriptElement.getPropertyValue(
alg,
"SolidAngleCorrection",
default=ReductionOptions.solid_angle_corr)
self.output_directory = BaseScriptElement.getPropertyValue(
alg, "OutputDirectory", default=ReductionOptions.output_directory)
self.use_data_directory = not len(self.output_directory) > 0
# Dark current
self.dark_current_data = BaseScriptElement.getPropertyValue(
alg, "DarkCurrentFile", default='')
self.dark_current_corr = len(self.dark_current_data) > 0
self.n_q_bins = BaseScriptElement.getPropertyValue(
alg, "IQNumberOfBins", default=ReductionOptions.n_q_bins)
self.n_sub_pix = BaseScriptElement.getPropertyValue(
alg, "NumberOfSubpixels", default=ReductionOptions.n_sub_pix)
self.log_binning = BaseScriptElement.getPropertyValue(
alg, "IQLogBinning", default=ReductionOptions.log_binning)
self.align_log_with_decades = BaseScriptElement.getPropertyValue(
alg,
"IQAlignLogWithDecades",
default=ReductionOptions.align_log_with_decades)
self.error_weighting = BaseScriptElement.getPropertyValue(
alg, "ErrorWeighting", default=ReductionOptions.error_weighting)
self.n_wedges = BaseScriptElement.getPropertyValue(
alg, "NumberOfWedges", default=ReductionOptions.n_wedges)
self.wedge_angle = BaseScriptElement.getPropertyValue(
alg, "WedgeAngle", default=ReductionOptions.wedge_angle)
self.wedge_offset = BaseScriptElement.getPropertyValue(
alg, "WedgeOffset", default=ReductionOptions.wedge_offset)
# Normalization
norm_option = BaseScriptElement.getPropertyValue(alg,
"Normalisation",
default='Monitor')
self.normalization = ReductionOptions.normalization
if norm_option == 'Timer':
self.normalization = ReductionOptions.NORMALIZATION_TIME
elif norm_option == 'Monitor' or norm_option == 'BeamProfileAndCharge':
self.normalization = ReductionOptions.NORMALIZATION_MONITOR
elif norm_option == 'None':
self.normalization = ReductionOptions.NORMALIZATION_NONE
# Mask
mask = BaseScriptElement.getPropertyValue(alg,
"MaskedEdges",
default=[])
if type(mask).__name__ == 'ndarray':
mask = mask.tolist()
if len(mask) == 4:
self.top = mask[3]
self.bottom = mask[2]
self.right = mask[1]
self.left = mask[0]
self.detector_ids = BaseScriptElement.getPropertyValue(
alg, "MaskedDetectorList", default=[])
if type(self.detector_ids).__name__ == 'ndarray':
self.detector_ids = self.detector_ids.tolist()
self.use_mask_file = len(self.detector_ids) > 0
# Absolute scaling
scale_option = BaseScriptElement.getPropertyValue(
alg, "AbsoluteScaleMethod", default='None')
self.calculate_scale = False
self.scaling_factor = 1.0
if scale_option == 'Value':
self.scaling_factor = BaseScriptElement.getPropertyValue(
alg,
"AbsoluteScalingFactor",
default=ReductionOptions.scaling_factor)
elif scale_option == 'ReferenceData':
self.calculate_scale = True
self.scaling_direct_file = BaseScriptElement.getPropertyValue(
alg, "AbsoluteScalingReferenceFilename")
self.scaling_att_trans = BaseScriptElement.getPropertyValue(
alg,
"AbsoluteScalingAttenuatorTrans",
default=ReductionOptions.scaling_att_trans)
self.manual_beam_diam = False
if alg.existsProperty("AbsoluteScalingBeamDiameter"):
if not alg.getProperty(
"AbsoluteScalingBeamDiameter").isDefault:
self.scaling_beam_diam = BaseScriptElement.getPropertyValue(
alg,
"AbsoluteScalingBeamDiameter",
default=ReductionOptions.scaling_beam_diam)
self.manual_beam_diam = True
def from_xml(self, xml_str):
""" 'Public' method to read in data from XML
@param xml_str: text to read the data from
"""
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("AdvancedSetup")
if len(element_list) > 0:
instrument_dom = element_list[0]
self.unwrapref = getFloatElement(instrument_dom, "unwrapref",
AdvancedSetupScript.unwrapref)
self.lowresref = getFloatElement(instrument_dom, "lowresref",
AdvancedSetupScript.lowresref)
self.cropwavelengthmin = getFloatElement(instrument_dom, "cropwavelengthmin",
AdvancedSetupScript.cropwavelengthmin)
self.cropwavelengthmax = getFloatElement(instrument_dom, 'cropwavelengthmax',
AdvancedSetupScript.cropwavelengthmax)
self.removepropmppulsewidth = getFloatElement(instrument_dom, "removepromptpulsewidth",
AdvancedSetupScript.removepropmppulsewidth)
try:
self.maxchunksize = BaseScriptElement.getIntElement(
instrument_dom, 'maxchunksize', default=AdvancedSetupScript.maxchunksize)
except ValueError:
self.maxchunksize = AdvancedSetupScript.maxchunksize
self.filterbadpulses = getFloatElement(instrument_dom,
'filterbadpulses',
AdvancedSetupScript.filterbadpulses)
self.bkgdsmoothpars = BaseScriptElement.getStringElement(instrument_dom,
"backgroundsmoothparams", default=AdvancedSetupScript.bkgdsmoothpars)
self.pushdatapositive = BaseScriptElement.getStringElement(instrument_dom,
"pushdatapositive", default=AdvancedSetupScript.pushdatapositive)
self.stripvanadiumpeaks = getBooleanElement(instrument_dom,
"stripvanadiumpeaks", AdvancedSetupScript.stripvanadiumpeaks)
self.vanadiumfwhm = getFloatElement(instrument_dom, "vanadiumfwhm",
AdvancedSetupScript.vanadiumfwhm)
self.vanadiumpeaktol = getFloatElement(instrument_dom, "vanadiumpeaktol",
AdvancedSetupScript.vanadiumpeaktol)
self.vanadiumsmoothparams = BaseScriptElement.getStringElement(instrument_dom,
"vanadiumsmoothparams",
default=AdvancedSetupScript.vanadiumsmoothparams)
self.vanadiumradius = getFloatElement(instrument_dom, "vanadiumradius",
AdvancedSetupScript.vanadiumradius)
self.extension = BaseScriptElement.getStringElement(instrument_dom,
"extension", default=AdvancedSetupScript.extension)
self.preserveevents = getBooleanElement(instrument_dom, "preserveevents",
default=AdvancedSetupScript.preserveevents)
self.outputfileprefix = BaseScriptElement.getStringElement(instrument_dom,
"outputfileprefix", default = AdvancedSetupScript.outputfileprefix)
self.scaledata = getFloatElement(instrument_dom, "scaledata",
AdvancedSetupScript.scaledata)
self.sampleformula = BaseScriptElement.getStringElement(instrument_dom, "sampleformula",
default=AdvancedSetupScript.sampleformula)
self.samplenumberdensity = getFloatElement(instrument_dom, "samplenumberdensity",
AdvancedSetupScript.samplenumberdensity)
self.measuredmassdensity = getFloatElement(instrument_dom, "measuredmassdensity",
AdvancedSetupScript.measuredmassdensity)
string_tmp = BaseScriptElement.getStringElement(instrument_dom, "samplegeometry",
default=AdvancedSetupScript.samplegeometry)
self.samplegeometry = {}
if string_tmp:
items = string_tmp.replace("{", "").replace("}", "").split(",")
keys_tmp = [item.split(":")[0].replace("'", "") for item in items]
vals_tmp = [item.split(":")[1].replace("'", "").strip() for item in items]
if vals_tmp.count("") == 0:
vals_tmp = [float(item) for item in vals_tmp]
for count, value in enumerate(keys_tmp):
self.samplegeometry[value] = vals_tmp[count]
self.containershape = BaseScriptElement.getStringElement(instrument_dom, "containershape",
default=AdvancedSetupScript.containershape)
self.typeofcorrection = BaseScriptElement.getStringElement(instrument_dom, "typeofcorrection",
default=AdvancedSetupScript.typeofcorrection)
# Caching options
# split it into the three cache dirs
# NOTE: there should only be three entries, if not, let it fail early
try:
self.cache_dir_scan_save, self.cache_dir_scan_1, self.cache_dir_scan_2 = BaseScriptElement.getStringElement(
instrument_dom, 'cachedir', default=";;").replace(";", ",").split(",")
except ValueError:
self.cache_dir_scan_save = ''
self.cache_dir_scan_1 = ''
self.cache_dir_scan_2 = ''
tempbool = BaseScriptElement.getStringElement(instrument_dom,
"cleancache",
default=str(
int(self.__class__.clean_cache)))
self.clean_cache = bool(int(tempbool))
