Example #1
0
 def get_next(self):
   if (self.coordinate_format == "generic"):
     if (self.i_next_model): return None
     crystal_symmetry = crystal.symmetry(
       unit_cell=self.get_unit_cell(),
       space_group_info=self.get_space_group_info())
     m = emma.model(
       crystal.special_position_settings(crystal_symmetry),
       self.positions)
     m.label = "Model 2"
     self.i_next_model += 1
     return m
   if (self.coordinate_format == "pdb"):
     if (self.i_next_model): return None
     self.i_next_model += 1
     return self.pdb_model
   if (self.coordinate_format == "sdb"):
     if (self.i_next_model >= len(self.sdb_files)): return None
     sdb = self.sdb_files[self.i_next_model]
     crystal_symmetry = crystal.symmetry(
       unit_cell=self.get_unit_cell(sdb.unit_cell),
       space_group_info=self.get_space_group_info(sdb.space_group_info))
     if (self.other_symmetry is not None):
       crystal_symmetry = crystal_symmetry.join_symmetry(
         other_symmetry=self.other_symmetry,
         force=False)
     m = sdb_file_to_emma_model(crystal_symmetry, sdb)
     self.i_next_model += 1
     return m
   raise RuntimeError("Internal error.")
Example #2
0
def get_emma_model_from_pdb(file_name=None,
                            pdb_records=None,
                            crystal_symmetry=None):
  assert [file_name, pdb_records].count(None) == 1
  if (pdb_records is None):
    pdb_inp = iotbx.pdb.input(file_name=file_name)
  else:
    pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_records)
  crystal_symmetry = pdb_inp.crystal_symmetry(
    crystal_symmetry=crystal_symmetry,
    weak_symmetry=True)
  if (not crystal_symmetry or crystal_symmetry.unit_cell() is None):
    raise RuntimeError("Unit cell parameters unknown for model %s." %(
        file_name))
  if (crystal_symmetry.space_group_info() is None):
    raise RuntimeError("Space group unknown.")
  positions = []
  for atom in pdb_inp.atoms_with_labels():
    positions.append(emma.position(
      ":".join([str(len(positions)+1),
                atom.name, atom.resname, atom.chain_id]),
      crystal_symmetry.unit_cell().fractionalize(atom.xyz)))
  assert len(positions) > 0
  result = emma.model(
    crystal_symmetry.special_position_settings(),
    positions)
  if (file_name is not None):
    result.label = file_name
  return result
Example #3
0
def get_emma_model_from_pdb(file_name=None,
                            pdb_records=None,
                            crystal_symmetry=None):
    assert [file_name, pdb_records].count(None) == 1
    if (pdb_records is None):
        pdb_inp = iotbx.pdb.input(file_name=file_name)
    else:
        pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_records)
    crystal_symmetry = pdb_inp.crystal_symmetry(
        crystal_symmetry=crystal_symmetry, weak_symmetry=True)
    if (not crystal_symmetry or crystal_symmetry.unit_cell() is None):
        raise RuntimeError("Unit cell parameters unknown for model %s." %
                           (file_name))
    if (crystal_symmetry.space_group_info() is None):
        raise RuntimeError("Space group unknown.")
    positions = []
    for atom in pdb_inp.atoms_with_labels():
        positions.append(
            emma.position(
                ":".join([
                    str(len(positions) + 1), atom.name, atom.resname,
                    atom.chain_id
                ]),
                crystal_symmetry.unit_cell().fractionalize(atom.xyz)))
    assert len(positions) > 0
    result = emma.model(crystal_symmetry.special_position_settings(),
                        positions)
    if (file_name is not None):
        result.label = file_name
    return result
Example #4
0
 def get_next(self):
     if (self.coordinate_format == "generic"):
         if (self.i_next_model): return None
         crystal_symmetry = crystal.symmetry(
             unit_cell=self.get_unit_cell(),
             space_group_info=self.get_space_group_info())
         m = emma.model(crystal.special_position_settings(crystal_symmetry),
                        self.positions)
         m.label = "Model 2"
         self.i_next_model += 1
         return m
     if (self.coordinate_format == "pdb"):
         if (self.i_next_model): return None
         self.i_next_model += 1
         return self.pdb_model
     if (self.coordinate_format == "sdb"):
         if (self.i_next_model >= len(self.sdb_files)): return None
         sdb = self.sdb_files[self.i_next_model]
         crystal_symmetry = crystal.symmetry(
             unit_cell=self.get_unit_cell(sdb.unit_cell),
             space_group_info=self.get_space_group_info(
                 sdb.space_group_info))
         if (self.other_symmetry is not None):
             crystal_symmetry = crystal_symmetry.join_symmetry(
                 other_symmetry=self.other_symmetry, force=False)
         m = sdb_file_to_emma_model(crystal_symmetry, sdb)
         self.i_next_model += 1
         return m
     raise RuntimeError("Internal error.")
