Example #1
0
def quartz():
  return xray.structure(
    crystal_symmetry=crystal.symmetry(
      (5.01,5.01,5.47,90,90,120), "P6222"),
    scatterers=flex.xray_scatterer([
      xray.scatterer("Si", (1/2.,1/2.,1/3.)),
      xray.scatterer("O", (0.197,-0.197,0.83333))]))
 def __init__(self, with_special_position_pivot):
   self.with_special_position_pivot = with_special_position_pivot
   self.uc = uctbx.unit_cell((1, 2, 3))
   self.sg = sgtbx.space_group("P 6")
   self.c0 = xray.scatterer("C0", site=(1e-5, 0., 0.1))
   self.site_symm = sgtbx.site_symmetry(self.uc, self.sg, self.c0.site)
   self.c0.flags.set_grad_site(True)
   self.c1 = xray.scatterer("C1", site=(0.09, 0.11, 0.))
   self.c1.flags.set_grad_site(True)
   self.h = xray.scatterer("H")
   self.reparam = constraints.ext.reparametrisation(self.uc)
   if with_special_position_pivot:
     x0 = self.reparam.add(constraints.special_position_site_parameter,
                           self.site_symm, self.c0)
   else:
     x0 = self.reparam.add(constraints.independent_site_parameter, self.c0)
   x1 = self.reparam.add(constraints.independent_site_parameter, self.c1)
   l = self.reparam.add(constraints.independent_scalar_parameter,
                        self.bond_length, variable=False)
   x_h = self.reparam.add(constraints.terminal_linear_ch_site,
                          pivot=x0,
                          pivot_neighbour=x1,
                          length=l,
                          hydrogen=self.h)
   self.reparam.finalise()
   self.x0, self.x1, self.x_h, self.l = [ x.index for x in (x0, x1, x_h, l) ]
   if self.with_special_position_pivot:
     self.y0 = x0.independent_params.index
def test_spacegroup_tidy_pickling():
  quartz_structure = xray.structure(
    crystal_symmetry=crystal.symmetry(
    unit_cell=(5.01,5.01,5.47,90,90,120),
    space_group_symbol="P6222"),
    scatterers=flex.xray_scatterer(
    [
      xray.scatterer(label="Si", site=(1/2.,1/2.,1/3.), u=0.2),
      xray.scatterer(label="O",  site=(0.197,-0.197,0.83333), u=0)
    ])
  )

  asu_mappings = quartz_structure.asu_mappings(buffer_thickness=2)
  pair_asu_table = crystal.pair_asu_table(asu_mappings=asu_mappings)
  pair_asu_table.add_all_pairs(distance_cutoff=1.7)
  pair_sym_table = pair_asu_table.extract_pair_sym_table()
  new_asu_mappings = quartz_structure.asu_mappings(buffer_thickness=5)
  new_pair_asu_table = crystal.pair_asu_table(asu_mappings=new_asu_mappings)
  new_pair_asu_table.add_pair_sym_table(sym_table=pair_sym_table)
  spg = new_pair_asu_table.asu_mappings().space_group()
  pspg = pickle.loads(pickle.dumps(spg))
  mstr = ""
  pmstr = ""
  for rt in spg.all_ops():
    mstr += rt.r().as_xyz() + "\n"
  for rt in pspg.all_ops():
    pmstr += rt.r().as_xyz() + "\n"
  assert mstr == pmstr
def exercise_is_simple_interaction():
  for space_group_symbol in ["P1", "P41"]:
    for shifts in flex.nested_loop((-2,-2,-2),(2,2,2),False):
      shifts = matrix.col(shifts)
      structure = xray.structure(
        crystal_symmetry=crystal.symmetry(
          unit_cell=(10,10,20,90,90,90),
          space_group_symbol=space_group_symbol),
        scatterers=flex.xray_scatterer([
          xray.scatterer(label="O", site=shifts+matrix.col((0,0,0))),
          xray.scatterer(label="N", site=shifts+matrix.col((0.5,0.5,0))),
          xray.scatterer(label="C", site=shifts+matrix.col((0.25,0.25,0)))]))
      asu_mappings = structure.asu_mappings(buffer_thickness=7)
      pair_generator = crystal.neighbors_simple_pair_generator(
        asu_mappings=asu_mappings,
        distance_cutoff=7)
      simple_interactions = {}
      for i_pair,pair in enumerate(pair_generator):
        if (asu_mappings.is_simple_interaction(pair)):
          assert asu_mappings_is_simple_interaction_emulation(
            asu_mappings, pair)
          key = (pair.i_seq,pair.j_seq)
          assert simple_interactions.get(key, None) is None
          simple_interactions[key] = 1
        else:
          assert not asu_mappings_is_simple_interaction_emulation(
            asu_mappings, pair)
      assert len(simple_interactions) == 2
      assert simple_interactions[(0,2)] == 1
      assert simple_interactions[(1,2)] == 1
 def __init__(self, n_runs, **kwds):
   libtbx.adopt_optional_init_args(self, kwds)
   self.n_runs = n_runs
   self.crystal_symmetry = crystal.symmetry(
     unit_cell=uctbx.unit_cell((5.1534, 5.1534, 8.6522, 90, 90, 120)),
     space_group_symbol='Hall: P 6c')
   self.structure = xray.structure(
     self.crystal_symmetry.special_position_settings(),
     flex.xray_scatterer((
       xray.scatterer('K1',
                       site=(0, 0, -0.00195),
                       u=self.u_cif_as_u_star((0.02427, 0.02427, 0.02379,
                                               0.01214, 0.00000, 0.00000))),
       xray.scatterer('S1',
                      site=(1/3, 2/3, 0.204215),
                      u=self.u_cif_as_u_star((0.01423, 0.01423, 0.01496,
                                              0.00712, 0.00000, 0.00000 ))),
       xray.scatterer('Li1',
                      site=(1/3, 2/3, 0.815681),
                      u=self.u_cif_as_u_star((0.02132, 0.02132, 0.02256,
                                              0.01066, 0.00000, 0.00000 ))),
       xray.scatterer('O1',
                      site=(1/3, 2/3, 0.035931),
                      u=self.u_cif_as_u_star((0.06532, 0.06532, 0.01669,
                                              0.03266, 0.00000, 0.00000 ))),
       xray.scatterer('O2',
                      site=(0.343810, 0.941658, 0.258405),
                      u=self.u_cif_as_u_star((0.02639,  0.02079, 0.05284,
                                              0.01194, -0.00053,-0.01180 )))
     )))
   mi = self.crystal_symmetry.build_miller_set(anomalous_flag=False,
                                               d_min=0.5)
   fo_sq = mi.structure_factors_from_scatterers(
     self.structure, algorithm="direct").f_calc().norm()
   self.fo_sq = fo_sq.customized_copy(sigmas=flex.double(fo_sq.size(), 1))
def demo():
  """
  Result of ICSD query:
    N * -Cr2O3-[R3-CH] Baster, M.;Bouree, F.;Kowalska, A.;Latacz, Z(2000)
    C 4.961950 4.961950 13.597400 90.000000 90.000000 120.000000
    S GRUP R -3 C
    A Cr1    0.000000 0.000000 0.347570 0.000000
    A O1    0.305830 0.000000 0.250000
  """
  crystal_symmetry = crystal.symmetry(
    unit_cell="4.961950 4.961950 13.597400 90.000000 90.000000 120.000000",
    space_group_symbol="R -3 C")
  scatterers = flex.xray_scatterer()
  scatterers.append(xray.scatterer(
    label="Cr1", site=(0.000000,0.000000,0.347570)))
  scatterers.append(xray.scatterer(
    label="O1", site=(0.305830,0.000000,0.250000)))
  icsd_structure = xray.structure(
    crystal_symmetry=crystal_symmetry,
    scatterers=scatterers)
  icsd_structure.show_summary().show_scatterers()
  print
  icsd_structure.show_distances(distance_cutoff=2.5)
  print
  primitive_structure = icsd_structure.primitive_setting()
  primitive_structure.show_summary().show_scatterers()
  print
  p1_structure = primitive_structure.expand_to_p1()
  p1_structure.show_summary().show_scatterers()
  print
  print "OK"
def exercise_unmerged () :
  quartz_structure = xray.structure(
    special_position_settings=crystal.special_position_settings(
      crystal_symmetry=crystal.symmetry(
        unit_cell=(5.01,5.01,5.47,90,90,120),
        space_group_symbol="P6222")),
    scatterers=flex.xray_scatterer([
      xray.scatterer(
        label="Si",
        site=(1/2.,1/2.,1/3.),
        u=0.2),
      xray.scatterer(
        label="O",
        site=(0.197,-0.197,0.83333),
        u=0.1)]))
  quartz_structure.set_inelastic_form_factors(
    photon=1.54,
    table="sasaki")
  fc = abs(quartz_structure.structure_factors(d_min=1.0).f_calc())
  symm = fc.crystal_symmetry()
  icalc = fc.expand_to_p1().f_as_f_sq().set_observation_type_xray_intensity()
  # generate 'unmerged' data
  i_obs = icalc.customized_copy(crystal_symmetry=symm)
  # now make up sigmas and some (hopefully realistic) error
  flex.set_random_seed(12345)
  n_refl = i_obs.size()
  sigmas = flex.random_double(n_refl) * flex.mean(fc.data())
  sigmas = icalc.customized_copy(data=sigmas).apply_debye_waller_factors(
    u_iso=0.15)
  err = (flex.double(n_refl, 0.5) - flex.random_double(n_refl)) * 2
  i_obs = i_obs.customized_copy(
    sigmas=sigmas.data(),
    data=i_obs.data() + err)
  # check for unmerged acentrics
  assert i_obs.is_unmerged_intensity_array()
  i_obs_centric = i_obs.select(i_obs.centric_flags().data())
  i_obs_acentric = i_obs.select(~(i_obs.centric_flags().data()))
  i_mrg_acentric = i_obs_acentric.merge_equivalents().array()
  i_mixed = i_mrg_acentric.concatenate(i_obs_centric)
  assert not i_mixed.is_unmerged_intensity_array()
  # XXX These results of these functions are heavily dependent on the
  # behavior of the random number generator, which is not consistent across
  # platforms - therefore we can only check for very approximate values.
  # Exact numerical results are tested with real data (stored elsewhere).
  # CC1/2, etc.
  assert approx_equal(i_obs.cc_one_half(), 0.9998, eps=0.001)
  assert i_obs.resolution_filter(d_max=1.2).cc_one_half() > 0
  assert i_obs.cc_anom() > 0.1
  r_ano = i_obs.r_anom()
  assert approx_equal(r_ano, 0.080756, eps=0.0001)
  # merging stats
  i_mrg = i_obs.merge_equivalents()
  assert i_mrg.r_merge() < 0.1
  assert i_mrg.r_meas() < 0.1
  assert i_mrg.r_pim() < 0.05
