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):
""" '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()
super(ReductionOptions, self).from_xml(xml_str)
dom = xml.dom.minidom.parseString(xml_str)
# 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(Background, self).from_setup_info(xml_str)
(alg, _) = BaseScriptElement.getAlgorithmFromXML(xml_str)
self.combine_transmission_frames = BaseScriptElement.getPropertyValue(alg, "BckFitFramesTogether",
default=SampleData.combine_transmission_frames)
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_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()
(alg, _) = BaseScriptElement.getAlgorithmFromXML(xml_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))
# 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 to_xml(self):
"""
Create XML from the current data.
"""
xml_str = super(Background, self).to_xml()
return BaseScriptElement.addElementToSection(xml_str, "Background", "combine_transmission_frames",
str(self.combine_transmission_frames))
def to_xml(self):
"""
Create XML from the current data.
"""
xml_str = super(SampleData, self).to_xml()
return BaseScriptElement.addElementToSection(xml_str, "Transmission", "combine_transmission_frames",
str(self.combine_transmission_frames))
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()
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_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()
alg, filename = BaseScriptElement.getAlgorithmFromXML(xml_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 = [filename]
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()
(alg, _) = BaseScriptElement.getAlgorithmFromXML(xml_str)
self.background_file = BaseScriptElement.getPropertyValue(alg, "BackgroundFiles", default='')
self.background_corr = len(self.background_file)>0
self.bck_transmission_enabled = True
trans_method = BaseScriptElement.getPropertyValue(alg, "BckTransmissionMethod", default='Value')
# Transmission
self.bck_transmission = BaseScriptElement.getPropertyValue(alg, "BckTransmissionValue", default=SampleData.transmission)
self.bck_transmission_spread = BaseScriptElement.getPropertyValue(alg, "BckTransmissionError",
default=SampleData.transmission_spread)
self.trans_dark_current = BaseScriptElement.getPropertyValue(alg, "BckTransmissionDarkCurrentFile", default='')
self.theta_dependent = BaseScriptElement.getPropertyValue(alg, "BckThetaDependentTransmission",
default = SampleData.theta_dependent)
self.calculate_transmission = trans_method in ['DirectBeam', 'BeamSpreader']
if trans_method=='DirectBeam':
self.trans_calculation_method = Background.DirectBeam()
self.trans_calculation_method.from_setup_info(xml_str)
elif trans_method=='BeamSpreader':
self.trans_calculation_method = Background.BeamSpreader()
self.trans_calculation_method.from_setup_info(xml_str)
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)
# 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)
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()
alg, filename = BaseScriptElement.getAlgorithmFromXML(xml_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 = [filename]
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()
(alg, _) = BaseScriptElement.getAlgorithmFromXML(xml_str)
self.sample_scatt = BaseScriptElement.getPropertyValue(
alg, "TransSampleScatteringFilename", default='')
self.sample_spreader = BaseScriptElement.getPropertyValue(
alg, "TransSampleSpreaderFilename", default='')
self.direct_scatt = BaseScriptElement.getPropertyValue(
alg, "TransDirectScatteringFilename", default='')
self.direct_spreader = BaseScriptElement.getPropertyValue(
alg, "TransDirectSpreaderFilename", default='')
self.spreader_trans = BaseScriptElement.getPropertyValue(
alg,
"SpreaderTransmissionValue",
default=SampleData.BeamSpreader.spreader_trans)
self.spreader_trans_spread = BaseScriptElement.getPropertyValue(
alg,
"SpreaderTransmissionError",
default=SampleData.BeamSpreader.spreader_trans_spread)
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_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 getFloatElement(instrument_dom, keyname, default):
"""Get a float from the xml document. Conversion errors
return the default value.
"""
try:
return BaseScriptElement.getFloatElement(instrument_dom,\
keyname, default=default)
except ValueError:
return default
def getFloatElement(instrument_dom, keyname, default):
"""Get a float from the xml document. Conversion errors
return the default value.
"""
try:
return BaseScriptElement.getFloatElement(instrument_dom,
keyname, default=default)
except ValueError:
return 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_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()
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
"""
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
"""
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)
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(self, xml_str):
"""
Read in data from XML
@param xml_str: text to read the data from
"""
self.reset()
super(Background, self).from_xml(xml_str)
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("Background")
if len(element_list)>0:
instrument_dom = element_list[0]
self.combine_transmission_frames = BaseScriptElement.getBoolElement(instrument_dom, "combine_transmission_frames",
default = Background.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()
super(SampleData, self).from_xml(xml_str)
dom = xml.dom.minidom.parseString(xml_str)
element_list = dom.getElementsByTagName("Transmission")
if len(element_list)>0:
instrument_dom = element_list[0]
self.combine_transmission_frames = BaseScriptElement.getBoolElement(instrument_dom, "combine_transmission_frames",
default = SampleData.combine_transmission_frames)
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 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 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 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
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_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()
(alg, _) = BaseScriptElement.getAlgorithmFromXML(xml_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, 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_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
"""
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_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()
(alg, _) = BaseScriptElement.getAlgorithmFromXML(xml_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)
# 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_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_bol(tag, default):
return BaseScriptElement.getBoolElement(dom, tag, default=default)
def get_int(tag, default):
return BaseScriptElement.getIntElement(dom,
tag,
default=default)
def get_optFloat(tag, default=None):
return OptionalFloat(BaseScriptElement.getStringElement(dom, tag, default=default))
def get_int(tag, default):
return BaseScriptElement.getIntElement(dom, tag, default=default)
def get_bol(tag, default):
return BaseScriptElement.getBoolElement(dom,
tag,
default=default)
def get_strlst(tag):
return BaseScriptElement.getStringList(dom, tag)
def get_flt(tag, default):
return BaseScriptElement.getFloatElement(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()
(alg, _) = BaseScriptElement.getAlgorithmFromXML(xml_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 get_strlst(tag):
return BaseScriptElement.getStringList(dom, tag)
def get_flt(tag, default):
return BaseScriptElement.getFloatElement(dom, tag, default=default)
def get_str(tag, default=''):
return BaseScriptElement.getStringElement(dom,
tag,
default=default)