Example #5
0
def get_emma_model_from_solve(file_name, crystal_symmetry):
    positions = []
    for line in open(file_name):
        flds = line.split()
        if (len(flds) < 4 or flds[0].lower() != "xyz"): continue
        site = [float(x) for x in flds[1:4]]
        positions.append(emma.position("site" + str(len(positions) + 1), site))
    assert len(positions) > 0
    result = emma.model(crystal_symmetry.special_position_settings(),
                        positions)
    result.label = file_name
    return result
Example #6
0
def get_emma_model_from_solve(file_name, crystal_symmetry):
  positions = []
  for line in open(file_name):
    flds = line.split()
    if (len(flds) < 4 or flds[0].lower() != "xyz"): continue
    site = [float(x) for x in flds[1:4]]
    positions.append(emma.position("site"+str(len(positions)+1), site))
  assert len(positions) > 0
  result = emma.model(
    crystal_symmetry.special_position_settings(),
    positions)
  result.label = file_name
  return result
Example #7
0
def sdb_file_to_emma_model(crystal_symmetry, sdb_file):
    positions = []
    for i, site in zip(count(1), sdb_file.sites):
        if (crystal_symmetry.unit_cell() is None):
            raise RuntimeError("Unit cell parameters unknown.")
        positions.append(
            emma.position(
                ":".join((str(i), site.segid, site.type)),
                crystal_symmetry.unit_cell().fractionalize(
                    (site.x, site.y, site.z))))
    m = emma.model(crystal_symmetry.special_position_settings(), positions)
    m.label = sdb_file.file_name
    return m
Example #8
0
def sdb_file_to_emma_model(crystal_symmetry, sdb_file):
  positions = []
  for i,site in zip(count(1),sdb_file.sites):
    if (crystal_symmetry.unit_cell() is None):
      raise RuntimeError("Unit cell parameters unknown.")
    positions.append(emma.position(
      ":".join((str(i), site.segid, site.type)),
      crystal_symmetry.unit_cell().fractionalize((site.x, site.y, site.z))))
  m = emma.model(
    crystal_symmetry.special_position_settings(),
    positions)
  m.label = sdb_file.file_name
  return m
Example #9
0
def pdb_file_to_emma_model(crystal_symmetry, pdb_inp, other_symmetry):
    crystal_symmetry = pdb_inp.crystal_symmetry(
        crystal_symmetry=crystal_symmetry, weak_symmetry=False)
    if (other_symmetry is not None):
        crystal_symmetry = crystal_symmetry.join_symmetry(
            other_symmetry=other_symmetry, force=False)
    positions = []
    for atom in pdb_inp.atoms_with_labels():
        if (crystal_symmetry.unit_cell() is None):
            raise RuntimeError("Unit cell parameters unknown.")
        positions.append(
            emma.position(
                ":".join([
                    str(len(positions) + 1), atom.name, atom.resname,
                    atom.chain_id
                ]),
                crystal_symmetry.unit_cell().fractionalize(atom.xyz)))
    m = emma.model(crystal_symmetry.special_position_settings(), positions)
    m.label = "Other model"
    return m
Example #10
0
def get_emma_models_from_lst(file_name, crystal_symmetry):
  read_flag = False
  positions = []
  re_lst_header = re.compile("Try  *([0-9]+), CPU  *([0-9]+), CC All/Weak  *([-0-9\.]+)  */  *([-0-9\.]+)")
  
  for l in open(file_name):
    if l.startswith("    x       y       z"):
      read_flag = True
      positions = []
    elif read_flag and l.strip() == "":
      read_flag = False
    elif read_flag:
      site = map(float, (l[:8], l[8:16], l[16:24]))
      positions.append(emma.position(str(len(positions)+1), site))
    elif l.startswith(" Try "):
      r = re_lst_header.search(l)
      itry, ccall, ccweak = r.group(1), r.group(3), r.group(4)

      ret = emma.model(crystal_symmetry.special_position_settings(), positions)
      ret.label = "Try%s_CCall_%s_CCweak_%s" % (itry, ccall, ccweak)
      yield (ret, itry, ccall, ccweak)