def demo():
  """
  Result of ICSD query:
    N * -Cr2O3-[R3-CH] Baster, M.;Bouree, F.;Kowalska, A.;Latacz, Z(2000)
    C 4.961950 4.961950 13.597400 90.000000 90.000000 120.000000
    S GRUP R -3 C
    A Cr1    0.000000 0.000000 0.347570 0.000000
    A O1    0.305830 0.000000 0.250000
  """
  crystal_symmetry = crystal.symmetry(
    unit_cell="4.961950 4.961950 13.597400 90.000000 90.000000 120.000000",
    space_group_symbol="R -3 C")
  scatterers = flex.xray_scatterer()
  scatterers.append(xray.scatterer(
    label="Cr1", site=(0.000000,0.000000,0.347570)))
  scatterers.append(xray.scatterer(
    label="O1", site=(0.305830,0.000000,0.250000)))
  icsd_structure = xray.structure(
    crystal_symmetry=crystal_symmetry,
    scatterers=scatterers)
  icsd_structure.show_summary().show_scatterers()
  print
  icsd_pairs = icsd_structure.show_distances(
    distance_cutoff=2.5, keep_pair_asu_table=True)
  print
  primitive_structure = icsd_structure.primitive_setting()
  primitive_structure.show_summary().show_scatterers()
  print
  p1_structure = primitive_structure.expand_to_p1()
  p1_structure.show_summary().show_scatterers()
  print
  p1_pairs = p1_structure.show_distances(
    distance_cutoff=2.5, keep_pair_asu_table=True)
  print
  for label,structure,pairs in [("ICSD", icsd_structure,icsd_pairs),
                                ("P1", p1_structure,p1_pairs)]:
    print "Coordination sequences for", label, "structure"
    term_table = crystal.coordination_sequences.simple(
      pair_asu_table=pairs.pair_asu_table,
      max_shell=10)
    crystal.coordination_sequences.show_terms(
      structure=structure,
      term_table=term_table)
    print
  icsd_f_calc = icsd_structure.structure_factors(
    d_min=1, algorithm="direct").f_calc()
  icsd_f_calc_in_p1 = icsd_f_calc.primitive_setting().expand_to_p1()
  p1_f_calc = icsd_f_calc_in_p1.structure_factors_from_scatterers(
    xray_structure=p1_structure, algorithm="direct").f_calc()
  for h,i,p in zip(icsd_f_calc_in_p1.indices(),
                   icsd_f_calc_in_p1.data(),
                   p1_f_calc.data()):
    print h, abs(i), abs(p)*3
  print "OK"
Example #9
0
def exercise_covariance():
  xs = xray.structure(
    crystal_symmetry=crystal.symmetry(
      (5.01,5.01,5.47,90,90,120), "P6222"),
    scatterers=flex.xray_scatterer([
      xray.scatterer("Si", (1/2.,1/2.,1/3.)),
      xray.scatterer("O", (0.197,-0.197,0.83333))]))
  uc = xs.unit_cell()
  flags = xs.scatterer_flags()
  for f in flags:
    f.set_grad_site(True)
  xs.set_scatterer_flags(flags)
  cov = flex.double((1e-8,1e-9,2e-9,3e-9,4e-9,5e-9,
                          2e-8,1e-9,2e-9,3e-9,4e-9,
                               3e-8,1e-9,2e-9,3e-9,
                                    2e-8,1e-9,2e-9,
                                         3e-8,1e-9,
                                              4e-8))
  param_map = xs.parameter_map()
  assert approx_equal(cov,
    covariance.extract_covariance_matrix_for_sites(flex.size_t([0,1]), cov, param_map))
  cov_cart = covariance.orthogonalize_covariance_matrix(cov, uc, param_map)
  O = matrix.sqr(uc.orthogonalization_matrix())
  for i in range(param_map.n_scatterers):
    cov_i = covariance.extract_covariance_matrix_for_sites(flex.size_t([i]), cov, param_map)
    cov_i_cart = covariance.extract_covariance_matrix_for_sites(flex.size_t([i]), cov_cart, param_map)
    assert approx_equal(
      O * matrix.sym(sym_mat3=cov_i) * O.transpose(),
      matrix.sym(sym_mat3=cov_i_cart).as_mat3())
  for f in flags: f.set_grads(False)
  flags[0].set_grad_u_aniso(True)
  flags[0].set_use_u_aniso(True)
  flags[1].set_grad_u_iso(True)
  flags[1].set_use_u_iso(True)
  xs.set_scatterer_flags(flags)
  param_map = xs.parameter_map()
  cov = flex.double(7*7, 0)
  cov.reshape(flex.grid(7,7))
  cov.matrix_diagonal_set_in_place(flex.double([i for i in range(7)]))
  cov = cov.matrix_symmetric_as_packed_u()
  assert approx_equal([i for i in range(6)],
                      covariance.extract_covariance_matrix_for_u_aniso(
                        0, cov, param_map).matrix_packed_u_diagonal())
  assert covariance.variance_for_u_iso(1, cov, param_map) == 6
  try: covariance.variance_for_u_iso(0, cov, param_map)
  except RuntimeError: pass
  else: raise Exception_expected
  try: covariance.extract_covariance_matrix_for_u_aniso(1, cov, param_map)
  except RuntimeError: pass
  else: raise Exception_expected
  approx_equal(covariance.extract_covariance_matrix_for_sites(
    flex.size_t([1]), cov, param_map), (0,0,0,0,0,0))
Example #10
0
 def add_new_solvent(self):
   if(self.params.b_iso is None):
     sol_sel = self.model.solvent_selection()
     xrs_mac_h = self.model.xray_structure.select(~sol_sel)
     hd_mac = self.model.xray_structure.hd_selection().select(~sol_sel)
     xrs_mac = xrs_mac_h.select(~hd_mac)
     b = xrs_mac.extract_u_iso_or_u_equiv() * math.pi**2*8
     b_solv = flex.mean_default(b, None)
     if(b_solv is not None and b_solv < self.params.b_iso_min or
        b_solv > self.params.b_iso_max):
       b_solv = (self.params.b_iso_min + self.params.b_iso_max) / 2.
   else:
     b_solv = self.params.b_iso
   if(self.params.new_solvent == "isotropic"):
     new_scatterers = flex.xray_scatterer(
       self.sites.size(),
       xray.scatterer(occupancy       = self.params.occupancy,
                      b               = b_solv,
                      scattering_type = self.params.scattering_type))
   elif(self.params.new_solvent == "anisotropic"):
     u_star = adptbx.u_iso_as_u_star(self.model.xray_structure.unit_cell(),
       adptbx.b_as_u(b_solv))
     new_scatterers = flex.xray_scatterer(
       self.sites.size(),
       xray.scatterer(
         occupancy       = self.params.occupancy,
         u               = u_star,
         scattering_type = self.params.scattering_type))
   else: raise RuntimeError
   new_scatterers.set_sites(self.sites)
   solvent_xray_structure = xray.structure(
     special_position_settings = self.model.xray_structure,
     scatterers                = new_scatterers)
   xrs_sol = self.model.xray_structure.select(self.model.solvent_selection())
   xrs_mac = self.model.xray_structure.select(~self.model.solvent_selection())
   xrs_sol = xrs_sol.concatenate(other = solvent_xray_structure)
   sol_sel = flex.bool(xrs_mac.scatterers().size(), False)
   sol_sel.extend( flex.bool(xrs_sol.scatterers().size(), True) )
   self.model.add_solvent(
     solvent_xray_structure = solvent_xray_structure,
     residue_name           = self.params.output_residue_name,
     atom_name              = self.params.output_atom_name,
     chain_id               = self.params.output_chain_id,
     refine_occupancies     = self.params.refine_occupancies,
     refine_adp             = self.params.new_solvent)
   self.fmodel.update_xray_structure(
     xray_structure = self.model.xray_structure,
     update_f_calc  = True)
Example #11
0
File: gid.py Project: isaxs/pynx
 def __init__(self,unitcell,spacegroup,scatterers):
   self.sg=sgtbx.space_group_info(spacegroup)
   self.uc=uctbx.unit_cell(unitcell)
   self.scatt=scatterers
   self.cctbx_scatterers=flex.xray_scatterer()
   for s in self.scatt:
     self.cctbx_scatterers.append(xray.scatterer(label=s.label,site=s.site,occupancy=s.occupancy,u=s.u_iso))
   try:
     #old cctbx version
     xray.add_scatterers_ext(unit_cell=self.uc,
                           space_group=self.sg.group(),
                           scatterers=self.cctbx_scatterers,
                           site_symmetry_table=sgtbx.site_symmetry_table(),
                           site_symmetry_table_for_new=sgtbx.site_symmetry_table(),
                           min_distance_sym_equiv=0.5,
                           u_star_tolerance=0,
                           assert_min_distance_sym_equiv=True)
   except:
     # cctbx version >= 2011_04_06_0217 
     #print "Whoops, cctbx version 2011"
     xray.add_scatterers_ext(unit_cell=self.uc,
                           space_group=self.sg.group(),
                           scatterers=self.cctbx_scatterers,
                           site_symmetry_table=sgtbx.site_symmetry_table(),
                           site_symmetry_table_for_new=sgtbx.site_symmetry_table(),
                           min_distance_sym_equiv=0.5,
                           u_star_tolerance=0,
                           assert_min_distance_sym_equiv=True,
                           non_unit_occupancy_implies_min_distance_sym_equiv_zero=False)
   cs=crystal.symmetry(self.uc,spacegroup)
   sp=crystal.special_position_settings(cs)
   self.structure=xray.structure(sp,self.cctbx_scatterers)
   self.structure_as_P1=self.structure.expand_to_p1()
