Example #1
0
    def __init__(self, params = None):
      super(XDSInitWrapper, self).__init__()

      # phil parameters

      if not params:
        from xia2.Handlers.Phil import master_phil
        params = master_phil.extract().xds.init
      self._params = params

      # now set myself up...

      self.set_executable('xds')

      # generic bits

      self._data_range = (0, 0)
      self._spot_range = []
      self._background_range = (0, 0)
      self._resolution_range = (0, 0)

      self._input_data_files = { }
      self._output_data_files = { }

      self._input_data_files_list = ['X-CORRECTIONS.cbf',
                                     'Y-CORRECTIONS.cbf']

      self._output_data_files_list = ['BKGINIT.cbf',
                                      'BLANK.cbf',
                                      'GAIN.cbf']

      return
Example #2
0
    def __init__(self, params=None):
      super(XDSIntegrateWrapper, self).__init__()

      # phil parameters

      if not params:
        from xia2.Handlers.Phil import master_phil
        params = master_phil.extract().xds.integrate
      self._params = params

      # now set myself up...

      self._parallel = PhilIndex.params.xia2.settings.multiprocessing.nproc
      self.set_cpu_threads(self._parallel)

      if self._parallel <= 1:
        self.set_executable('xds')
      else:
        self.set_executable('xds_par')

      # generic bits

      self._data_range = (0, 0)

      self._input_data_files = { }
      self._output_data_files = { }

      self._input_data_files_list = ['X-CORRECTIONS.cbf',
                                     'Y-CORRECTIONS.cbf',
                                     'BLANK.cbf',
                                     'BKGPIX.cbf',
                                     'GAIN.cbf',
                                     'XPARM.XDS']

      self._output_data_files_list = ['FRAME.cbf']

      self._refined_xparm = False

      self._updates = { }

      # note well - INTEGRATE.HKL is not included in this list
      # because it is likely to be very large - this is treated
      # separately...

      self._integrate_hkl = None

      # FIXME these will also be wanted by the full integrater
      # interface I guess?

      self._mean_mosaic = None
      self._min_mosaic = None
      self._max_mosaic = None

      return
Example #3
0
    def __init__(self, params=None):
      super(XDSColspotWrapper, self).__init__()

      # phil parameters

      if not params:
        from xia2.Handlers.Phil import master_phil
        params = master_phil.extract().xds.colspot
      self._params = params

      # now set myself up...

      self._parallel = Flags.get_parallel()
      self.set_cpu_threads(self._parallel)

      if self._parallel <= 1:
        self.set_executable('xds')
      else:
        self.set_executable('xds_par')

      # generic bits

      self._data_range = (0, 0)
      self._spot_range = []
      self._background_range = (0, 0)
      self._resolution_range = (0, 0)

      self._input_data_files = { }
      self._output_data_files = { }

      self._input_data_files_list = ['X-CORRECTIONS.cbf',
                                     'Y-CORRECTIONS.cbf',
                                     'BLANK.cbf',
                                     'BKGINIT.cbf',
                                     'GAIN.cbf']

      self._output_data_files_list = ['SPOT.XDS']

      return
Example #4
0
    def __init__(self, params=None):

      super(Merge2cbfWrapper, self).__init__()

      # phil parameters

      if not params:
        from xia2.Handlers.Phil import master_phil
        params = master_phil.extract().xds.merge2cbf
      self._params = params

      # now set myself up...

      # I don't think there is a parallel version
      self.set_executable('merge2cbf')

      self._input_data_files = { }
      self._output_data_files = { }

      self._input_data_files_list = []
      self._output_data_files_list = []

      return