Example #11
0
def pdb_file_to_emma_model(crystal_symmetry, pdb_inp, other_symmetry):
  crystal_symmetry = pdb_inp.crystal_symmetry(
    crystal_symmetry=crystal_symmetry,
    weak_symmetry=False)
  if (other_symmetry is not None):
    crystal_symmetry = crystal_symmetry.join_symmetry(
      other_symmetry=other_symmetry,
      force=False)
  positions = []
  for atom in pdb_inp.atoms_with_labels():
    if (crystal_symmetry.unit_cell() is None):
      raise RuntimeError("Unit cell parameters unknown.")
    positions.append(emma.position(
      ":".join([str(len(positions)+1),
                atom.name, atom.resname, atom.chain_id]),
      crystal_symmetry.unit_cell().fractionalize(atom.xyz)))
  m = emma.model(
    crystal_symmetry.special_position_settings(),
    positions)
  m.label = "Other model"
  return m
Example #12
0
def get_emma_model_from_sdb(file_name, crystal_symmetry):
  sdb_files = sdb_reader.multi_sdb_parser(open(file_name))
  if (len(sdb_files) > 1):
    raise MultipleEntriesError(
      "SDB file %s may contain only one structure." % file_name)
  assert len(sdb_files) == 1
  sdb_file = sdb_files[0]
  crystal_symmetry = crystal_symmetry.join_symmetry(
    other_symmetry=sdb_file.crystal_symmetry(),
    force=True)
  positions = []
  for i,site in enumerate(sdb_file.sites):
    if (crystal_symmetry.unit_cell() is None):
      raise RuntimeError("Unit cell parameters unknown.")
    positions.append(emma.position(
      ":".join((str(i+1), site.segid, site.type)),
      crystal_symmetry.unit_cell().fractionalize((site.x, site.y, site.z))))
  assert len(positions) > 0
  result = emma.model(
    crystal_symmetry.special_position_settings(),
    positions)
  result.label = sdb_file.file_name
  return result
Example #13
0
def get_emma_model_from_sdb(file_name, crystal_symmetry):
    sdb_files = sdb_reader.multi_sdb_parser(open(file_name))
    if (len(sdb_files) > 1):
        raise MultipleEntriesError(
            "SDB file %s may contain only one structure." % file_name)
    assert len(sdb_files) == 1
    sdb_file = sdb_files[0]
    crystal_symmetry = crystal_symmetry.join_symmetry(
        other_symmetry=sdb_file.crystal_symmetry(), force=True)
    positions = []
    for i, site in enumerate(sdb_file.sites):
        if (crystal_symmetry.unit_cell() is None):
            raise RuntimeError("Unit cell parameters unknown.")
        positions.append(
            emma.position(
                ":".join((str(i + 1), site.segid, site.type)),
                crystal_symmetry.unit_cell().fractionalize(
                    (site.x, site.y, site.z))))
    assert len(positions) > 0
    result = emma.model(crystal_symmetry.special_position_settings(),
                        positions)
    result.label = sdb_file.file_name
    return result