Example #12
0
 def iass_as_xray_structure(self, iass):
    ias_xray_structure = xray.structure(
                    crystal_symmetry = self.xray_structure.crystal_symmetry())
    for ias in iass:
      assert ias.status is not None
      if(ias.status):
         if(self.params.use_map):
            site_cart = ias.peak_position_cart
            b_iso     = ias.b_iso
            q         = ias.q
         else:
            site_cart = ias.site_cart_predicted
            b_iso     = (ias.atom_1.b_iso + ias.atom_2.b_iso)*0.5
            q         = self.params.initial_ias_occupancy
         if(b_iso is None):
            b_iso = (ias.atom_1.b_iso + ias.atom_2.b_iso)*0.5
         if(q is None):
            q = self.params.initial_ias_occupancy
         if(site_cart is None):
            site_cart = ias.site_cart_predicted
         assert [b_iso, q].count(None) == 0
         if(site_cart is not None):
           ias_scatterer = xray.scatterer(
             label           = ias.name,
             scattering_type = ias.name,
             site = self.xray_structure.unit_cell().fractionalize(site_cart),
             u               = adptbx.b_as_u(b_iso),
             occupancy       = q)
           ias_xray_structure.add_scatterer(ias_scatterer)
    ias_xray_structure.scattering_type_registry(
                                            custom_dict = ias_scattering_dict)
    return ias_xray_structure
def exercise_trigonometric_ff():
    from math import cos, sin, pi

    sgi = sgtbx.space_group_info("P1")
    cs = sgi.any_compatible_crystal_symmetry(volume=1000)
    miller_set = miller.build_set(cs, anomalous_flag=False, d_min=1)
    miller_set = miller_set.select(flex.random_double(miller_set.size()) < 0.2)
    for i in xrange(5):
        sites = flex.random_double(9)
        x1, x2, x3 = (matrix.col(sites[:3]), matrix.col(sites[3:6]), matrix.col(sites[6:]))
        xs = xray.structure(crystal.special_position_settings(cs))
        for x in (x1, x2, x3):
            sc = xray.scatterer(site=x, scattering_type="const")
            sc.flags.set_grad_site(True)
            xs.add_scatterer(sc)
        f_sq = structure_factors.f_calc_modulus_squared(xs)
        for h in miller_set.indices():
            h = matrix.col(h)
            phi1, phi2, phi3 = 2 * pi * h.dot(x1), 2 * pi * h.dot(x2), 2 * pi * h.dot(x3)
            fc_mod_sq = 3 + 2 * (cos(phi1 - phi2) + cos(phi2 - phi3) + cos(phi3 - phi1))
            g = []
            g.extend(-2 * (sin(phi1 - phi2) - sin(phi3 - phi1)) * 2 * pi * h)
            g.extend(-2 * (sin(phi2 - phi3) - sin(phi1 - phi2)) * 2 * pi * h)
            g.extend(-2 * (sin(phi3 - phi1) - sin(phi2 - phi3)) * 2 * pi * h)
            grad_fc_mod_sq = g

            f_sq.linearise(h)
            assert approx_equal(f_sq.observable, fc_mod_sq)
            assert approx_equal(f_sq.grad_observable, grad_fc_mod_sq)
Example #14
0
 def iass_as_xray_structure(self, iass):
     ias_xray_structure = xray.structure(
         crystal_symmetry=self.xray_structure.crystal_symmetry())
     for ias in iass:
         assert ias.status is not None
         if (ias.status):
             if (self.params.use_map):
                 site_cart = ias.peak_position_cart
                 b_iso = ias.b_iso
                 q = ias.q
             else:
                 site_cart = ias.site_cart_predicted
                 b_iso = (ias.atom_1.b_iso + ias.atom_2.b_iso) * 0.5
                 q = self.params.initial_ias_occupancy
             if (b_iso is None):
                 b_iso = (ias.atom_1.b_iso + ias.atom_2.b_iso) * 0.5
             if (q is None):
                 q = self.params.initial_ias_occupancy
             if (site_cart is None):
                 site_cart = ias.site_cart_predicted
             assert [b_iso, q].count(None) == 0
             if (site_cart is not None):
                 ias_scatterer = xray.scatterer(
                     label=ias.name,
                     scattering_type=ias.name,
                     site=self.xray_structure.unit_cell().fractionalize(
                         site_cart),
                     u=adptbx.b_as_u(b_iso),
                     occupancy=q)
                 ias_xray_structure.add_scatterer(ias_scatterer)
     ias_xray_structure.scattering_type_registry(
         custom_dict=ias_scattering_dict)
     return ias_xray_structure
 def add_new_solvent(self):
   b_solv = self.params.b_iso
   new_scatterers = flex.xray_scatterer(
             self.sites.size(),
             xray.scatterer(occupancy       = self.params.occupancy,
             b                              = b_solv,
             scattering_type                = self.params.scattering_type,
             label                          = 'HOH'))
   new_scatterers.set_sites(self.sites)
   solvent_xray_structure = xray.structure(
     special_position_settings = self.model.xray_structure,
     scatterers                = new_scatterers)
   xrs_sol = self.model.xray_structure.select(self.model.solvent_selection())
   xrs_mac = self.model.xray_structure.select(~self.model.solvent_selection())
   xrs_sol = xrs_sol.concatenate(other = solvent_xray_structure)
   sol_sel = flex.bool(xrs_mac.scatterers().size(), False)
   sol_sel.extend( flex.bool(xrs_sol.scatterers().size(), True) )
   self.model.add_solvent(
           solvent_xray_structure = solvent_xray_structure,
           residue_name           = self.params.output_residue_name,
           atom_name              = self.params.output_atom_name,
           chain_id               = self.params.output_chain_id,
           refine_occupancies     = self.params.refine_occupancies,
           refine_adp             = self.params.new_solvent)
   self.fmodel.update_xray_structure(
     xray_structure = self.model.xray_structure,
     update_f_calc  = False)
def scatterer_from_list(l):
  if (len(l) == 7):
    return xray.scatterer(
      site=l[:3],
      u=l[3],
      occupancy=l[4],
      scattering_type="const",
      fp=l[5],
      fdp=l[6])
  return xray.scatterer(
    site=l[:3],
    u=l[3:9],
    occupancy=l[9],
    scattering_type="const",
    fp=l[10],
    fdp=l[11])
Example #17
0
  def extract_structure(self, phase_nr=1):
    """This method tries to extract the crystal structure from the parsed pcrfile.

    :returns: the extracted structure
    :rtype: cctbx.xray.structure
    """
    from cctbx import xray
    from cctbx import crystal
    from cctbx.array_family import flex
    p = self.cfg['phases'][str(phase_nr)]
    atoms = p['atoms']
    unit_cell = [ p['a'], p['b'], p['c'], p['alpha'], p['beta'], p['gamma'] ]
    special_position_settings=crystal.special_position_settings(
              crystal_symmetry=crystal.symmetry(
                    unit_cell=unit_cell,
                    space_group_symbol=p['SYMB']))
    scatterers = []
    for k, a in atoms.iteritems():
      scatterers.append(xray.scatterer(label=a['LABEL'],
                                       scattering_type=a['NTYP'],
                                       site=(a['X'], a['Y'], a['Z']),
                                       b=a['B']))
    scatterers_flex=flex.xray_scatterer(scatterers)
    structure = xray.structure(special_position_settings=special_position_settings,
                               scatterers=scatterers_flex)
    return structure.as_py_code()
def exercise_symmetry_equivalent():
  xs = xray.structure(
    crystal_symmetry=crystal.symmetry(
      unit_cell=(1, 2, 3),
      space_group_symbol='hall: P 2x'),
    scatterers=flex.xray_scatterer((
      xray.scatterer("C", site=(0.1, 0.2, 0.3)),
    )))
  xs.scatterers()[0].flags.set_grad_site(True)
  connectivity_table = smtbx.utils.connectivity_table(xs)
  reparametrisation = constraints.reparametrisation(
    xs, [], connectivity_table)
  site_0 = reparametrisation.add(constraints.independent_site_parameter,
                                 scatterer=xs.scatterers()[0])
  g = sgtbx.rt_mx('x,-y,-z')
  symm_eq = reparametrisation.add(
    constraints.symmetry_equivalent_site_parameter,
    site=site_0, motion=g)
  reparametrisation.finalise()

  assert approx_equal(symm_eq.original.scatterers[0].site, (0.1, 0.2, 0.3),
                      eps=1e-15)
  assert str(symm_eq.motion) == 'x,-y,-z'
  assert symm_eq.is_variable
  reparametrisation.linearise()
  assert approx_equal(symm_eq.value, g*site_0.value, eps=1e-15)

  reparametrisation.store()
  assert approx_equal(symm_eq.value, (0.1, -0.2, -0.3), eps=1e-15)
  assert approx_equal(site_0.value, (0.1, 0.2, 0.3), eps=1e-15)
Example #19
0
def read_scatterer(flds, default_b_iso=3.0):
    scatterer = xray.scatterer(scattering_type="const")
    # Label [ScatFact] x y z [Occ [Biso]]
    try:
        scatterer.label = flds[0]
        try:
            float(flds[1])
        except Exception:
            offs = 2
            scatterer.scattering_type = eltbx.xray_scattering.get_standard_label(label=flds[1], exact=True)
        else:
            offs = 1
            scatterer.scattering_type = eltbx.xray_scattering.get_standard_label(label=flds[0], exact=False)
        site = flds[offs : offs + 3]
        for i in xrange(3):
            site[i] = float(site[i])
        scatterer.site = site
        scatterer.occupancy = 1.0
        scatterer.set_use_u_iso_only()
        scatterer.u_iso = adptbx.b_as_u(default_b_iso)
        if len(flds) >= offs + 4:
            scatterer.occupancy = float(flds[offs + 3])
            if len(flds) == offs + 5:
                scatterer.u_iso = adptbx.b_as_u(float(flds[offs + 4]))
            else:
                assert len(flds) < offs + 5
    except Exception:
        raise cgi_utils.FormatError, flds
    return scatterer
