def Sortmtz(self):
   '''Create a Sortmtz wrapper from _Sortmtz - set the working directory
   and log file stuff as a part of this...'''
   sortmtz = _Sortmtz()
   sortmtz.set_working_directory(self.get_working_directory())
   auto_logfiler(sortmtz)
   return sortmtz

def get_reciprocal_space_primitive_matrix(lattice, matrix, wd = None):
  '''Get the primitive reciprocal space vectors for this matrix.'''

  # parse the orientation matrix

  cell, a, u = parse_matrix(matrix)

  # generate other possibilities

  o = _Othercell()

  if wd:
    o.set_working_directory(wd)
    auto_logfiler(o)

  o.set_cell(cell)
  o.set_lattice(lattice)
  o.generate()

  # transform the possibly centred cell to the primitive setting

  new_cell = o.get_cell('aP')
  op = symop_to_mat(o.get_reindex_op('aP'))

  primitive_a = matmul(invert(op), a)

  return mat2vec(primitive_a)

 def Chef(self):
   '''Create a Chef wrapper from _Chef - set the
   working directory and log file stuff as a part of this...'''
   chef = _Chef()
   chef.set_working_directory(self.get_working_directory())
   auto_logfiler(chef)
   return chef

 def Report(self):
   report = _Report()
   report.set_working_directory(self.get_working_directory())
   report.set_experiments_filename(self._intgr_experiments_filename)
   report.set_reflections_filename(self._intgr_integrated_pickle)
   auto_logfiler(report, 'REPORT')
   return report

 def Freerflag(self):
   '''Create a Freerflag wrapper from _Freerflag - set the working
   directory and log file stuff as a part of this...'''
   freerflag = _Freerflag()
   freerflag.set_working_directory(self.get_working_directory())
   auto_logfiler(freerflag)
   return freerflag

 def Matthews_coef(self):
   '''Create a Matthews_coef wrapper from _Matthews_coef - set the
   working directory and log file stuff as a part of this...'''
   matthews_coef = _Matthews_coef()
   matthews_coef.set_working_directory(self.get_working_directory())
   auto_logfiler(matthews_coef)
   return matthews_coef

 def Mtz2various(self):
   '''Create a Mtz2various wrapper from _Mtz2various - set the working
   directory and log file stuff as a part of this...'''
   mtz2various = _Mtz2various()
   mtz2various.set_working_directory(self.get_working_directory())
   auto_logfiler(mtz2various)
   return mtz2various

 def Cad(self):
   '''Create a Cad wrapper from _Cad - set the working directory
   and log file stuff as a part of this...'''
   cad = _Cad()
   cad.set_working_directory(self.get_working_directory())
   auto_logfiler(cad)
   return cad

 def Reindex(self):
   '''Create a Reindex wrapper from _Reindex - set the working directory
   and log file stuff as a part of this...'''
   reindex = _Reindex()
   reindex.set_working_directory(self.get_working_directory())
   auto_logfiler(reindex)
   return reindex

  def _index_select_images(self):
    '''Select correct images based on image headers. This will in
    general use the 20 frames. N.B. only if they have good
    spots on them!'''

    phi_width = self.get_phi_width()
    images = self.get_matching_images()

    # N.B. now bodging this to use up to 20 frames which have decent
    # spots on, spaced from throughout the data set.

    spacing = max(1, int(len(images) // 20))

    selected = []

    for j in range(0, len(images), spacing):
      selected.append(images[j])

    for image in selected[:20]:
      ld = LabelitDistl()
      ld.set_working_directory(self.get_working_directory())
      auto_logfiler(ld)
      ld.add_image(self.get_image_name(image))
      ld.distl()
      spots = ld.get_statistics(
          self.get_image_name(image))['spots_good']
      Debug.write('Image %d good spots %d' % (image, spots))
      if spots > 10:
        self.add_indexer_image_wedge(image)

    return

  def Idxref(self):
    from xia2.Handlers.Phil import PhilIndex
    idxref = _Idxref(params=PhilIndex.params.xds.index)
    idxref.set_working_directory(self.get_working_directory())

    idxref.setup_from_imageset(self.get_imageset())

    if self.get_distance():
      idxref.set_distance(self.get_distance())

    if self.get_wavelength():
      idxref.set_wavelength(self.get_wavelength())

    # if we have a refined set of parameters to apply, apply these
    if Flags.get_xparm():
      idxref.set_refined_origin(Flags.get_xparm_origin())
      idxref.set_refined_beam_vector(Flags.get_xparm_beam_vector())
      idxref.set_refined_rotation_axis(Flags.get_xparm_rotation_axis())
      idxref.set_refined_distance(Flags.get_xparm_distance())

    # hacks for Jira 493

    if Flags.get_xparm_a():
      idxref.set_a_axis(Flags.get_xparm_a())
    if Flags.get_xparm_b():
      idxref.set_b_axis(Flags.get_xparm_b())
    if Flags.get_xparm_c():
      idxref.set_c_axis(Flags.get_xparm_c())

    auto_logfiler(idxref, 'IDXREF')

    return idxref

def get_real_space_primitive_matrix(lattice, matrix, wd = None):
  '''Get the primitive real space vectors for the unit cell and
  lattice type. Note that the resulting matrix will need to be
  scaled by a factor equal to the wavelength in Angstroms.'''

  # parse the orientation matrix

  cell, a, u = parse_matrix(matrix)

  # generate other possibilities

  o = _Othercell()

  if wd:
    o.set_working_directory(wd)
    auto_logfiler(o)

  o.set_cell(cell)
  o.set_lattice(lattice)
  o.generate()

  # transform the possibly centred cell to the primitive setting

  new_cell = o.get_cell('aP')
  op = symop_to_mat(o.get_reindex_op('aP'))

  primitive_a = matmul(invert(op), a)

  # then convert to real space

  real_a = invert(primitive_a)

  return real_a[0:3], real_a[3:6], real_a[6:9]

 def Scaleit(self):
   '''Create a Scaleit wrapper from _Scaleit - set the working directory
   and log file stuff as a part of this...'''
   scaleit = _Scaleit()
   scaleit.set_working_directory(self.get_working_directory())
   auto_logfiler(scaleit)
   return scaleit

 def Mtzdump(self):
   '''Create a Mtzdump wrapper from _Mtzdump - set the working directory
   and log file stuff as a part of this...'''
   mtzdump = _Mtzdump()
   mtzdump.set_working_directory(self.get_working_directory())
   auto_logfiler(mtzdump)
   return mtzdump

  def Correct(self):
    correct = _Correct(params=PhilIndex.params.xds.correct)
    correct.set_working_directory(self.get_working_directory())

    correct.setup_from_imageset(self.get_imageset())

    if self.get_distance():
      correct.set_distance(self.get_distance())

    if self.get_wavelength():
      correct.set_wavelength(self.get_wavelength())

    if self.get_integrater_ice():
      correct.set_ice(self.get_integrater_ice())

    if self.get_integrater_excluded_regions():
      correct.set_excluded_regions(self.get_integrater_excluded_regions())

    if self.get_integrater_anomalous():
      correct.set_anomalous(True)

    if self.get_integrater_low_resolution() > 0.0:
      Debug.write('Using low resolution limit: %.2f' % \
                  self.get_integrater_low_resolution())
      correct.set_resolution_high(0.0)
      correct.set_resolution_low(
          self.get_integrater_low_resolution())

    auto_logfiler(correct, 'CORRECT')

    return correct

 def Pointless(self):
   '''Create a Pointless wrapper from _Pointless - and set the
   working directory and log file stuff as a part of this...'''
   pointless = _Pointless()
   pointless.set_working_directory(self.get_working_directory())
   auto_logfiler(pointless)
   return pointless

 def Cellparm(self):
   '''Create a Cellparm wrapper from _Cellparm - set the working directory
   and log file stuff as a part of this...'''
   cellparm = _Cellparm()
   cellparm.set_working_directory(self.get_working_directory())
   auto_logfiler(cellparm)
   return cellparm

  def _integrate_finish(self):
    '''Finish the integration - if necessary performing reindexing
    based on the pointgroup and the reindexing operator.'''

    if self._intgr_reindex_operator is None and \
       self._intgr_spacegroup_number == lattice_to_spacegroup(
        self.get_integrater_refiner().get_refiner_lattice()):
      return self._mosflm_hklout

    if self._intgr_reindex_operator is None and \
       self._intgr_spacegroup_number == 0:
      return self._mosflm_hklout

    Debug.write('Reindexing to spacegroup %d (%s)' % \
                (self._intgr_spacegroup_number,
                 self._intgr_reindex_operator))

    hklin = self._mosflm_hklout
    reindex = Reindex()
    reindex.set_working_directory(self.get_working_directory())
    auto_logfiler(reindex)

    reindex.set_operator(self._intgr_reindex_operator)

    if self._intgr_spacegroup_number:
      reindex.set_spacegroup(self._intgr_spacegroup_number)

    hklout = '%s_reindex.mtz' % hklin[:-4]

    reindex.set_hklin(hklin)
    reindex.set_hklout(hklout)
    reindex.reindex()

    return hklout

 def Rebatch(self):
   '''Create a Rebatch wrapper from _Rebatch - set the working directory
   and log file stuff as a part of this...'''
   rebatch = _Rebatch()
   rebatch.set_working_directory(self.get_working_directory())
   auto_logfiler(rebatch)
   return rebatch

 def Truncate(self):
   '''Create a Truncate wrapper from _Truncate - set the working directory
   and log file stuff as a part of this...'''
   truncate = _Truncate()
   truncate.set_working_directory(self.get_working_directory())
   auto_logfiler(truncate)
   return truncate