def exercise_one_structure(
    target_structure,
    flipping_type,
    anomalous_flag,
    d_min,
    grid_resolution_factor=1.0 / 2,
    verbose=False,
    amplitude_type="F",
):
    assert amplitude_type in ("F", "E", "quasi-E")

    # Generate its structure factors
    f_target = (
        miller.build_set(
            crystal_symmetry=target_structure,
            anomalous_flag=target_structure.scatterers().count_anomalous() != 0,
            d_min=d_min,
        )
        .structure_factors_from_scatterers(xray_structure=target_structure, algorithm="direct")
        .f_calc()
    )

    f_target_in_p1 = f_target.expand_to_p1().as_non_anomalous_array().merge_equivalents().array()
    f_obs = f_target.as_amplitude_array()

    # Unleash charge flipping on the amplitudes
    flipping = flipping_type(delta=None)
    extra = group_args()
    if amplitude_type == "E":
        extra.normalisations_for = lambda f: f.amplitude_normalisations(
            target_structure.unit_cell_content(omit=("H", "D"))
        )
    elif amplitude_type == "quasi-E":
        extra.normalisations_for = charge_flipping.amplitude_quasi_normalisations
    solving = charge_flipping.solving_iterator(
        flipping, f_obs, yield_during_delta_guessing=True, yield_solving_interval=1, **extra.__dict__
    )
    s = StringIO()
    charge_flipping.loop(solving, verbose="highly", out=s)
    if verbose:
        print s.getvalue()

    # check whether a phase transition has occured
    assert solving.had_phase_transition

    flipping = solving.flipping_iterator
    f_result_in_p1 = solving.flipping_iterator.f_calc

    # Euclidean matching of the peaks from the obtained map
    # against those of the correct structure (in P1)
    target_structure = target_structure.select(target_structure.scattering_types() == "H", negate=True)
    target_structure_in_p1 = target_structure.expand_to_p1()
    search_parameters = maptbx.peak_search_parameters(
        interpolate=True, min_distance_sym_equiv=1.0, max_clusters=int(target_structure_in_p1.scatterers().size() * 1.2)
    )
    peak_search_outcome = flipping.rho_map.peak_search(search_parameters)
    peak_structure = emma.model(
        target_structure_in_p1.crystal_symmetry().special_position_settings(),
        positions=[emma.position("Q%i" % i, x) for i, x in enumerate(peak_search_outcome.all().sites())],
    )
    refined_matches = emma.model_matches(
        target_structure_in_p1.as_emma_model(), peak_structure, tolerance=0.5, break_if_match_with_no_singles=False
    ).refined_matches
    m = refined_matches[0]
    assert m.rms < 0.2, m.rms  # no farther than that
    assert m.rt.r in (mat.identity(3), mat.inversion(3))

    reference_shift = -refined_matches[0].rt.t

    # Find the translation to bring back the structure to the same space-group
    # setting as the starting f_obs from correlation map analysis
    is_allowed = lambda x: f_target.space_group_info().is_allowed_origin_shift(x, tolerance=0.1)
    first_correct_correlation_peak = None
    for i, (f_calc, shift, cc_peak_height) in enumerate(solving.f_calc_solutions):
        if is_allowed(shift - reference_shift) or is_allowed(shift + reference_shift):
            first_correct_correlation_peak = i
            break
        else:
            if verbose == "more":
                print "++ Incorrect peak: shift=(%.3f, %.3f, %.3f), height=%.2f" % (tuple(shift) + (cc_peak_height,))
                print "   Reference shift=(%.3f, %.3f, %.3f)" % tuple(reference_shift)
    assert first_correct_correlation_peak is not None
    if verbose and first_correct_correlation_peak != 0:
        print "** First correct correlation peak: #%i (%.3f) **" % (first_correct_correlation_peak, cc_peak_height)

    # check Euclidean matching in the original space-group
    search_parameters = maptbx.peak_search_parameters(
        interpolate=True, min_distance_sym_equiv=1.0, max_clusters=int(1.5 * target_structure.scatterers().size())
    )
    solution_fft_map = f_calc.fft_map(symmetry_flags=maptbx.use_space_group_symmetry)
    solution_peaks = solution_fft_map.peak_search(search_parameters, verify_symmetry=False)
    solution_peak_structure = emma.model(
        target_structure.crystal_symmetry().special_position_settings(),
        positions=[emma.position("Q%i" % i, x) for i, x in enumerate(solution_peaks.all().sites())],
    )
    refined_matches = emma.model_matches(
        target_structure.as_emma_model(), solution_peak_structure, break_if_match_with_no_singles=False
    ).refined_matches
    assert refined_matches
    m = refined_matches[0]
    assert not m.singles1, m.show()  # all sites match a peak
    assert m.rms < 0.15, m.rms  # no farther than that
    assert m.rt.r in (mat.identity(3), mat.inversion(3))

    # success!
    if verbose:
        print "@@ Success @@"