Example #20
0
    def __init__(self,
                 space_group=SpaceGroup('P 1'),
                 lattice=Lattice(1.0, 1.0, 1.0, 90.0, 90.0, 90.0),
                 sites=[]):
        """
        Crystal object.
        Functions as a wrapper to a cctbx xray.structure object,
        but adds additional variables and functionality.
        Core object of this package.
        
        Input:
            SpaceGroup  space_group                            space group for the current crystal
            List of Site objects  sites                        List of Site objects.
        
        Warning:
            'crystal_structure' must be given,
            or 'space_group', 'lattice', and 'sites' must be given,
            or creation of the crystal will fail.
        """

        try:
            crystal_symmetry = crystal.symmetry(
                unit_cell=str(lattice),
                space_group_symbol=space_group.cctbx_name)
        except Exception as e:
            raise SymmetryError(
                "SpaceGroup {s} is incompatible with Lattice -> {l} cctbx error {e}"
                .format(l=str(lattice), s=SpaceGroup.cctbx_name, e=e))

        scatterers = flex.xray_scatterer()
        for i, site in enumerate(sites):
            # the element name can be pulled from scatterer via the s.element_symbol() method (if it's an element!!!)
            # example: 'atom-b-12',or 'vacancy-c-3'
            # we need to set the scattering_type so we can freely use the label to store metadata

            #scattering_type = something
            #scatterers.append(xray.scatterer(label=atom.name, site=tuple(atom.abc), occupancy=atom.occupancy), scattering_type=atom.name)

            #Method #2
            # explicitly add metadata to _meta
            st_temp, dash, num = site.label.partition("-")
            if dash == "-":
                k = site.label
            else:
                k = "-".join([site.label, str(i)])

            # problems here not sure what's up
            k = str(k)
            # print "label = ", k, ' type of label = ', type(k)
            # print "site = ", tuple(site.abc)
            # print "occupancy = ", site.occupancy
            scatterers.append(
                xray.scatterer(label=k,
                               site=tuple(site.abc),
                               occupancy=site.occupancy))

        # Test for coherency of Lattice and SpaceGroup
        self.crystal_structure = xray.structure(
            crystal_symmetry=crystal_symmetry, scatterers=scatterers)
def get_xrs():
  crystal_symmetry = crystal.symmetry(
    unit_cell=(10,10,10,90,90,90),
    space_group_symbol="P 1")
  return xray.structure(
    crystal_symmetry=crystal_symmetry,
    scatterers=flex.xray_scatterer([
      xray.scatterer(label="C", site=(0,0,0))]))
Example #22
0
def scatterer_from_list(l):
  return xray.scatterer(
    site=l[:3],
    u=l[3],
    occupancy=l[4],
    scattering_type="const",
    fp=l[5],
    fdp=l[6])
Example #23
0
def exercise_2():
  symmetry = crystal.symmetry(
    unit_cell=(5.67, 10.37, 10.37, 90, 135.49, 90),
    space_group_symbol="C2")
  structure = xray.structure(crystal_symmetry=symmetry)
  atmrad = flex.double()
  xyzf = flex.vec3_double()
  for k in xrange(100):
    scatterer = xray.scatterer(
      site = ((1.+k*abs(math.sin(k)))/1000.0,
              (1.+k*abs(math.cos(k)))/1000.0,
              (1.+ k)/1000.0),
      scattering_type = "C")
    structure.add_scatterer(scatterer)
    atmrad.append(van_der_waals_radii.vdw.table[scatterer.element_symbol()])
    xyzf.append(scatterer.site)
  miller_set = miller.build_set(
    crystal_symmetry=structure,
    d_min=1.0,
    anomalous_flag=False)
  step = 0.5
  crystal_gridding = maptbx.crystal_gridding(
    unit_cell=structure.unit_cell(),
    step=step)
  nxyz = crystal_gridding.n_real()
  shrink_truncation_radius = 1.0
  solvent_radius = 1.0
  m1 = around_atoms(
    structure.unit_cell(),
    structure.space_group().order_z(),
    structure.sites_frac(),
    atmrad,
    nxyz,
    solvent_radius,
    shrink_truncation_radius)
  assert m1.solvent_radius == 1
  assert m1.shrink_truncation_radius == 1
  assert flex.max(m1.data) == 1
  assert flex.min(m1.data) == 0
  assert m1.data.size() == m1.data.count(1) + m1.data.count(0)
  m2 = mmtbx.masks.bulk_solvent(
    xray_structure=structure,
    gridding_n_real=nxyz,
    ignore_zero_occupancy_atoms = False,
    solvent_radius=solvent_radius,
    shrink_truncation_radius=shrink_truncation_radius)
  assert m2.data.all_eq(m1.data)
  m3 = mmtbx.masks.bulk_solvent(
    xray_structure=structure,
    grid_step=step,
    ignore_zero_occupancy_atoms = False,
    solvent_radius=solvent_radius,
    shrink_truncation_radius=shrink_truncation_radius)
  assert m3.data.all_eq(m1.data)
  f_mask2 = m2.structure_factors(miller_set=miller_set)
  f_mask3 = m3.structure_factors(miller_set=miller_set)
  assert approx_equal(f_mask2.data(), f_mask3.data())
  assert approx_equal(flex.sum(flex.abs(f_mask3.data())), 1095.17999134)
Example #24
0
def run():
  quartz_structure = xray.structure(
    special_position_settings=crystal.special_position_settings(
      crystal_symmetry=crystal.symmetry(
        unit_cell=(5.01,5.01,5.47,90,90,120),
        space_group_symbol="P6222")),
    scatterers=flex.xray_scatterer([
      xray.scatterer(
        label="Si",
        site=(1/2.,1/2.,1/3.),
        u=0.2),
      xray.scatterer(
        label="O",
        site=(0.197,-0.197,0.83333),
        u=0)]))

  quartz_structure.show_summary().show_scatterers()

  from libtbx import easy_pickle
  easy_pickle.dump("beach", quartz_structure)

  from libtbx import easy_pickle
  quartz_structure = easy_pickle.load("beach")

  for scatterer in quartz_structure.scatterers():
    print("%s:" % scatterer.label, "%8.4f %8.4f %8.4f" % scatterer.site)
    site_symmetry = quartz_structure.site_symmetry(scatterer.site)
    print("  point group type:", site_symmetry.point_group_type())
    print("  special position operator:", site_symmetry.special_op_simplified())

  for table in ["xray", "electron"]:
    print("Scattering type table:", table)

    reg = quartz_structure.scattering_type_registry(table=table)
    reg.show_summary()

    f_calc = quartz_structure.structure_factors(d_min=2).f_calc()
    f_calc.show_summary().show_array()

    f_calc.d_spacings().show_array()

    low_resolution_only = f_calc.select(f_calc.d_spacings().data() > 2.5)
    low_resolution_only.show_array()

    print()
def run():
  quartz_structure = xray.structure(
    special_position_settings=crystal.special_position_settings(
      crystal_symmetry=crystal.symmetry(
        unit_cell=(5.01,5.01,5.47,90,90,120),
        space_group_symbol="P6222")),
    scatterers=flex.xray_scatterer([
      xray.scatterer(
        label="Si",
        site=(1/2.,1/2.,1/3.),
        u=0.2),
      xray.scatterer(
        label="O",
        site=(0.197,-0.197,0.83333),
        u=0)]))

  quartz_structure.show_summary().show_scatterers()

  from libtbx import easy_pickle
  easy_pickle.dump("beach", quartz_structure)

  from libtbx import easy_pickle
  quartz_structure = easy_pickle.load("beach")

  for scatterer in quartz_structure.scatterers():
    print "%s:" % scatterer.label, "%8.4f %8.4f %8.4f" % scatterer.site
    site_symmetry = quartz_structure.site_symmetry(scatterer.site)
    print "  point group type:", site_symmetry.point_group_type()
    print "  special position operator:", site_symmetry.special_op_simplified()

  for table in ["xray", "electron"]:
    print "Scattering type table:", table

    reg = quartz_structure.scattering_type_registry(table=table)
    reg.show_summary()

    f_calc = quartz_structure.structure_factors(d_min=2).f_calc()
    f_calc.show_summary().show_array()

    f_calc.d_spacings().show_array()

    low_resolution_only = f_calc.select(f_calc.d_spacings().data() > 2.5)
    low_resolution_only.show_array()

    print
    def get_transformed_model2(self,
                               output_pdb=None,
                               scattering_type="SE",
                               f=sys.stdout,
                               return_superposed_model2=True,
                               template_pdb_inp=None):
        # tt 2013-01-25; 2016-10-31
        from cctbx import xray
        xray_scatterer = xray.scatterer(scattering_type=scattering_type)
        model2 = self.ref_model2.as_xray_structure(xray_scatterer)
        from cctbx.array_family import flex
        new_coords = flex.vec3_double()
        for i_model2 in range(self.ref_model2.size()):
            c2 = matrix.col(self.eucl_symop * self.ref_model2[i_model2].site)
            c2 += self.adjusted_shift
            c2 = inside_zero_one(c2)
            new_coords.append(c2)
        model2.set_sites_frac(new_coords)

        if output_pdb is not None:
            assert template_pdb_inp is not None
            # Set up new xrs with these sites and with scattering types, occ, b,
            #   labels from original 2nd model
            xrs = xray.structure(model2.xray_structure())
            assert len(model2.scatterers()) == len(template_pdb_inp.atoms())
            b_iso_values = flex.double()
            for scatterer, atom in zip(model2.scatterers(),
                                       template_pdb_inp.atoms()):
                b_iso_values.append(atom.b)
                new_scatterer = xray.scatterer(scattering_type=atom.element,
                                               label=atom.name,
                                               occupancy=atom.occ,
                                               site=scatterer.site)
                xrs.add_scatterer(new_scatterer)
            xrs.set_b_iso(values=b_iso_values)
            pdb_string = xrs.as_pdb_file()
            ff = open(output_pdb, 'w')
            print(pdb_string, file=ff)
            ff.close()
            print("\nWrote model 2 mapped to model 1 to file %s " %
                  (output_pdb),
                  file=f)

        if return_superposed_model2:
            return model2.as_emma_model()
