Python BaseScriptElement.getIntElement方法代码示例

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

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

#.........这里部分代码省略.........

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getIntElement [as 别名]
 def get_int(tag, default):
     return BaseScriptElement.getIntElement(dom, tag, default=default)

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

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

        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
#.........这里部分代码省略.........

# 需要导入模块: from reduction_gui.reduction.scripter import BaseScriptElement [as 别名]
# 或者: from reduction_gui.reduction.scripter.BaseScriptElement import getIntElement [as 别名]
    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
#.........这里部分代码省略.........

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