def run():
  import sys
  reflection_file_name = sys.argv[1]
  import iotbx.cif
  miller_arrays = iotbx.cif.reader(
    file_path=reflection_file_name).as_miller_arrays()
  for miller_array in miller_arrays:
    s = str(miller_array.info())
    if '_meas' in s:
      if miller_array.is_xray_intensity_array():
        break
      elif miller_array.is_xray_amplitude_array():
        break
  if not ('_meas' in str(miller_array.info())
          and (miller_array.is_xray_amplitude_array()
               or miller_array.is_xray_intensity_array())):
    print "Sorry: CIF does not contain an appropriate miller array"
    return
  miller_array.show_comprehensive_summary()
  print

  if (miller_array.is_xray_intensity_array()):
    print "Converting intensities to amplitudes."
    miller_array = miller_array.as_amplitude_array()
    print

  miller_array.setup_binner(auto_binning=True)
  miller_array.binner().show_summary()
  print

  all_e_values = miller_array.quasi_normalize_structure_factors().sort(
    by_value="data")
  large_e_values = all_e_values.select(all_e_values.data() > 1.2)
  print "number of large_e_values:", large_e_values.size()
  print

  from cctbx import dmtbx
  triplets = dmtbx.triplet_generator(large_e_values)
  from cctbx.array_family import flex
  print "triplets per reflection: min,max,mean: %d, %d, %.2f" % (
    flex.min(triplets.n_relations()),
    flex.max(triplets.n_relations()),
    flex.mean(triplets.n_relations().as_double()))
  print "total number of triplets:", flex.sum(triplets.n_relations())
  print

  input_phases = large_e_values \
    .random_phases_compatible_with_phase_restrictions()
  tangent_formula_phases = input_phases.data()
  for i in xrange(10):
    tangent_formula_phases = triplets.apply_tangent_formula(
      amplitudes=large_e_values.data(),
      phases_rad=tangent_formula_phases,
      selection_fixed=None,
      use_fixed_only=False,
      reuse_results=True)

  e_map_coeff = large_e_values.phase_transfer(
    phase_source=tangent_formula_phases)
  from cctbx import maptbx
  e_map = e_map_coeff.fft_map(
    symmetry_flags=maptbx.use_space_group_symmetry)
  e_map.apply_sigma_scaling()
  e_map.statistics().show_summary(prefix="e_map ")
  print

  peak_search = e_map.peak_search(parameters=maptbx.peak_search_parameters(
    min_distance_sym_equiv=1.2))
  peaks = peak_search.all(max_clusters=10)
  print "e_map peak list"
  print "       fractional coordinates       peak height"
  for site,height in zip(peaks.sites(), peaks.heights()):
    print "  (%9.6f, %9.6f, %9.6f)" % site, "%10.3f" % height
  print

  if (len(sys.argv) > 2):
    coordinate_file_name = sys.argv[2]
    xray_structure = iotbx.cif.reader(
      file_path=coordinate_file_name).build_crystal_structures(
        data_block_name="I")
    xray_structure.show_summary().show_scatterers()
    print

    f_calc = abs(miller_array.structure_factors_from_scatterers(
      xray_structure=xray_structure,
      algorithm="direct").f_calc())
    correlation = flex.linear_correlation(f_calc.data(), miller_array.data())
    assert correlation.is_well_defined()
    print "correlation of f_obs and f_calc: %.4f" % correlation.coefficient()
    print

    reference_model = xray_structure.as_emma_model()
    assert reference_model.unit_cell().is_similar_to(e_map.unit_cell())
    assert reference_model.space_group() == e_map.space_group()
    from cctbx import euclidean_model_matching as emma
    peak_model = emma.model(special_position_settings=reference_model)
    for i,site in enumerate(peaks.sites()):
      peak_model.add_position(emma.position(label="peak%02d" % i, site=site))
    matches = emma.model_matches(
      model1=reference_model,
      model2=peak_model,
      tolerance=1.,
      models_are_diffraction_index_equivalent=True)
    for match in matches.refined_matches:
      match.show()