Example #27
0
def exercise_real_space_refinement(verbose):
    if (verbose):
        out = sys.stdout
    else:
        out = StringIO()
    out_of_bounds_clamp = maptbx.out_of_bounds_clamp(0)
    out_of_bounds_raise = maptbx.out_of_bounds_raise()
    crystal_symmetry = crystal.symmetry(unit_cell=(10, 10, 10, 90, 90, 90),
                                        space_group_symbol="P 1")
    xray_structure = xray.structure(crystal_symmetry=crystal_symmetry,
                                    scatterers=flex.xray_scatterer([
                                        xray.scatterer(label="C",
                                                       site=(0, 0, 0))
                                    ]))
    miller_set = miller.build_set(crystal_symmetry=crystal_symmetry,
                                  anomalous_flag=False,
                                  d_min=1)
    f_calc = miller_set.structure_factors_from_scatterers(
        xray_structure=xray_structure).f_calc()
    fft_map = f_calc.fft_map()
    fft_map.apply_sigma_scaling()
    real_map = fft_map.real_map_unpadded()
    #### unit_cell test
    delta_h = .005
    basic_map = maptbx.basic_map(
        maptbx.basic_map_unit_cell_flag(), real_map, real_map.focus(),
        crystal_symmetry.unit_cell().orthogonalization_matrix(),
        out_of_bounds_clamp.as_handle(), crystal_symmetry.unit_cell())
    testing_function_for_rsfit(basic_map, delta_h, xray_structure, out)
    ### non_symmetric test
    #
    minfrac = crystal_symmetry.unit_cell().fractionalize((-5, -5, -5))
    maxfrac = crystal_symmetry.unit_cell().fractionalize((5, 5, 5))
    gridding_first = [ifloor(n * b) for n, b in zip(fft_map.n_real(), minfrac)]
    gridding_last = [iceil(n * b) for n, b in zip(fft_map.n_real(), maxfrac)]
    data = maptbx.copy(real_map, gridding_first, gridding_last)
    #
    basic_map = maptbx.basic_map(
        maptbx.basic_map_non_symmetric_flag(), data, fft_map.n_real(),
        crystal_symmetry.unit_cell().orthogonalization_matrix(),
        out_of_bounds_clamp.as_handle(), crystal_symmetry.unit_cell())
    testing_function_for_rsfit(basic_map, delta_h, xray_structure, out)
    ### asu test
    #
    minfrac = crystal_symmetry.unit_cell().fractionalize((0, 0, 0))
    maxfrac = crystal_symmetry.unit_cell().fractionalize((10, 10, 10))
    gridding_first = [ifloor(n * b) for n, b in zip(fft_map.n_real(), minfrac)]
    gridding_last = [iceil(n * b) for n, b in zip(fft_map.n_real(), maxfrac)]
    data = maptbx.copy(real_map, gridding_first, gridding_last)
    #
    basic_map = maptbx.basic_map(
        maptbx.basic_map_asu_flag(), data, crystal_symmetry.space_group(),
        crystal_symmetry.direct_space_asu().as_float_asu(), real_map.focus(),
        crystal_symmetry.unit_cell().orthogonalization_matrix(),
        out_of_bounds_clamp.as_handle(), crystal_symmetry.unit_cell(), 0.5,
        True)
    testing_function_for_rsfit(basic_map, delta_h, xray_structure, out)
Example #28
0
def test_direction():
    from cctbx.array_family import flex
    from cctbx import uctbx, xray, crystal
    from smtbx.refinement import constraints
    from scitbx.matrix import col, row
    from libtbx.test_utils import approx_equal

    uc = uctbx.unit_cell((1, 2, 3))
    xs = xray.structure(crystal_symmetry=crystal.symmetry(
        unit_cell=uc, space_group_symbol='hall: P 2x 2y'),
                        scatterers=flex.xray_scatterer((
                            xray.scatterer('C0', site=(0, 0, 0)),
                            xray.scatterer('C1', site=(0, 2, 0)),
                            xray.scatterer('C2', site=(1, 1, 0)),
                            xray.scatterer('C3', site=(3, 1, 0)),
                        )))
    r = constraints.ext.reparametrisation(xs.unit_cell())
    sc = xs.scatterers()
    site_0 = r.add(constraints.independent_site_parameter, sc[0])
    site_1 = r.add(constraints.independent_site_parameter, sc[1])
    site_2 = r.add(constraints.independent_site_parameter, sc[2])
    site_3 = r.add(constraints.independent_site_parameter, sc[3])
    d = constraints.vector_direction((site_0, site_1, site_2)).direction(uc)
    sd = constraints.static_direction.calc_best_line(uc,
                                                     (site_0, site_1, site_2))
    assert approx_equal(d, sd, eps=1e-15)

    d = constraints.vector_direction((site_0, site_1)).direction(uc)
    assert approx_equal(
        d,
        row(uc.orthogonalize(col(sc[1].site) - col(sc[0].site))).normalize(),
        eps=1e-15)

    n = constraints.static_direction.calc_best_plane_normal(
        uc, (site_0, site_1, site_2))

    n1 = constraints.static_direction.calc_best_plane_normal(
        uc, (site_0, site_1, site_2, site_3))

    v01 = uc.orthogonalize(col(sc[0].site) - col(sc[1].site))
    v21 = uc.orthogonalize(col(sc[2].site) - col(sc[1].site))
    nc = row(v01).cross(row(v21)).normalize()
    assert approx_equal(n, n1, eps=1e-15)
    assert approx_equal(n, nc, eps=1e-15)
def exercise_u_iso_proportional_to_pivot_u_eq():
    xs = xray.structure(crystal_symmetry=crystal.symmetry(
        unit_cell=(), space_group_symbol='hall: P 2x 2y'),
                        scatterers=flex.xray_scatterer((
                            xray.scatterer('C0', u=(1, 1, 1, 0, 0, 0)),
                            xray.scatterer('C1'),
                            xray.scatterer('C2',
                                           site=(0.1, 0.2, 0.3),
                                           u=(1, 2, 3, 0, 0, 0)),
                            xray.scatterer('C3'),
                        )))
    r = constraints.ext.reparametrisation(xs.unit_cell())
    sc = xs.scatterers()
    sc[0].flags.set_grad_u_aniso(True)
    sc[2].flags.set_grad_u_aniso(True)

    u_0 = r.add(constraints.special_position_u_star_parameter,
                site_symmetry=xs.site_symmetry_table().get(0),
                scatterer=sc[0])
    u_iso_1 = r.add(constraints.u_iso_proportional_to_pivot_u_eq,
                    pivot_u=u_0,
                    multiplier=3,
                    scatterer=sc[1])
    u_2 = r.add(constraints.independent_u_star_parameter, sc[2])
    u_iso_3 = r.add(constraints.u_iso_proportional_to_pivot_u_eq,
                    pivot_u=u_2,
                    multiplier=2,
                    scatterer=sc[3])
    r.finalise()
    m = 3 + 6
    n = m + 6 + 1 + 1
    r.linearise()
    assert approx_equal(u_iso_1.value, 3, eps=1e-15)
    assert approx_equal(u_iso_3.value, 4, eps=1e-15)
    jt0 = sparse.matrix(m, n)
    for i in xrange(m):
        jt0[i, i] = 1
    p, q = u_0.argument(0).index, u_0.index
    jt0[p, q] = jt0[p + 1, q + 1] = jt0[p + 2, q + 2] = 1
    q = u_iso_1.index
    jt0[p, q] = jt0[p + 1, q] = jt0[p + 2, q] = 1
    p, q = u_2.index, u_iso_3.index
    jt0[p, q] = jt0[p + 1, q] = jt0[p + 2, q] = 2 / 3
    assert sparse.approx_equal(tolerance=1e-15)(r.jacobian_transpose, jt0)
 def __init__(self, staggered, verbose=False):
     self.staggered = staggered
     self.verbose = verbose
     self.cs = crystal.symmetry(uctbx.unit_cell((1, 1, 2, 90, 90, 80)),
                                "hall: P 2z")
     self.o = xray.scatterer('O', site=(0, 0, 0))
     self.o.flags.set_grad_site(True)
     self.c1 = xray.scatterer('C1', site=(1.5, 0, 0))
     self.c2 = xray.scatterer('C2', site=(2.5, 1, 0))
     self.h = xray.scatterer('H')
     self.reparam = constraints.ext.reparametrisation(self.cs.unit_cell())
     xo = self.reparam.add(constraints.independent_site_parameter, self.o)
     x1 = self.reparam.add(constraints.independent_site_parameter, self.c1)
     x2 = self.reparam.add(constraints.independent_site_parameter, self.c2)
     l = self.reparam.add(constraints.independent_scalar_parameter,
                          value=self.bond_length,
                          variable=False)
     phi = self.reparam.add(constraints.independent_scalar_parameter,
                            value=0,
                            variable=False)
     uc = self.cs.unit_cell()
     _ = mat.col
     if staggered:
         xh = self.reparam.add(
             constraints.staggered_terminal_tetrahedral_xh_site,
             pivot=xo,
             pivot_neighbour=x1,
             stagger_on=x2,
             length=l,
             hydrogen=(self.h, ))
     else:
         xh = self.reparam.add(constraints.terminal_tetrahedral_xh_site,
                               pivot=xo,
                               pivot_neighbour=x1,
                               azimuth=phi,
                               length=l,
                               e_zero_azimuth=uc.orthogonalize(
                                   _(self.c2.site) - _(self.c1.site)),
                               hydrogen=(self.h, ))
     self.reparam.finalise()
     self.xh, self.xo, self.x1, self.x2 = [
         x.index for x in (xh, xo, x1, x2)
     ]
     self.l, self.phi = l.index, phi.index
 def as_xray_structure(self, scatterer=None):
     from cctbx import xray
     if (scatterer is None):
         scatterer = xray.scatterer(scattering_type="const")
     result = xray.structure(special_position_settings=self)
     for position in self.positions():
         result.add_scatterer(
             scatterer.customized_copy(label=position.label,
                                       site=position.site))
     return result
def exercise_u_iso_proportional_to_pivot_u_eq():
  xs = xray.structure(
    crystal_symmetry=crystal.symmetry(
      unit_cell=(),
      space_group_symbol='hall: P 2x 2y'),
    scatterers=flex.xray_scatterer((
      xray.scatterer('C0', u=(1, 1, 1, 0, 0, 0)),
      xray.scatterer('C1'),
      xray.scatterer('C2', site=(0.1, 0.2, 0.3), u=(1, 2, 3, 0, 0, 0)),
      xray.scatterer('C3'),
      )))
  r = constraints.ext.reparametrisation(xs.unit_cell())
  sc = xs.scatterers()
  sc[0].flags.set_grad_u_aniso(True)
  sc[2].flags.set_grad_u_aniso(True)

  u_0 = r.add(constraints.special_position_u_star_parameter,
              site_symmetry=xs.site_symmetry_table().get(0),
              scatterer=sc[0])
  u_iso_1 = r.add(constraints.u_iso_proportional_to_pivot_u_eq,
                pivot_u=u_0,
                multiplier=3,
                scatterer=sc[1])
  u_2 = r.add(constraints.independent_u_star_parameter, sc[2])
  u_iso_3 = r.add(constraints.u_iso_proportional_to_pivot_u_eq,
                pivot_u=u_2,
                multiplier=2,
                scatterer=sc[3])
  r.finalise()
  m = 3 + 6
  n = m + 6 + 1 + 1
  r.linearise()
  assert approx_equal(u_iso_1.value, 3, eps=1e-15)
  assert approx_equal(u_iso_3.value, 4, eps=1e-15)
  jt0 = sparse.matrix(m, n)
  for i in xrange(m): jt0[i, i] = 1
  p, q = u_0.argument(0).index, u_0.index
  jt0[p, q] = jt0[p+1, q+1] = jt0[p+2, q+2] = 1
  q = u_iso_1.index
  jt0[p, q] = jt0[p+1, q] = jt0[p+2, q] = 1
  p, q = u_2.index, u_iso_3.index
  jt0[p, q] = jt0[p+1, q] = jt0[p+2, q] = 2/3
  assert sparse.approx_equal(tolerance=1e-15)(r.jacobian_transpose, jt0)
 def as_xray_structure(self, scatterer=None):
   from cctbx import xray
   if (scatterer is None):
     scatterer = xray.scatterer(scattering_type="const")
   result = xray.structure(special_position_settings=self)
   for position in self.positions():
     result.add_scatterer(scatterer.customized_copy(
       label=position.label,
       site=position.site))
   return result
