Python BaseScriptElement.getStringElement方法代码示例

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getStringElement [as 别名]
 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)

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getStringElement [as 别名]
    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', '')]

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getStringElement [as 别名]
    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) 

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getStringElement [as 别名]
 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)

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getStringElement [as 别名]
 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)

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getStringElement [as 别名]
 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)

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getStringElement [as 别名]
    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)

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getStringElement [as 别名]
    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

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getStringElement [as 别名]
    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

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getStringElement [as 别名]
 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)

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getStringElement [as 别名]
    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)

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getStringElement [as 别名]
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))

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getStringElement [as 别名]
    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

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getStringElement [as 别名]
    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)

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getStringElement [as 别名]
    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)