Example #16
0
def exercise_one_structure(
    target_structure,
    flipping_type,
    anomalous_flag,
    d_min,
    grid_resolution_factor=1. / 2,
    verbose=False,
    amplitude_type="F",
):
    assert amplitude_type in ('F', 'E', 'quasi-E')

    # Generate its structure factors
    f_target = miller.build_set(
        crystal_symmetry=target_structure,
        anomalous_flag=target_structure.scatterers().count_anomalous() != 0,
        d_min=d_min).structure_factors_from_scatterers(
            xray_structure=target_structure, algorithm="direct").f_calc()

    f_target_in_p1 = f_target.expand_to_p1()\
                             .as_non_anomalous_array()\
                             .merge_equivalents().array()
    f_obs = f_target.as_amplitude_array()

    # Unleash charge flipping on the amplitudes
    flipping = flipping_type(delta=None)
    extra = group_args()
    if amplitude_type == 'E':
        extra.normalisations_for = lambda f: f.amplitude_normalisations(
            target_structure.unit_cell_content(omit=('H', 'D')))
    elif amplitude_type == 'quasi-E':
        extra.normalisations_for = charge_flipping.amplitude_quasi_normalisations
    solving = charge_flipping.solving_iterator(
        flipping,
        f_obs,
        yield_during_delta_guessing=True,
        yield_solving_interval=1,
        **extra.__dict__)
    s = StringIO()
    charge_flipping.loop(solving, verbose="highly", out=s)
    if verbose:
        print s.getvalue()

    # check whether a phase transition has occured
    assert solving.had_phase_transition

    flipping = solving.flipping_iterator
    f_result_in_p1 = solving.flipping_iterator.f_calc

    # Euclidean matching of the peaks from the obtained map
    # against those of the correct structure (in P1)
    target_structure = target_structure.select(
        target_structure.scattering_types() == "H", negate=True)
    target_structure_in_p1 = target_structure.expand_to_p1()
    search_parameters = maptbx.peak_search_parameters(
        interpolate=True,
        min_distance_sym_equiv=1.,
        max_clusters=int(target_structure_in_p1.scatterers().size() * 1.2))
    peak_search_outcome = flipping.rho_map.peak_search(search_parameters)
    peak_structure = emma.model(
        target_structure_in_p1.crystal_symmetry().special_position_settings(),
        positions=[
            emma.position('Q%i' % i, x)
            for i, x in enumerate(peak_search_outcome.all().sites())
        ])
    refined_matches = emma.model_matches(
        target_structure_in_p1.as_emma_model(),
        peak_structure,
        tolerance=0.5,
        break_if_match_with_no_singles=False).refined_matches
    m = refined_matches[0]
    assert m.rms < 0.2, m.rms  # no farther than that
    assert m.rt.r in (mat.identity(3), mat.inversion(3))

    reference_shift = -refined_matches[0].rt.t

    # Find the translation to bring back the structure to the same space-group
    # setting as the starting f_obs from correlation map analysis
    is_allowed = lambda x: f_target.space_group_info().is_allowed_origin_shift(
        x, tolerance=0.1)
    first_correct_correlation_peak = None
    for i, (f_calc, shift,
            cc_peak_height) in enumerate(solving.f_calc_solutions):
        if (is_allowed(shift - reference_shift)
                or is_allowed(shift + reference_shift)):
            first_correct_correlation_peak = i
            break
        else:
            if verbose == "more":
                print "++ Incorrect peak: shift=(%.3f, %.3f, %.3f), height=%.2f"\
                      % (tuple(shift)+(cc_peak_height,))
                print "   Reference shift=(%.3f, %.3f, %.3f)" % tuple(
                    reference_shift)
    assert first_correct_correlation_peak is not None
    if verbose and first_correct_correlation_peak != 0:
        print "** First correct correlation peak: #%i (%.3f) **"\
              % (first_correct_correlation_peak, cc_peak_height)

    # check Euclidean matching in the original space-group
    search_parameters = maptbx.peak_search_parameters(
        interpolate=True,
        min_distance_sym_equiv=1.,
        max_clusters=int(1.5 * target_structure.scatterers().size()))
    solution_fft_map = f_calc.fft_map(
        symmetry_flags=maptbx.use_space_group_symmetry)
    solution_peaks = solution_fft_map.peak_search(search_parameters,
                                                  verify_symmetry=False)
    solution_peak_structure = emma.model(
        target_structure.crystal_symmetry().special_position_settings(),
        positions=[
            emma.position('Q%i' % i, x)
            for i, x in enumerate(solution_peaks.all().sites())
        ])
    refined_matches = emma.model_matches(
        target_structure.as_emma_model(),
        solution_peak_structure,
        break_if_match_with_no_singles=False).refined_matches
    assert refined_matches
    m = refined_matches[0]
    assert not m.singles1, m.show()  # all sites match a peak
    assert m.rms < 0.15, m.rms  # no farther than that
    assert m.rt.r in (mat.identity(3), mat.inversion(3))

    # success!
    if verbose:
        print "@@ Success @@"