Example #34
0
def exercise_lbfgs(test_case, use_geo, out, d_min=2):
    sites_cart, geo_manager = cctbx.geometry_restraints.manager.\
      construct_non_crystallographic_conserving_bonds_and_angles(
        sites_cart=flex.vec3_double(test_case.sites),
        edge_list_bonds=test_case.bonds,
        edge_list_angles=test_case.angles())
    scatterers = flex.xray_scatterer(sites_cart.size(),
                                     xray.scatterer(scattering_type="C", b=20))
    for sc, lbl in zip(scatterers, test_case.labels):
        sc.label = lbl
    structure = xray.structure(crystal_symmetry=geo_manager.crystal_symmetry,
                               scatterers=scatterers)
    structure.set_sites_cart(sites_cart=sites_cart)
    f_calc = structure.structure_factors(d_min=d_min,
                                         anomalous_flag=False).f_calc()
    fft_map = f_calc.fft_map()
    fft_map.apply_sigma_scaling()
    if (use_geo):
        axis = matrix.col(flex.random_double_point_on_sphere())
        rot = scitbx.math.r3_rotation_axis_and_angle_as_matrix(axis=axis,
                                                               angle=25,
                                                               deg=True)
        trans = matrix.col(flex.random_double_point_on_sphere()) * 1.0
        structure.apply_rigid_body_shift(rot=rot, trans=trans)
        geo_manager.energies_sites(sites_cart=structure.sites_cart()).show(
            f=out)
        minimized = real_space_refinement_simple.lbfgs(
            sites_cart=structure.sites_cart(),
            density_map=fft_map.real_map(),
            geometry_restraints_manager=geo_manager,
            gradients_method="fd",
            real_space_target_weight=1,
            real_space_gradients_delta=d_min / 3)
        geo_manager.energies_sites(sites_cart=minimized.sites_cart).show(f=out)
    else:
        minimized = real_space_refinement_simple.lbfgs(
            sites_cart=structure.sites_cart(),
            density_map=fft_map.real_map(),
            unit_cell=structure.unit_cell(),
            gradients_method="fd",
            real_space_gradients_delta=d_min / 3)
    rmsd_start = sites_cart.rms_difference(structure.sites_cart())
    rmsd_final = sites_cart.rms_difference(minimized.sites_cart)
    print("RMSD start, final:", rmsd_start, rmsd_final, file=out)
    if (use_geo):
        assert rmsd_start >= 1 - 1e-6
        assert rmsd_final < 0.2

    def show_f_g(label, f, g):
        print(label, "f, |g|:", f, flex.mean_sq(g)**0.5, file=out)

    show_f_g(label="start", f=minimized.f_start, g=minimized.g_start)
    show_f_g(label="final", f=minimized.f_final, g=minimized.g_final)
    assert minimized.f_final <= minimized.f_start
    return minimized
Example #35
0
def quartz_p1(metrical_matrix=None):
  if metrical_matrix is not None:
    unit_cell = uctbx.unit_cell(metrical_matrix=metrical_matrix)
  else:
    unit_cell = uctbx.unit_cell(parameters=(5.01,5.01,5.47,90,90,120))
  return xray.structure(
    crystal_symmetry=crystal.symmetry(
    unit_cell=unit_cell,
    space_group_symbol='hall:  P 1'),
    scatterers=flex.xray_scatterer((
      xray.scatterer( #0
        label='Si',
        site=(0.500000, 0.500000, 0.333333),
        u=0.000000),
      xray.scatterer( #1
        label='Si',
        site=(0.000000, 0.500000, 0.666667),
        u=0.000000),
      xray.scatterer( #2
        label='Si',
        site=(0.500000, 0.000000, 0.000000),
        u=0.000000),
      xray.scatterer( #3
        label='O',
        site=(0.197000, 0.803000, 0.833333),
        u=0.000000),
      xray.scatterer( #4
        label='O',
        site=(0.394000, 0.197000, 0.166667),
        u=0.000000),
      xray.scatterer( #5
        label='O',
        site=(0.803000, 0.606000, 0.500000),
        u=0.000000),
      xray.scatterer( #6
        label='O',
        site=(0.197000, 0.394000, 0.500000),
        u=0.000000),
      xray.scatterer( #7
        label='O',
        site=(0.606000, 0.803000, 0.166667),
        u=0.000000),
      xray.scatterer( #8
        label='O',
        site=(0.803000, 0.197000, 0.833333),
        u=0.000000)
        )))
def exercise_u_iso_proportional_to_pivot_u_iso():
  # Test working constraint
  xs = xray.structure(
    crystal_symmetry=crystal.symmetry(
      unit_cell=(),
      space_group_symbol='hall: P 2x 2y'),
    scatterers=flex.xray_scatterer((
      xray.scatterer('C0', u=0.12),
      xray.scatterer('C1'),
      )))
  r = constraints.ext.reparametrisation(xs.unit_cell())
  sc = xs.scatterers()

  u_iso = r.add(constraints.independent_u_iso_parameter, sc[0])
  u_iso_1 = r.add(constraints.u_iso_proportional_to_pivot_u_iso,
                pivot_u_iso=u_iso,
                multiplier=2,
                scatterer=sc[1])
  r.finalise()
  r.linearise()
  assert approx_equal(u_iso_1.value, 0.24, eps=1e-15)

  # Test conflicting constraints
  xs = xray.structure(
    crystal_symmetry=crystal.symmetry(
      unit_cell=(),
      space_group_symbol='hall: P 2x 2y'),
    scatterers=flex.xray_scatterer((
      xray.scatterer('C0', u=0.12),
      xray.scatterer('C1', u=0.21),
      xray.scatterer('C2')
    )))
  with warnings.catch_warnings(record=True) as w:
    warnings.simplefilter("always")
    r = constraints.reparametrisation(
      structure=xs,
      constraints=[constraints.adp.shared_u((0, 2)),
                   constraints.adp.shared_u((1, 2))],
      connectivity_table=smtbx.utils.connectivity_table(xs))
    assert len(w) == 1
    assert w[-1].category == constraints.ConflictingConstraintWarning
    assert w[-1].message.conflicts == set(((2, 'U'),))
def pdb_atoms_as_xray_structure(pdb_atoms, crystal_symmetry):
    xray_structure = xray.structure(crystal_symmetry=crystal_symmetry)
    unit_cell = xray_structure.unit_cell()
    for atom in pdb_atoms:
        scatterer = xray.scatterer(label=atom.name,
                                   site=unit_cell.fractionalize(atom.xyz),
                                   b=atom.b,
                                   occupancy=atom.occ,
                                   scattering_type=atom.element)
        xray_structure.add_scatterer(scatterer)
    return xray_structure
 def debug_write_reciprocal_lattice_points_as_pdb(self,
                             file_name='reciprocal_lattice.pdb'):
   from cctbx import crystal, xray
   cs = crystal.symmetry(unit_cell=(1000,1000,1000,90,90,90),
                         space_group="P1")
   xs = xray.structure(crystal_symmetry=cs)
   for site in self.trial_sites:
     xs.add_scatterer(xray.scatterer("C", site=site))
   xs.sites_mod_short()
   with open(file_name, 'wb') as f:
     print >> f, xs.as_pdb_file()
Example #39
0
def tst_pdb_output():
  print("Testing pdb-output option")
  xray_scatterer = xray.scatterer( scattering_type = 'SE')
  for sg,target_list in zip(
     ['p1','p43212'],
     [
        [target_p1,target_p1_inverse,target_p1_partial,
           target_p1_inverse_partial],
        [target_p43212,target_p43212_inverse,target_p43212_half,
           target_p43212_inverse_half]
     ]
     ):
    print("Testing group of targets in %s" %(sg))
    for t1 in target_list:
      e1=get_emma_model_from_pdb(pdb_records=t1)
      for t2 in target_list:
        e2=get_emma_model_from_pdb(pdb_records=t2)
        match_list=e1.best_superpositions_on_other(
          e2)
        match=match_list[0]
        assert match
        offset_e2=match.get_transformed_model2()

        # make sure that offset_i2 is pretty much the same as e1 now.
        new_match_list=e1.best_superpositions_on_other(
          offset_e2)
        new_match=new_match_list[0]
        assert new_match
        assert approx_equal(new_match.rms,0.,eps=0.01)
        assert len(new_match.pairs)==12
        assert approx_equal(
           new_match.rt.r,matrix.sqr((1, 0, 0, 0, 1, 0, 0, 0, 1)))
        assert approx_equal(new_match.rt.t.transpose(),matrix.col((0, 0, 0)))

  print("Testing pdb-output option with different-sized entries")
  e1=get_emma_model_from_pdb(pdb_records=pdb6)
  e2=get_emma_model_from_pdb(pdb_records=pdb5)
  pdb_inp_e2=iotbx.pdb.input(source_info=None, lines=pdb5)

  match_list=e1.best_superpositions_on_other(e2)
  match=match_list[0]
  assert match
  output_pdb="output.pdb"
  offset_e2=match.get_transformed_model2(output_pdb=output_pdb,
    template_pdb_inp=pdb_inp_e2)
  with open(output_pdb) as f:
    offset_e2_text_lines=f.readlines()
  for o,e in zip(offset_e2_text_lines, pdb5_out.splitlines()):
     o=o.strip()
     e=e.strip()
     if o != e:
       print(o)
       print(e)
       assert o==e
  def get_transformed_model2(self,output_pdb=None,
    scattering_type="SE",f=sys.stdout,
    return_superposed_model2=True,template_pdb_inp=None):
      # tt 2013-01-25; 2016-10-31
      from cctbx import xray
      xray_scatterer = xray.scatterer( scattering_type = scattering_type)
      model2=self.ref_model2.as_xray_structure(xray_scatterer)
      from cctbx.array_family import flex
      new_coords=flex.vec3_double()
      for i_model2 in xrange(self.ref_model2.size()):
        c2 = matrix.col(self.eucl_symop * self.ref_model2[i_model2].site)
        c2 += self.adjusted_shift
        c2=inside_zero_one(c2)
        new_coords.append(c2)
      model2.set_sites_frac(new_coords)


      if output_pdb is not None:
        assert template_pdb_inp is not None
        # Set up new xrs with these sites and with scattering types, occ, b,
        #   labels from original 2nd model
        xrs=xray.structure(model2.xray_structure())
        assert len(model2.scatterers())==len(template_pdb_inp.atoms())
        b_iso_values=flex.double()
        for scatterer,atom in zip(model2.scatterers(),template_pdb_inp.atoms()):
          b_iso_values.append(atom.b)
          new_scatterer = xray.scatterer(
            scattering_type = atom.element,
            label=atom.name,
            occupancy=atom.occ,
            site=scatterer.site)
          xrs.add_scatterer(new_scatterer)
        xrs.set_b_iso(values = b_iso_values)
        pdb_string=xrs.as_pdb_file()
        ff=open(output_pdb,'w')
        print >>ff, pdb_string
        ff.close()
        print >>f,"\nWrote model 2 mapped to model 1 to file %s " %(output_pdb)

      if return_superposed_model2:
        return model2.as_emma_model()