Example #5
0
    def __init__(self, params=None):
      super(XDSIdxrefWrapper, self).__init__()

      # phil parameters

      if not params:
        from xia2.Handlers.Phil import master_phil
        params = master_phil.extract().xds.index
      self._params = params

      # now set myself up...

      self._parallel = PhilIndex.params.xia2.settings.multiprocessing.nproc
      self.set_cpu_threads(self._parallel)

      if self._parallel <= 1:
        self.set_executable('xds')
      else:
        self.set_executable('xds_par')

      # generic bits

      self._data_range = (0, 0)
      self._spot_range = []
      self._background_range = (0, 0)
      self._resolution_range = (0, 0)

      self._org = [0.0, 0.0]

      self._refined_origin = None
      self._refined_beam_vector = None
      self._refined_rotation_axis = None

      self._starting_angle = 0.0
      self._starting_frame = 0

      self._cell = None
      self._symm = 0

      self._a_axis = None
      self._b_axis = None
      self._c_axis = None

      # results

      self._refined_beam = (0, 0)
      self._refined_distance = 0

      self._indexing_solutions = { }

      self._indxr_input_lattice = None
      self._indxr_input_cell = None
      self._indxr_user_input_lattice = False

      self._indxr_lattice = None
      self._indxr_cell = None
      self._indxr_mosaic = None

      self._input_data_files = { }
      self._output_data_files = { }

      self._input_data_files_list = ['SPOT.XDS']

      self._output_data_files_list = ['SPOT.XDS',
                                      'XPARM.XDS']

      self._index_tree_problem = False

      self._fraction_rmsd_rmsphi = None

      return
Example #6
0
    def __init__(self, params=None):
      super(XDSCorrectWrapper, self).__init__()

      # phil parameters

      if not params:
        from xia2.Handlers.Phil import master_phil
        params = master_phil.extract().xds.correct
      self._params = params

      # now set myself up...

      self._parallel = Flags.get_parallel()
      self.set_cpu_threads(self._parallel)

      if self._parallel <= 1:
        self.set_executable('xds')
      else:
        self.set_executable('xds_par')

      # generic bits

      self._data_range = (0, 0)
      self._spot_range = []
      self._background_range = (0, 0)
      self._resolution_range = (0, 0)
      self._resolution_high = 0.0
      self._resolution_low = 40.0

      # specific information

      self._cell = None
      self._spacegroup_number = None
      self._anomalous = False

      self._polarization = 0.0

      self._reindex_matrix = None
      self._reindex_used = None

      self._input_data_files = { }
      self._output_data_files = { }

      self._input_data_files_list = []

      self._output_data_files_list = ['GXPARM.XDS']

      self._ice = 0
      self._excluded_regions = []

      # the following input files are also required:
      #
      # INTEGRATE.HKL
      # REMOVE.HKL
      #
      # and XDS_ASCII.HKL is produced.

      # in
      self._integrate_hkl = None
      self._remove_hkl = None

      # out
      self._xds_ascii_hkl = None
      self._results = None
      self._remove = []

      return
Example #7
0
        def __init__(self, params=None):
            super(XDSIdxrefWrapper, self).__init__()

            # phil parameters

            if not params:
                from xia2.Handlers.Phil import master_phil

                params = master_phil.extract().xds.index
            self._params = params

            # now set myself up...

            self._parallel = PhilIndex.params.xia2.settings.multiprocessing.nproc
            self.set_cpu_threads(self._parallel)

            if self._parallel <= 1:
                self.set_executable("xds")
            else:
                self.set_executable("xds_par")

            # generic bits

            self._data_range = (0, 0)
            self._spot_range = []
            self._background_range = (0, 0)
            self._resolution_range = (0, 0)

            self._org = [0.0, 0.0]

            self._refined_origin = None
            self._refined_beam_vector = None
            self._refined_rotation_axis = None

            self._starting_angle = 0.0
            self._starting_frame = 0

            self._cell = None
            self._symm = 0

            self._a_axis = None
            self._b_axis = None
            self._c_axis = None

            # results

            self._refined_beam = (0, 0)
            self._refined_distance = 0

            self._indexing_solutions = {}

            self._indxr_input_lattice = None
            self._indxr_input_cell = None
            self._indxr_user_input_lattice = False

            self._indxr_lattice = None
            self._indxr_cell = None
            self._indxr_mosaic = None

            self._input_data_files = {}
            self._output_data_files = {}

            self._input_data_files_list = ["SPOT.XDS"]

            self._output_data_files_list = ["SPOT.XDS", "XPARM.XDS"]

            self._index_tree_problem = False

            self._fraction_rmsd_rmsphi = None