def run():
    import sys
    reflection_file_name = sys.argv[1]
    import iotbx.cif
    miller_arrays = iotbx.cif.reader(
        file_path=reflection_file_name).as_miller_arrays()
    for miller_array in miller_arrays:
        s = str(miller_array.info())
        if '_meas' in s:
            if miller_array.is_xray_intensity_array():
                break
            elif miller_array.is_xray_amplitude_array():
                break
    if not ('_meas' in str(miller_array.info()) and
            (miller_array.is_xray_amplitude_array()
             or miller_array.is_xray_intensity_array())):
        print "Sorry: CIF does not contain an appropriate miller array"
        return
    miller_array.show_comprehensive_summary()
    print

    if (miller_array.is_xray_intensity_array()):
        print "Converting intensities to amplitudes."
        miller_array = miller_array.as_amplitude_array()
        print

    miller_array.setup_binner(auto_binning=True)
    miller_array.binner().show_summary()
    print

    all_e_values = miller_array.quasi_normalize_structure_factors().sort(
        by_value="data")
    large_e_values = all_e_values.select(all_e_values.data() > 1.2)
    print "number of large_e_values:", large_e_values.size()
    print

    from cctbx import dmtbx
    triplets = dmtbx.triplet_generator(large_e_values)
    from cctbx.array_family import flex
    print "triplets per reflection: min,max,mean: %d, %d, %.2f" % (
        flex.min(triplets.n_relations()), flex.max(triplets.n_relations()),
        flex.mean(triplets.n_relations().as_double()))
    print "total number of triplets:", flex.sum(triplets.n_relations())
    print

    input_phases = large_e_values \
      .random_phases_compatible_with_phase_restrictions()
    tangent_formula_phases = input_phases.data()
    for i in xrange(10):
        tangent_formula_phases = triplets.apply_tangent_formula(
            amplitudes=large_e_values.data(),
            phases_rad=tangent_formula_phases,
            selection_fixed=None,
            use_fixed_only=False,
            reuse_results=True)

    e_map_coeff = large_e_values.phase_transfer(
        phase_source=tangent_formula_phases)
    from cctbx import maptbx
    e_map = e_map_coeff.fft_map(symmetry_flags=maptbx.use_space_group_symmetry)
    e_map.apply_sigma_scaling()
    e_map.statistics().show_summary(prefix="e_map ")
    print

    peak_search = e_map.peak_search(parameters=maptbx.peak_search_parameters(
        min_distance_sym_equiv=1.2))
    peaks = peak_search.all(max_clusters=10)
    print "e_map peak list"
    print "       fractional coordinates       peak height"
    for site, height in zip(peaks.sites(), peaks.heights()):
        print "  (%9.6f, %9.6f, %9.6f)" % site, "%10.3f" % height
    print

    if (len(sys.argv) > 2):
        coordinate_file_name = sys.argv[2]
        xray_structure = iotbx.cif.reader(
            file_path=coordinate_file_name).build_crystal_structures(
                data_block_name="I")
        xray_structure.show_summary().show_scatterers()
        print

        f_calc = abs(
            miller_array.structure_factors_from_scatterers(
                xray_structure=xray_structure, algorithm="direct").f_calc())
        correlation = flex.linear_correlation(f_calc.data(),
                                              miller_array.data())
        assert correlation.is_well_defined()
        print "correlation of f_obs and f_calc: %.4f" % correlation.coefficient(
        )
        print

        reference_model = xray_structure.as_emma_model()
        assert reference_model.unit_cell().is_similar_to(e_map.unit_cell())
        assert reference_model.space_group() == e_map.space_group()
        from cctbx import euclidean_model_matching as emma
        peak_model = emma.model(special_position_settings=reference_model)
        for i, site in enumerate(peaks.sites()):
            peak_model.add_position(
                emma.position(label="peak%02d" % i, site=site))
        matches = emma.model_matches(
            model1=reference_model,
            model2=peak_model,
            tolerance=1.,
            models_are_diffraction_index_equivalent=True)
        for match in matches.refined_matches:
            match.show()