Example #41
0
def structure_init2(site, site2, sg, cell):
    symmetry = crystal.symmetry(unit_cell=cell, space_group_symbol=sg)
    structure = xray.structure(crystal_symmetry=symmetry)
    scatterer = xray.scatterer(site=site,
                               u=0.1,
                               occupancy=1.0,
                               scattering_type="C")
    scatterer2 = xray.scatterer(site=site2,
                                u=0.1,
                                occupancy=1.0,
                                scattering_type="C")
    structure.add_scatterer(scatterer)
    structure.add_scatterer(scatterer2)
    xyzf = flex.vec3_double()
    atmrad = flex.double()
    for scatterer in structure.scatterers():
        xyzf.append(list(scatterer.site))
        atmrad.append(
            van_der_waals_radii.vdw.table[scatterer.element_symbol()])
    assert xyzf.size() == atmrad.size()
    return structure, xyzf, atmrad
Example #42
0
def pdb_atoms_as_xray_structure(pdb_atoms, crystal_symmetry):
  xray_structure = xray.structure(crystal_symmetry = crystal_symmetry)
  unit_cell = xray_structure.unit_cell()
  for atom in pdb_atoms:
    scatterer = xray.scatterer(
      label           = atom.name,
      site            = unit_cell.fractionalize(atom.xyz),
      b               = atom.b,
      occupancy       = atom.occ,
      scattering_type = atom.element)
    xray_structure.add_scatterer(scatterer)
  return xray_structure
 def scatterers(self):
   yield xray.scatterer('Ba', (0.500000, 0.369879, 0.431121))
   yield xray.scatterer('Mg', (-0.000000, 0.385261, -0.084062))
   yield xray.scatterer('F1', (0.000000, 0.291730, 0.783213))
   yield xray.scatterer('F2', (0.000000, 0.328018, 0.303193))
   yield xray.scatterer('F3', (0.000000, 0.506766, 0.591744))
   yield xray.scatterer('F4', (0.500000, 0.414262, 1.002902))
 def scatterers(self):
   yield xray.scatterer('Ba', (0.500000, 0.369879, 0.431121))
   yield xray.scatterer('Mg', (-0.000000, 0.385261, -0.084062))
   yield xray.scatterer('F1', (0.000000, 0.291730, 0.783213))
   yield xray.scatterer('F2', (0.000000, 0.328018, 0.303193))
   yield xray.scatterer('F3', (0.000000, 0.506766, 0.591744))
   yield xray.scatterer('F4', (0.500000, 0.414262, 1.002902))
 def __init__(self, staggered, verbose=False):
   self.staggered = staggered
   self.verbose = verbose
   self.cs = crystal.symmetry(uctbx.unit_cell((1, 1, 2, 90, 90, 80)),
                              "hall: P 2z")
   self.o = xray.scatterer('O', site=(0,0,0))
   self.o.flags.set_grad_site(True)
   self.c1 = xray.scatterer('C1', site=(1.5, 0, 0))
   self.c2 = xray.scatterer('C2', site=(2.5, 1, 0))
   self.h = xray.scatterer('H')
   self.reparam = constraints.ext.reparametrisation(self.cs.unit_cell())
   xo = self.reparam.add(constraints.independent_site_parameter, self.o)
   x1 = self.reparam.add(constraints.independent_site_parameter, self.c1)
   x2 = self.reparam.add(constraints.independent_site_parameter, self.c2)
   l = self.reparam.add(constraints.independent_scalar_parameter,
                        value=self.bond_length, variable=False)
   phi = self.reparam.add(constraints.independent_scalar_parameter,
                          value=0, variable=False)
   uc = self.cs.unit_cell()
   _ = mat.col
   if staggered:
     xh = self.reparam.add(
       constraints.staggered_terminal_tetrahedral_xh_site,
       pivot=xo,
       pivot_neighbour=x1,
       stagger_on=x2,
       length=l,
       hydrogen=(self.h,))
   else:
     xh = self.reparam.add(
       constraints.terminal_tetrahedral_xh_site,
       pivot=xo,
       pivot_neighbour=x1,
       azimuth=phi,
       length=l,
       e_zero_azimuth=uc.orthogonalize(_(self.c2.site) - _(self.c1.site)),
       hydrogen=(self.h,))
   self.reparam.finalise()
   self.xh, self.xo, self.x1, self.x2 = [ x.index for x in (xh, xo, x1, x2) ]
   self.l, self.phi = l.index, phi.index
Example #46
0
def dummy_structure(space_group_info, volume, n_scatterers):
  structure = xray.structure(
    special_position_settings=crystal.special_position_settings(
      crystal_symmetry=crystal.symmetry(
        unit_cell=space_group_info.any_compatible_unit_cell(volume=volume),
        space_group_info=space_group_info)))
  b_iso = 20
  u_iso = adptbx.b_as_u(b_iso)
  u_star = adptbx.u_iso_as_u_star(structure.unit_cell(), u_iso)
  scatterer = xray.scatterer(label="C", site=(0.123,0.234,0.345), u=u_star)
  for i in xrange(n_scatterers):
    structure.add_scatterer(scatterer)
  return structure
def build_xray_structure_with_carbon_along_x(a, b_iso, x=[0]):
  result = xray.structure(
    crystal_symmetry=crystal.symmetry(
      unit_cell=(a,a,a,90,90,90),
      space_group_symbol="P1"))
  for i,v in enumerate(x):
    result.add_scatterer(xray.scatterer(
      label="C%d" % (i+1), scattering_type="C", site=(v,0,0), b=b_iso))
  reg = result.scattering_type_registry(table="n_gaussian", d_min=1/12)
  g = reg.as_type_gaussian_dict()["C"]
  assert g.n_terms() == 5
  assert not g.use_c()
  return result
Example #48
0
 def __init__(self, n_runs, **kwds):
     libtbx.adopt_optional_init_args(self, kwds)
     self.n_runs = n_runs
     self.crystal_symmetry = crystal.symmetry(
         unit_cell=uctbx.unit_cell((5.1534, 5.1534, 8.6522, 90, 90, 120)),
         space_group_symbol='Hall: P 6c')
     self.structure = xray.structure(
         self.crystal_symmetry.special_position_settings(),
         flex.xray_scatterer(
             (xray.scatterer('K1',
                             site=(0, 0, -0.00195),
                             u=self.u_cif_as_u_star(
                                 (0.02427, 0.02427, 0.02379, 0.01214,
                                  0.00000, 0.00000))),
              xray.scatterer('S1',
                             site=(1 / 3, 2 / 3, 0.204215),
                             u=self.u_cif_as_u_star(
                                 (0.01423, 0.01423, 0.01496, 0.00712,
                                  0.00000, 0.00000))),
              xray.scatterer('Li1',
                             site=(1 / 3, 2 / 3, 0.815681),
                             u=self.u_cif_as_u_star(
                                 (0.02132, 0.02132, 0.02256, 0.01066,
                                  0.00000, 0.00000))),
              xray.scatterer('O1',
                             site=(1 / 3, 2 / 3, 0.035931),
                             u=self.u_cif_as_u_star(
                                 (0.06532, 0.06532, 0.01669, 0.03266,
                                  0.00000, 0.00000))),
              xray.scatterer('O2',
                             site=(0.343810, 0.941658, 0.258405),
                             u=self.u_cif_as_u_star(
                                 (0.02639, 0.02079, 0.05284, 0.01194,
                                  -0.00053, -0.01180))))))
     mi = self.crystal_symmetry.build_miller_set(anomalous_flag=False,
                                                 d_min=0.5)
     fo_sq = mi.structure_factors_from_scatterers(
         self.structure, algorithm="direct").f_calc().norm()
     self.fo_sq = fo_sq.customized_copy(sigmas=flex.double(fo_sq.size(), 1))
def exercise_u_iso_proportional_to_pivot_u_iso():
    # Test working constraint
    xs = xray.structure(crystal_symmetry=crystal.symmetry(
        unit_cell=(), space_group_symbol='hall: P 2x 2y'),
                        scatterers=flex.xray_scatterer((
                            xray.scatterer('C0', u=0.12),
                            xray.scatterer('C1'),
                        )))
    r = constraints.ext.reparametrisation(xs.unit_cell())
    sc = xs.scatterers()

    u_iso = r.add(constraints.independent_u_iso_parameter, sc[0])
    u_iso_1 = r.add(constraints.u_iso_proportional_to_pivot_u_iso,
                    pivot_u_iso=u_iso,
                    multiplier=2,
                    scatterer=sc[1])
    r.finalise()
    r.linearise()
    assert approx_equal(u_iso_1.value, 0.24, eps=1e-15)

    # Test conflicting constraints
    xs = xray.structure(
        crystal_symmetry=crystal.symmetry(unit_cell=(),
                                          space_group_symbol='hall: P 2x 2y'),
        scatterers=flex.xray_scatterer(
            (xray.scatterer('C0', u=0.12), xray.scatterer('C1', u=0.21),
             xray.scatterer('C2'))))
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        r = constraints.reparametrisation(
            structure=xs,
            constraints=[
                constraints.adp.shared_u((0, 2)),
                constraints.adp.shared_u((1, 2))
            ],
            connectivity_table=smtbx.utils.connectivity_table(xs))
        assert len(w) == 1
        assert w[-1].category == constraints.ConflictingConstraintWarning
        assert w[-1].message.conflicts == set(((2, 'U'), ))
Example #50
0
 def __init__(self):
   self.size_value = 9
   self.rx = pi
   self.ry = pi/2
   self.rz = pi/3
   self.sites = ((0,0,0), (1,0,0), (0,1,0), (0,0,1))
   self.uc = uctbx.unit_cell((1, 1, 1))
   self.xs = xray.structure(
     crystal_symmetry=crystal.symmetry(
       unit_cell=self.uc,
       space_group_symbol='hall: P 2x 2y'),
     scatterers=flex.xray_scatterer(( #triangle
       xray.scatterer('C0'),
       xray.scatterer('C1'),
       xray.scatterer('C2'),
       xray.scatterer('C3'),
       )))
   self.center = col((0,0,0))
   for s in self.sites:
     self.center = self.center + col(s)
   self.center = self.center / len(self.sites)
   self.reset_sites()
Example #51
0
def exercise_2():
    symmetry = crystal.symmetry(unit_cell=(5.67, 10.37, 10.37, 90, 135.49, 90),
                                space_group_symbol="C2")
    structure = xray.structure(crystal_symmetry=symmetry)
    atmrad = flex.double()
    xyzf = flex.vec3_double()
    for k in xrange(100):
        scatterer = xray.scatterer(site=((1. + k * abs(math.sin(k))) / 1000.0,
                                         (1. + k * abs(math.cos(k))) / 1000.0,
                                         (1. + k) / 1000.0),
                                   scattering_type="C")
        structure.add_scatterer(scatterer)
        atmrad.append(
            van_der_waals_radii.vdw.table[scatterer.element_symbol()])
        xyzf.append(scatterer.site)
    miller_set = miller.build_set(crystal_symmetry=structure,
                                  d_min=1.0,
                                  anomalous_flag=False)
    step = 0.5
    crystal_gridding = maptbx.crystal_gridding(unit_cell=structure.unit_cell(),
                                               step=step)
    nxyz = crystal_gridding.n_real()
    shrink_truncation_radius = 1.0
    solvent_radius = 1.0
    m1 = around_atoms(structure.unit_cell(),
                      structure.space_group().order_z(),
                      structure.sites_frac(), atmrad, nxyz, solvent_radius,
                      shrink_truncation_radius)
    assert m1.solvent_radius == 1
    assert m1.shrink_truncation_radius == 1
    assert flex.max(m1.data) == 1
    assert flex.min(m1.data) == 0
    assert m1.data.size() == m1.data.count(1) + m1.data.count(0)
    m2 = mmtbx.masks.bulk_solvent(
        xray_structure=structure,
        gridding_n_real=nxyz,
        ignore_zero_occupancy_atoms=False,
        solvent_radius=solvent_radius,
        shrink_truncation_radius=shrink_truncation_radius)
    assert m2.data.all_eq(m1.data)
    m3 = mmtbx.masks.bulk_solvent(
        xray_structure=structure,
        grid_step=step,
        ignore_zero_occupancy_atoms=False,
        solvent_radius=solvent_radius,
        shrink_truncation_radius=shrink_truncation_radius)
    assert m3.data.all_eq(m1.data)
    f_mask2 = m2.structure_factors(miller_set=miller_set)
    f_mask3 = m3.structure_factors(miller_set=miller_set)
    assert approx_equal(f_mask2.data(), f_mask3.data())
    assert approx_equal(flex.sum(flex.abs(f_mask3.data())), 1095.17999134)
Example #52
0
def exercise_extract_u_cart_plus_u_iso():
  from cctbx import uctbx, sgtbx, xray
  uc = uctbx.unit_cell((1,1,1))
  sg = sgtbx.space_group_info("P 1")
  a = flex.xray_scatterer()
  assert a.size() == 0
  s1 = xray.scatterer(label = "C", u = 0.1)
  s2 = xray.scatterer(label = "C", u = 0.1)
  s2.flags.set_use_u_iso(False)
  s3 = xray.scatterer(label = "C", u = (1,1,1,1,1,1))
  s4 = xray.scatterer(label = "C", u = (1,1,1,1,1,1))
  s4.flags.set_use_u_aniso(False)
  s5 = xray.scatterer(label = "C", u = 0.1)
  s5.u_star=(1,1,1,1,1,1)
  s5.flags.set_use_u_aniso(True)
  s6 = xray.scatterer(label = "C", u = 0.1)
  s6.u_star=(1,1,1,1,1,1)
  s7 = xray.scatterer(label = "C", u = (1,1,1,1,1,1))
  s7.u_iso=0.1
  s8 = xray.scatterer(label = "C", u = (1,1,1,1,1,1))
  s8.u_iso=0.1
  s8.flags.set_use_u_iso(True)
  s9 = xray.scatterer(label = "C")
  s10 = xray.scatterer(label = "C")
  s10.flags.set_use_u_iso(False)
  a = flex.xray_scatterer((s1,s2,s3,s4,s5,s6,s7,s8,s9,s10))
  u_cart_total = a.extract_u_cart_plus_u_iso(uc)
  assert approx_equal(u_cart_total,
    [(0.1,0.1,0.1,0,0,0),
    (0,0,0,0,0,0),
    (1,1,1,1,1,1),
    (0,0,0,0,0,0),
    (1.1,1.1,1.1,1,1,1),
    (0.1,0.1,0.1,0,0,0),
    (1,1,1,1,1,1),
    (1.1,1.1,1.1,1,1,1),
    (0,0,0,0,0,0),
    (0,0,0,0,0,0)])
Example #53
0
def expand_cell(scatterers, direction, number):
    for atom in scatterers:
        print atom.label, number
        site = list(atom.site)

        coord = site[direction]

        for n in range(number):
            n = float(n)
            new = (coord / number) + (n / number)
            site[direction] = new

            label = atom.label+chr(97+int(n))  # 97 => a
            yield xray.scatterer(label=label, site=site, u=atom.u_iso, occupancy=atom.occupancy)
Example #54
0
 def as_xray_scatterer(self, unit_cell=None):
     scattering_type = eltbx.xray_scattering.get_standard_label(
         label=self.type, exact=False, optional=True)
     if (scattering_type is None):
         scattering_type = eltbx.xray_scattering.get_standard_label(
             label=self.segid, exact=False, optional=True)
     if (scattering_type is None): scattering_type = "unknown"
     site = (self.x, self.y, self.z)
     if (unit_cell is not None): site = unit_cell.fractionalize(site)
     return xray.scatterer(label="_".join((self.segid, self.type)),
                           site=site,
                           u=adptbx.b_as_u(self.b),
                           occupancy=self.q,
                           scattering_type=scattering_type)
    def debug_write_reciprocal_lattice_points_as_pdb(
        self, file_name="reciprocal_lattice.pdb"
    ):
        from cctbx import crystal, xray

        cs = crystal.symmetry(
            unit_cell=(1000, 1000, 1000, 90, 90, 90), space_group="P1"
        )
        xs = xray.structure(crystal_symmetry=cs)
        for site in self.trial_sites:
            xs.add_scatterer(xray.scatterer("C", site=site))
        xs.sites_mod_short()
        with open(file_name, "wb") as f:
            print(xs.as_pdb_file(), file=f)
def debug_write_reciprocal_lattice_points_as_pdb(
    points, file_name="reciprocal_lattice.pdb"
):
    from cctbx import crystal, xray

    cs = crystal.symmetry(unit_cell=(1000, 1000, 1000, 90, 90, 90), space_group="P1")
    xs = xray.structure(crystal_symmetry=cs)
    sel = flex.random_selection(points.size(), min(20000, points.size()))
    rsp = points.select(sel)
    for site in rsp:
        xs.add_scatterer(xray.scatterer("C", site=site))

    xs.sites_mod_short()
    with open(file_name, "wb") as f:
        print(xs.as_pdb_file(), file=f)
Example #57
0
def test_rigid_pivoted_rotatable():
    uc = uctbx.unit_cell((1, 1, 1))
    xs = xray.structure(
        crystal_symmetry=crystal.symmetry(unit_cell=uc,
                                          space_group_symbol='hall: P 2x 2y'),
        scatterers=flex.xray_scatterer((  #triangle
            xray.scatterer('C0', site=(0, 0, 0)),
            xray.scatterer('C1', site=(0, 2, 0)),
            xray.scatterer('C2', site=(1, 1, 0)),
        )))
    r = constraints.ext.reparametrisation(xs.unit_cell())
    sc = xs.scatterers()
    pivot = r.add(constraints.independent_site_parameter, sc[0])
    pivot_neighbour = r.add(constraints.independent_site_parameter, sc[1])
    azimuth = r.add(constraints.independent_scalar_parameter,
                    value=math.pi / 2,
                    variable=True)
    size = r.add(constraints.independent_scalar_parameter,
                 value=1,
                 variable=False)
    rg = r.add(constraints.rigid_pivoted_rotatable_group,
               pivot=pivot,
               pivot_neighbour=pivot_neighbour,
               azimuth=azimuth,
               size=size,
               scatterers=(sc[1], sc[2]))
    site_proxy = r.add(constraints.rigid_site_proxy, rg, 1)
    r.finalise()
    r.linearise()
    r.store()
    #check that proxy and the final results are the same...
    assert uc.distance(col(site_proxy.value),
                       col(sc[2].site)) == pytest.approx(0, abs=1e-15)
    #rotation happens around the center of gravity
    assert uc.distance(col((0, 1, 1)),
                       col(sc[2].site)) == pytest.approx(0, abs=1e-15)
Example #58
0
 def scatterers(O, u_iso=0):
   assert O.types is not None
   from cctbx import xray
   from cctbx.array_family import flex
   result = flex.xray_scatterer()
   sites = iter(O.sites)
   for type,count in zip(O.types, O.type_counts):
     for _ in range(count):
       result.append(xray.scatterer(
         label="%s%d"%(type, len(result)+1),
         scattering_type=type,
         site=next(sites),
         u=u_iso))
   assert len(result) == len(O.sites)
   return result