コード例 #1
0
ファイル: tst_ext.py プロジェクト: cctbx/cctbx-playground
 def residual(restraint_type, proxy, sites_cart=None,
              u_cart=None, u_iso=None, use_u_aniso=None):
   if sites_cart is not None:
     return restraint_type(
       adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart),
       proxy=proxy).residual()
   elif u_iso is None:
     return restraint_type(
       adp_restraint_params(u_cart=u_cart),
       proxy=proxy).residual()
   else:
     assert use_u_aniso is not None
     return restraint_type(
       adp_restraint_params(u_cart=u_cart, u_iso=u_iso, use_u_aniso=use_u_aniso),
       proxy=proxy).residual()
コード例 #2
0
 def residual(restraint_type, proxy, sites_cart=None,
              u_cart=None, u_iso=None, use_u_aniso=None):
   if sites_cart is not None:
     return restraint_type(
       adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart),
       proxy=proxy).residual()
   elif u_iso is None:
     return restraint_type(
       adp_restraint_params(u_cart=u_cart),
       proxy=proxy).residual()
   else:
     assert use_u_aniso is not None
     return restraint_type(
       adp_restraint_params(u_cart=u_cart, u_iso=u_iso, use_u_aniso=use_u_aniso),
       proxy=proxy).residual()
コード例 #3
0
def adp_volume_similarity_as_cif_loops(xray_structure, proxies):
    site_labels = xray_structure.scatterers().extract_labels()
    fmt = "%.4e"
    loop = model.loop(header=(
        "_restr_U_volume_similar_atom_site_label_1",
        "_restr_U_volume_similar_diff",
        "_restr_U_volume_similar_class_id",
    ))
    class_loop = model.loop(header=(
        "_restr_U_volume_similar_class_class_id",
        "_restr_U_volume_similar_class_target_weight_param",
        "_restr_U_volume_similar_class_average",
        "_restr_U_volume_similar_class_esd",
        "_restr_U_volume_similar_class_diff_max",
    ))
    unit_cell = xray_structure.unit_cell()
    params = adp_restraints.adp_restraint_params(
        u_cart=xray_structure.scatterers().extract_u_cart(unit_cell),
        u_iso=xray_structure.scatterers().extract_u_iso(),
        use_u_aniso=xray_structure.use_u_aniso())
    class_id = 0
    for proxy in proxies:
        restraint = adp_restraints.adp_volume_similarity(params=params,
                                                         proxy=proxy)
        class_id += 1
        class_loop.add_row(
            (class_id, fmt % math.sqrt(1 / proxy.weight),
             fmt % restraint.mean_u_volume, fmt % restraint.rms_deltas(),
             fmt % flex.max_absolute(restraint.deltas())))
        for i, i_seq in enumerate(proxy.i_seqs):
            loop.add_row(
                (site_labels[i_seq], fmt % restraint.deltas()[i], class_id))
    return class_loop, loop
コード例 #4
0
ファイル: restraints.py プロジェクト: yayahjb/cctbx_project
def rigu_as_cif_loop(xray_structure, proxies):
  unit_cell = xray_structure.unit_cell()
  sites_cart = xray_structure.sites_cart()
  u_cart = xray_structure.scatterers().extract_u_cart(unit_cell)
  site_labels = xray_structure.scatterers().extract_labels()
  fmt = "%.6f"
  loop = model.loop(header=(
    "_restr_RIGU_atom_site_label_1",
    "_restr_RIGU_atom_site_label_2",
    "_restr_RIGU_target_weight_param",
    "_restr_RIGU_U13_diff",
    "_restr_RIGU_U23_diff",
    "_restr_RIGU_U33_diff"
  ))
  for proxy in proxies:
    restraint = adp_restraints.rigu(
      adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart),
      proxy=proxy)
    loop.add_row((site_labels[proxy.i_seqs[0]],
                  site_labels[proxy.i_seqs[1]],
                  fmt % math.sqrt(1/proxy.weight),
                  fmt % restraint.delta_13(),
                  fmt % restraint.delta_23(),
                  fmt % restraint.delta_33()
                 ))
  return loop
コード例 #5
0
 def restraint(self, proxy, u_iso=None, u_cart=None):
   if u_cart is None:
     u_cart=self.xray_structure.scatterers().extract_u_cart(
       self.xray_structure.unit_cell())
   return adp.fixed_u_eq_adp(
     adp_restraint_params(u_cart=u_cart),
     proxy)
コード例 #6
0
ファイル: restraints.py プロジェクト: cctbx/cctbx-playground
def fixed_u_eq_adp_as_cif_loop(xray_structure, proxies):
  site_labels = xray_structure.scatterers().extract_labels()
  fmt = "%.4f"
  loop = model.loop(header=(
    "_restr_U_Ueq_atom_site_label_1",
    "_restr_U_Ueq_weight_param",
    "_restr_U_Ueq_target",
    "_restr_U_Ueq_diff"
  ))
  unit_cell = xray_structure.unit_cell()
  params = adp_restraints.adp_restraint_params(
    u_cart=xray_structure.scatterers().extract_u_cart(unit_cell),
    u_iso=xray_structure.scatterers().extract_u_iso(),
    use_u_aniso=xray_structure.use_u_aniso()
    )
  for proxy in proxies:
    restraint = adp_restraints.fixed_u_eq_adp(
      params=params,
      proxy=proxy)
    for i, i_seq in enumerate(proxy.i_seqs):
      loop.add_row((site_labels[i_seq],
                    fmt % math.sqrt(1/proxy.weight),
                    fmt % proxy.u_eq_ideal,
                    fmt % restraint.delta()))
  return loop
コード例 #7
0
ファイル: tst_restraints.py プロジェクト: TheApacheCats/cctbx
 def restraint(self, proxy, u_iso=None, u_cart=None):
   if u_cart is None:
     u_cart=self.xray_structure.scatterers().extract_u_cart(
       self.xray_structure.unit_cell())
   return adp.fixed_u_eq_adp(
     adp_restraint_params(u_cart=u_cart),
     proxy)
コード例 #8
0
 def restraint(self, proxy, u_iso=None, u_cart=None):
     if u_cart is None:
         u_cart = self.xray_structure.scatterers().extract_u_cart(
             self.xray_structure.unit_cell())
     sites_cart = self.xray_structure.sites_cart()
     return adp.rigid_bond(
         adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart), proxy)
コード例 #9
0
ファイル: restraints.py プロジェクト: yayahjb/cctbx_project
def fixed_u_eq_adp_as_cif_loop(xray_structure, proxies):
  site_labels = xray_structure.scatterers().extract_labels()
  fmt = "%.4f"
  loop = model.loop(header=(
    "_restr_U_Ueq_atom_site_label_1",
    "_restr_U_Ueq_weight_param",
    "_restr_U_Ueq_target",
    "_restr_U_Ueq_diff"
  ))
  unit_cell = xray_structure.unit_cell()
  params = adp_restraints.adp_restraint_params(
    u_cart=xray_structure.scatterers().extract_u_cart(unit_cell),
    u_iso=xray_structure.scatterers().extract_u_iso(),
    use_u_aniso=xray_structure.use_u_aniso()
    )
  for proxy in proxies:
    restraint = adp_restraints.fixed_u_eq_adp(
      params=params,
      proxy=proxy)
    for i, i_seq in enumerate(proxy.i_seqs):
      loop.add_row((site_labels[i_seq],
                    fmt % math.sqrt(1/proxy.weight),
                    fmt % proxy.u_eq_ideal,
                    fmt % restraint.delta()))
  return loop
コード例 #10
0
def exercise_isotropic_adp():
  i_seqs = (0,)
  weight = 2
  u_cart = ((1,2,3,5,2,8),)
  u_iso = (0,)
  use_u_aniso = (True,)
  p = adp_restraints.isotropic_adp_proxy(
    i_seqs=i_seqs,
    weight=weight)
  assert p.i_seqs == i_seqs
  assert approx_equal(p.weight, weight)
  i = adp_restraints.isotropic_adp(u_cart=u_cart[0], weight=weight)
  expected_deltas = (-1, 0, 1, 5, 2, 8)
  expected_gradients = (-4, 0, 4, 40, 16, 64)
  assert approx_equal(i.weight, weight)
  assert approx_equal(i.deltas(), expected_deltas)
  assert approx_equal(i.rms_deltas(), 4.5704364002673632)
  assert approx_equal(i.residual(), 376.0)
  assert approx_equal(i.gradients(), expected_gradients)
  gradients_aniso_cart = flex.sym_mat3_double(1, (0,0,0,0,0,0))
  gradients_iso = flex.double(1,0)
  proxies = adp_restraints.shared_isotropic_adp_proxy([p,p])
  u_cart = flex.sym_mat3_double(u_cart)
  u_iso = flex.double(u_iso)
  use_u_aniso = flex.bool(use_u_aniso)
  params = adp_restraint_params(u_cart=u_cart, u_iso=u_iso, use_u_aniso=use_u_aniso)
  residuals = adp_restraints.isotropic_adp_residuals(params, proxies=proxies)
  assert approx_equal(residuals, (i.residual(),i.residual()))
  deltas_rms = adp_restraints.isotropic_adp_deltas_rms(params, proxies=proxies)
  assert approx_equal(deltas_rms, (i.rms_deltas(),i.rms_deltas()))
  residual_sum = adp_restraints.isotropic_adp_residual_sum(
    params,
    proxies=proxies,
    gradients_aniso_cart=gradients_aniso_cart
  )
  assert approx_equal(residual_sum, 752.0)
  fd_grads_aniso, fd_grads_iso = finite_difference_gradients(
    restraint_type=adp_restraints.isotropic_adp,
    proxy=p,
    u_cart=u_cart,
    u_iso=u_iso,
    use_u_aniso=use_u_aniso
  )
  for g,e in zip(gradients_aniso_cart, fd_grads_aniso):
    assert approx_equal(g, matrix.col(e)*2)
  #
  # check frame invariance of residual
  #
  u_cart = matrix.sym(sym_mat3=(0.1,0.2,0.05,0.03,0.02,0.01))
  a = adp_restraints.isotropic_adp(
    u_cart=u_cart.as_sym_mat3(), weight=1)
  expected_residual = a.residual()
  gen = flex.mersenne_twister()
  for i in range(20):
    R = matrix.rec(gen.random_double_r3_rotation_matrix(),(3,3))
    u_cart_rot = R * u_cart * R.transpose()
    a = adp_restraints.isotropic_adp(
      u_cart=u_cart_rot.as_sym_mat3(), weight=1)
    assert approx_equal(a.residual(), expected_residual)
コード例 #11
0
ファイル: tst_ext.py プロジェクト: cctbx/cctbx-playground
def exercise_isotropic_adp():
  i_seqs = (0,)
  weight = 2
  u_cart = ((1,2,3,5,2,8),)
  u_iso = (0,)
  use_u_aniso = (True,)
  p = adp_restraints.isotropic_adp_proxy(
    i_seqs=i_seqs,
    weight=weight)
  assert p.i_seqs == i_seqs
  assert approx_equal(p.weight, weight)
  i = adp_restraints.isotropic_adp(u_cart=u_cart[0], weight=weight)
  expected_deltas = (-1, 0, 1, 5, 2, 8)
  expected_gradients = (-4, 0, 4, 40, 16, 64)
  assert approx_equal(i.weight, weight)
  assert approx_equal(i.deltas(), expected_deltas)
  assert approx_equal(i.rms_deltas(), 4.5704364002673632)
  assert approx_equal(i.residual(), 376.0)
  assert approx_equal(i.gradients(), expected_gradients)
  gradients_aniso_cart = flex.sym_mat3_double(1, (0,0,0,0,0,0))
  gradients_iso = flex.double(1,0)
  proxies = adp_restraints.shared_isotropic_adp_proxy([p,p])
  u_cart = flex.sym_mat3_double(u_cart)
  u_iso = flex.double(u_iso)
  use_u_aniso = flex.bool(use_u_aniso)
  params = adp_restraint_params(u_cart=u_cart, u_iso=u_iso, use_u_aniso=use_u_aniso)
  residuals = adp_restraints.isotropic_adp_residuals(params, proxies=proxies)
  assert approx_equal(residuals, (i.residual(),i.residual()))
  deltas_rms = adp_restraints.isotropic_adp_deltas_rms(params, proxies=proxies)
  assert approx_equal(deltas_rms, (i.rms_deltas(),i.rms_deltas()))
  residual_sum = adp_restraints.isotropic_adp_residual_sum(
    params,
    proxies=proxies,
    gradients_aniso_cart=gradients_aniso_cart
  )
  assert approx_equal(residual_sum, 752.0)
  fd_grads_aniso, fd_grads_iso = finite_difference_gradients(
    restraint_type=adp_restraints.isotropic_adp,
    proxy=p,
    u_cart=u_cart,
    u_iso=u_iso,
    use_u_aniso=use_u_aniso
  )
  for g,e in zip(gradients_aniso_cart, fd_grads_aniso):
    assert approx_equal(g, matrix.col(e)*2)
  #
  # check frame invariance of residual
  #
  u_cart = matrix.sym(sym_mat3=(0.1,0.2,0.05,0.03,0.02,0.01))
  a = adp_restraints.isotropic_adp(
    u_cart=u_cart.as_sym_mat3(), weight=1)
  expected_residual = a.residual()
  gen = flex.mersenne_twister()
  for i in range(20):
    R = matrix.rec(gen.random_double_r3_rotation_matrix(),(3,3))
    u_cart_rot = R * u_cart * R.transpose()
    a = adp_restraints.isotropic_adp(
      u_cart=u_cart_rot.as_sym_mat3(), weight=1)
    assert approx_equal(a.residual(), expected_residual)
コード例 #12
0
ファイル: __init__.py プロジェクト: rimmartin/cctbx_project
 def build_linearised_eqns(self, xray_structure, parameter_map):
     n_restraints = 0
     n_params = parameter_map.n_parameters
     geometry_proxies = [
         proxies for proxies in (self.bond_proxies, self.angle_proxies,
                                 self.dihedral_proxies)
         if proxies is not None
     ]
     # count restraints, i.e. number of rows for restraint matrix
     n_restraints = sum([proxies.size() for proxies in geometry_proxies])
     if self.bond_similarity_proxies is not None:
         for proxy in self.bond_similarity_proxies:
             n_restraints += proxy.i_seqs.size()
         geometry_proxies.append(self.bond_similarity_proxies)
     if self.chirality_proxies is not None:
         for proxy in self.chirality_proxies:
             n_restraints += 1
         geometry_proxies.append(self.chirality_proxies)
     adp_proxies = []
     if self.adp_similarity_proxies is not None:
         adp_proxies.append(self.adp_similarity_proxies)
         n_restraints += 6 * self.adp_similarity_proxies.size()
     if self.adp_u_eq_similarity_proxies is not None:
         adp_proxies.append(self.adp_u_eq_similarity_proxies)
         for p in self.adp_u_eq_similarity_proxies:
             n_restraints += len(p.i_seqs)
     if self.adp_volume_similarity_proxies is not None:
         adp_proxies.append(self.adp_volume_similarity_proxies)
         for p in self.adp_volume_similarity_proxies:
             n_restraints += len(p.i_seqs)
     if self.isotropic_adp_proxies is not None:
         adp_proxies.append(self.isotropic_adp_proxies)
         n_restraints += 6 * self.isotropic_adp_proxies.size()
     if self.fixed_u_eq_adp_proxies is not None:
         adp_proxies.append(self.fixed_u_eq_adp_proxies)
         n_restraints += self.fixed_u_eq_adp_proxies.size()
     if self.rigid_bond_proxies is not None:
         adp_proxies.append(self.rigid_bond_proxies)
         n_restraints += self.rigid_bond_proxies.size()
     if self.rigu_proxies is not None:
         adp_proxies.append(self.rigu_proxies)
         n_restraints += 3 * self.rigu_proxies.size()
     # construct restraints matrix
     linearised_eqns = linearised_eqns_of_restraint(n_restraints, n_params)
     for proxies in geometry_proxies:
         linearise_restraints(xray_structure.unit_cell(),
                              xray_structure.sites_cart(), parameter_map,
                              proxies, linearised_eqns)
     u_cart = xray_structure.scatterers().extract_u_cart(
         xray_structure.unit_cell())
     params = adp_restraint_params(
         sites_cart=xray_structure.sites_cart(),
         u_cart=u_cart,
         u_iso=xray_structure.scatterers().extract_u_iso(),
         use_u_aniso=xray_structure.use_u_aniso())
     for proxies in adp_proxies:
         linearise_restraints(xray_structure.unit_cell(), params,
                              parameter_map, proxies, linearised_eqns)
     return linearised_eqns
コード例 #13
0
 def restraint(self, proxy, u_iso=None, u_cart=None):
   if u_cart is None:
     u_cart = self.xray_structure.scatterers().extract_u_cart(
       self.xray_structure.unit_cell())
   sites_cart = self.xray_structure.sites_cart()
   return adp.rigid_bond(
     adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart),
     proxy)
コード例 #14
0
 def restraint(self, proxy, u_iso=None, u_cart=None):
   if u_cart is None:
     u_cart=self.xray_structure.scatterers().extract_u_cart(
       self.xray_structure.unit_cell())
   if u_iso is None:
     u_iso=self.xray_structure.scatterers().extract_u_iso()
   use_u_aniso=self.xray_structure.use_u_aniso()
   return adp.adp_volume_similarity(
     adp_restraint_params(u_cart=u_cart, u_iso=u_iso, use_u_aniso=use_u_aniso),
     proxy)
コード例 #15
0
ファイル: tst_restraints.py プロジェクト: TheApacheCats/cctbx
 def restraint(self, proxy, u_iso=None, u_cart=None):
   if u_cart is None:
     u_cart=self.xray_structure.scatterers().extract_u_cart(
       self.xray_structure.unit_cell())
   if u_iso is None:
     u_iso=self.xray_structure.scatterers().extract_u_iso()
   use_u_aniso=self.xray_structure.use_u_aniso()
   return adp.adp_volume_similarity(
     adp_restraint_params(u_cart=u_cart, u_iso=u_iso, use_u_aniso=use_u_aniso),
     proxy)
コード例 #16
0
ファイル: tst_ext.py プロジェクト: phyy-nx/cctbx_project
def exercise_rigu():
    ins = """
CELL 0.71073 7.772741 8.721603 10.863736 90 102.9832 90
ZERR 2 0.000944 0.001056 0.001068 0 0.0107 0
LATT -1
SYMM -X,0.5+Y,-Z
SFAC C H O
UNIT 24 44 22
RIGU 0.0001 0.0001 O4 C C12

C12   1    -0.12812  0.06329 -0.17592  11.00000  0.01467  0.02689  0.02780 =
 -0.00379  0.00441 -0.00377
O4    3     0.08910  0.02721  0.02186  11.00000  0.02001  0.03168  0.03125 =
 -0.00504  0.00144 -0.00274
C     1    -0.05545 -0.04221 -0.06528  11.00000  0.01560  0.02699  0.02581 =
 -0.00481  0.00597 -0.00068
HKLF 4
END
  """
    sio = StringIO(ins)
    import iotbx.shelx as shelx
    model = shelx.parse_smtbx_refinement_model(file=sio)
    sites_cart = model.structure.sites_cart()
    u_cart = model.structure.scatterers().extract_u_cart(
        model.structure.unit_cell())
    arp = adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart)
    for rp in model._proxies['rigu']:
        rr = adp_restraints.rigu(arp, rp)
        U1 = matrix.sym(sym_mat3=u_cart[rp.i_seqs[0]])
        U2 = matrix.sym(sym_mat3=u_cart[rp.i_seqs[1]])
        vz = matrix.col(sites_cart[rp.i_seqs[1]]) - matrix.col(
            sites_cart[rp.i_seqs[0]])
        vy = vz.ortho()
        vx = vy.cross(vz)
        R = matrix.rec(
            vx.normalize().elems + vy.normalize().elems + vz.normalize().elems,
            (3, 3))
        # with this matrix we can only test Z component as X and Y will differ
        dU = ((R * U1) * R.transpose() -
              (R * U2) * R.transpose()).as_sym_mat3()
        assert approx_equal(dU[2], rr.delta_33())
        #with the original matrix all components should match
        R1 = matrix.rec(rr.RM(), (3, 3))
        dU = ((R1 * U1) * R1.transpose() -
              (R1 * U2) * R1.transpose()).as_sym_mat3()
        assert approx_equal(dU[2], rr.delta_33())
        assert approx_equal(dU[4], rr.delta_13())
        assert approx_equal(dU[5], rr.delta_23())
        # check the raw gradients against the reference implementation
        for x, y in zip(rr.reference_gradients(R1), rr.raw_gradients()):
            for idx in range(0, 6):
                assert approx_equal(x[idx], y[idx])
        for x, y in zip(rigu_finite_diff(R1, U1), rr.raw_gradients()):
            for idx in range(0, 6):
                assert approx_equal(x[idx], y[idx])
コード例 #17
0
ファイル: __init__.py プロジェクト: cctbx/cctbx-playground
 def build_linearised_eqns(self, xray_structure, parameter_map):
   n_restraints = 0
   n_params = parameter_map.n_parameters
   geometry_proxies = [proxies for proxies in (
     self.bond_proxies, self.angle_proxies, self.dihedral_proxies)
                       if proxies is not None]
   # count restraints, i.e. number of rows for restraint matrix
   n_restraints = sum([proxies.size() for proxies in geometry_proxies])
   if self.bond_similarity_proxies is not None:
     for proxy in self.bond_similarity_proxies:
       n_restraints += proxy.i_seqs.size()
     geometry_proxies.append(self.bond_similarity_proxies)
   adp_proxies = []
   if self.adp_similarity_proxies is not None:
     adp_proxies.append(self.adp_similarity_proxies)
     n_restraints += 6 * self.adp_similarity_proxies.size()
   if self.adp_u_eq_similarity_proxies is not None:
     adp_proxies.append(self.adp_u_eq_similarity_proxies)
     for p in self.adp_u_eq_similarity_proxies:
       n_restraints += len(p.i_seqs)
   if self.adp_volume_similarity_proxies is not None:
     adp_proxies.append(self.adp_volume_similarity_proxies)
     for p in self.adp_volume_similarity_proxies:
       n_restraints += len(p.i_seqs)
   if self.isotropic_adp_proxies is not None:
     adp_proxies.append(self.isotropic_adp_proxies)
     n_restraints += 6 * self.isotropic_adp_proxies.size()
   if self.fixed_u_eq_adp_proxies is not None:
     adp_proxies.append(self.fixed_u_eq_adp_proxies)
     n_restraints += self.fixed_u_eq_adp_proxies.size()
   if self.rigid_bond_proxies is not None:
     adp_proxies.append(self.rigid_bond_proxies)
     n_restraints += self.rigid_bond_proxies.size()
   # construct restraints matrix
   linearised_eqns = linearised_eqns_of_restraint(
     n_restraints, n_params)
   for proxies in geometry_proxies:
     linearise_restraints(
       xray_structure.unit_cell(), xray_structure.sites_cart(),
       parameter_map, proxies, linearised_eqns)
   u_cart = xray_structure.scatterers().extract_u_cart(
     xray_structure.unit_cell())
   params = adp_restraint_params(
     sites_cart=xray_structure.sites_cart(),
     u_cart=u_cart,
     u_iso=xray_structure.scatterers().extract_u_iso(),
     use_u_aniso=xray_structure.use_u_aniso())
   for proxies in adp_proxies:
     linearise_restraints(
       xray_structure.unit_cell(), params,
       parameter_map, proxies, linearised_eqns)
   return linearised_eqns
コード例 #18
0
ファイル: restraints.py プロジェクト: cctbx/cctbx-playground
def rigid_bond_as_cif_loop(xray_structure, proxies):
  unit_cell = xray_structure.unit_cell()
  sites_cart = xray_structure.sites_cart()
  u_cart = xray_structure.scatterers().extract_u_cart(unit_cell)
  site_labels = xray_structure.scatterers().extract_labels()
  fmt = "%.4f"
  loop = model.loop(header=(
    "_restr_U_rigid_atom_site_label_1",
    "_restr_U_rigid_atom_site_label_2",
    "_restr_U_rigid_target_weight_param",
    "_restr_U_rigid_U_parallel",
    "_restr_U_rigid_diff",
  ))
  for proxy in proxies:
    restraint = adp_restraints.rigid_bond(
      adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart),
      proxy=proxy)
    loop.add_row((site_labels[proxy.i_seqs[0]],
                  site_labels[proxy.i_seqs[1]],
                  fmt % math.sqrt(1/proxy.weight),
                  fmt % (0.5*(restraint.z_12()+restraint.z_21())),
                  fmt % restraint.delta_z()))
  return loop
コード例 #19
0
def rigid_bond_as_cif_loop(xray_structure, proxies):
    unit_cell = xray_structure.unit_cell()
    sites_cart = xray_structure.sites_cart()
    u_cart = xray_structure.scatterers().extract_u_cart(unit_cell)
    site_labels = xray_structure.scatterers().extract_labels()
    fmt = "%.4f"
    loop = model.loop(header=(
        "_restr_U_rigid_atom_site_label_1",
        "_restr_U_rigid_atom_site_label_2",
        "_restr_U_rigid_target_weight_param",
        "_restr_U_rigid_U_parallel",
        "_restr_U_rigid_diff",
    ))
    for proxy in proxies:
        restraint = adp_restraints.rigid_bond(adp_restraint_params(
            sites_cart=sites_cart, u_cart=u_cart),
                                              proxy=proxy)
        loop.add_row(
            (site_labels[proxy.i_seqs[0]], site_labels[proxy.i_seqs[1]],
             fmt % math.sqrt(1 / proxy.weight),
             fmt % (0.5 * (restraint.z_12() + restraint.z_21())),
             fmt % restraint.delta_z()))
    return loop
コード例 #20
0
ファイル: restraints.py プロジェクト: cctbx/cctbx-playground
def adp_volume_similarity_as_cif_loops(xray_structure, proxies):
  site_labels = xray_structure.scatterers().extract_labels()
  fmt = "%.4e"
  loop = model.loop(header=(
    "_restr_U_volume_similar_atom_site_label_1",
    "_restr_U_volume_similar_diff",
    "_restr_U_volume_similar_class_id",
  ))
  class_loop = model.loop(header=(
    "_restr_U_volume_similar_class_class_id",
    "_restr_U_volume_similar_class_target_weight_param",
    "_restr_U_volume_similar_class_average",
    "_restr_U_volume_similar_class_esd",
    "_restr_U_volume_similar_class_diff_max",
  ))
  unit_cell = xray_structure.unit_cell()
  params = adp_restraints.adp_restraint_params(
    u_cart=xray_structure.scatterers().extract_u_cart(unit_cell),
    u_iso=xray_structure.scatterers().extract_u_iso(),
    use_u_aniso=xray_structure.use_u_aniso()
    )
  class_id = 0
  for proxy in proxies:
    restraint = adp_restraints.adp_volume_similarity(
      params=params,
      proxy=proxy)
    class_id += 1
    class_loop.add_row((class_id,
                        fmt % math.sqrt(1/proxy.weight),
                        fmt % restraint.mean_u_volume,
                        fmt % restraint.rms_deltas(),
                        fmt % flex.max_absolute(restraint.deltas())))
    for i, i_seq in enumerate(proxy.i_seqs):
      loop.add_row((site_labels[i_seq],
                    fmt % restraint.deltas()[i],
                    class_id))
  return class_loop, loop
コード例 #21
0
ファイル: __init__.py プロジェクト: cctbx/cctbx-playground
def _show_sorted_impl(self,
      proxy_type,
      proxy_label,
      item_label,
      by_value,
      u_cart,
      u_iso=None,
      use_u_aniso=None,
      sites_cart=None,
      site_labels=None,
      f=None,
      prefix="",
      max_items=None):
  assert by_value in ["residual", "rms_deltas", "delta"]
  assert site_labels is None or len(site_labels) == u_cart.size()
  assert sites_cart is None or len(sites_cart) == u_cart.size()
  assert [u_iso, use_u_aniso].count(None) in (0,2)
  if (f is None): f = sys.stdout
  print >> f, "%s%s restraints: %d" % (prefix, proxy_label, self.size())
  if (self.size() == 0): return
  if (max_items is not None and max_items <= 0): return

  from cctbx.adp_restraints import adp_restraint_params
  if use_u_aniso is None:  use_u_aniso = []
  if sites_cart is None:  sites_cart = []
  if u_iso is None: u_iso = []
  params = adp_restraint_params(
    sites_cart=sites_cart, u_cart=u_cart, u_iso=u_iso, use_u_aniso=use_u_aniso)
  if (by_value == "residual"):
    if proxy_type in (adp_similarity, adp_u_eq_similarity, adp_volume_similarity,\
                      isotropic_adp, fixed_u_eq_adp, rigid_bond):
      data_to_sort = self.residuals(params=params)
    else:
      raise AssertionError
  elif (by_value == "rms_deltas"):
    if proxy_type in (adp_similarity, adp_u_eq_similarity, adp_volume_similarity,\
                      isotropic_adp, fixed_u_eq_adp):
      data_to_sort = self.deltas_rms(params=params)
    else:
      raise AssertionError
  elif (by_value == "delta"):
    if proxy_type is rigid_bond:
      data_to_sort = flex.abs(self.deltas(params=params))
    else:
      raise AssertionError
  else:
    raise AssertionError
  i_proxies_sorted = flex.sort_permutation(data=data_to_sort, reverse=True)
  if (max_items is not None):
    i_proxies_sorted = i_proxies_sorted[:max_items]
  item_label_blank = " " * len(item_label)
  print >> f, "%sSorted by %s:" % (prefix, by_value)
  dynamic_proxy_types = (
    adp_u_eq_similarity,
    adp_volume_similarity,
    )
  for i_proxy in i_proxies_sorted:
    proxy = self[i_proxy]
    s = item_label
    if proxy_type in (isotropic_adp, fixed_u_eq_adp):
      if (site_labels is None): l = str(proxy.i_seqs[0])
      else:                     l = site_labels[proxy.i_seqs[0]]
      print >> f, "%s%s %s" % (prefix, s, l)
      s = item_label_blank
    elif proxy_type in dynamic_proxy_types:
      restraint = proxy_type(params=params, proxy=proxy)
      restraint._show_sorted_item(f=f, prefix=prefix)
      print >> f, \
        "%s         delta" % (prefix)
      for n, i_seq in enumerate(proxy.i_seqs):
        if (site_labels is None): l = str(i_seq)
        else:                     l = site_labels[i_seq]
        print >> f, "%s %s %9.2e" % (prefix, l, restraint.deltas()[n])
    else:
      for n, i_seq in enumerate(proxy.i_seqs):
        if (site_labels is None): l = str(i_seq)
        else:                     l = site_labels[i_seq]
        print >> f, "%s%s %s" % (prefix, s, l)
        s = item_label_blank
    if proxy_type in (adp_similarity, isotropic_adp, fixed_u_eq_adp,\
                      rigid_bond):
      restraint = proxy_type(params=params, proxy=proxy)
      restraint._show_sorted_item(f=f, prefix=prefix)
    elif proxy_type in dynamic_proxy_types:
      pass
    else:
      raise AssertionError
  n_not_shown = self.size() - i_proxies_sorted.size()
  if (n_not_shown != 0):
    print >> f, prefix + "... (remaining %d not shown)" % n_not_shown
コード例 #22
0
ファイル: tst_ext.py プロジェクト: cctbx/cctbx-playground
def exercise_rigid_bond():
  i_seqs = (1,2)
  weight = 1
  p = adp_restraints.rigid_bond_proxy(i_seqs=i_seqs,weight=weight)
  assert p.i_seqs == i_seqs
  assert p.weight == weight
  sites = ((1,2,3),(2,3,4))
  u_cart = ((1,2,3,4,5,6), (3,4,5,6,7,8))
  expected_gradients = ((-4, -4, -4, -8, -8, -8), (4, 4, 4, 8, 8, 8))
  r = adp_restraints.rigid_bond(sites=sites, u_cart=u_cart, weight=weight)
  assert r.weight == weight
  assert approx_equal(r.delta_z(), -6)
  assert approx_equal(r.residual(), 36)
  assert approx_equal(r.gradients(), expected_gradients)
  sites_cart = flex.vec3_double(((1,2,3),(2,5,4),(3,4,5)))
  u_cart = flex.sym_mat3_double(((1,2,3,4,5,6),
                                 (2,3,3,5,7,7),
                                 (3,4,5,3,7,8)))
  r = adp_restraints.rigid_bond(
    adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart),
    proxy=p)
  assert approx_equal(r.weight, weight)
  unit_cell = uctbx.unit_cell([15,25,30,90,90,90])
  sites_frac = unit_cell.fractionalize(sites_cart=sites_cart)
  u_star = flex.sym_mat3_double([
    adptbx.u_cart_as_u_star(unit_cell, u_cart_i)
    for u_cart_i in u_cart])
  pair = adp_restraints.rigid_bond_pair(sites_frac[1],
                                     sites_frac[2],
                                     u_star[1],
                                     u_star[2],
                                     unit_cell)
  assert approx_equal(pair.delta_z(), abs(r.delta_z()))
  assert approx_equal(pair.z_12(), r.z_12())
  assert approx_equal(pair.z_21(), r.z_21())
  #
  gradients_aniso_cart = flex.sym_mat3_double(sites_cart.size(), (0,0,0,0,0,0))
  gradients_iso = flex.double(sites_cart.size(), 0)
  proxies = adp_restraints.shared_rigid_bond_proxy([p,p])
  params = adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart)
  residuals = adp_restraints.rigid_bond_residuals(params, proxies=proxies)
  assert approx_equal(residuals, (r.residual(),r.residual()))
  deltas = adp_restraints.rigid_bond_deltas(params, proxies=proxies)
  assert approx_equal(deltas, (r.delta_z(),r.delta_z()))
  residual_sum = adp_restraints.rigid_bond_residual_sum(
    params=params,
    proxies=proxies,
    gradients_aniso_cart=gradients_aniso_cart)
  assert approx_equal(residual_sum, 2 * r.residual())
  for g,e in zip(gradients_aniso_cart[1:3], r.gradients()):
    assert approx_equal(g, matrix.col(e)*2)
  fd_grads_aniso, fd_grads_iso = finite_difference_gradients(
    restraint_type=adp_restraints.rigid_bond,
    proxy=p,
    sites_cart=sites_cart,
    u_cart=u_cart)
  for g,e in zip(gradients_aniso_cart, fd_grads_aniso):
    assert approx_equal(g, matrix.col(e)*2)
  #
  # check frame invariance of residual
  #
  u_cart_1 = matrix.sym(sym_mat3=(0.1,0.2,0.05,0.03,0.02,0.01))
  u_cart_2 = matrix.sym(sym_mat3=(0.21,0.32,0.11,0.02,0.02,0.07))
  u_cart = (u_cart_1.as_sym_mat3(),u_cart_2.as_sym_mat3())
  site_cart_1 = matrix.col((1,2,3))
  site_cart_2 = matrix.col((3,1,4.2))
  sites = (tuple(site_cart_1),tuple(site_cart_2))
  a = adp_restraints.rigid_bond(sites=sites, u_cart=u_cart, weight=1)
  expected_residual = a.residual()
  gen = flex.mersenne_twister()
  for i in range(20):
    R = matrix.rec(gen.random_double_r3_rotation_matrix(),(3,3))
    u_cart_1_rot = R * u_cart_1 * R.transpose()
    u_cart_2_rot = R * u_cart_2 * R.transpose()
    u_cart = (u_cart_1_rot.as_sym_mat3(),u_cart_2_rot.as_sym_mat3())
    site_cart_1_rot = R * site_cart_1
    site_cart_2_rot = R * site_cart_2
    sites = (tuple(site_cart_1_rot),tuple(site_cart_2_rot))
    a = adp_restraints.rigid_bond(
      sites=sites, u_cart=u_cart,
      weight=1)
    assert approx_equal(a.residual(), expected_residual)
コード例 #23
0
ファイル: tst_ext.py プロジェクト: cctbx/cctbx-playground
def exercise_adp_similarity():
  u_cart = ((1,3,2,4,3,6),(2,4,2,6,5,1))
  u_iso = (-1,-1)
  use_u_aniso = (True, True)
  weight = 1
  a = adp_restraints.adp_similarity(
    u_cart=u_cart,
    weight=weight)
  assert approx_equal(a.use_u_aniso, use_u_aniso)
  assert a.weight == weight
  assert approx_equal(a.residual(), 68)
  assert approx_equal(a.gradients2(),
    ((-2.0, -2.0, 0.0, -8.0, -8.0, 20.0), (2.0, 2.0, -0.0, 8.0, 8.0, -20.0)))
  assert approx_equal(a.deltas(), (-1.0, -1.0, 0.0, -2.0, -2.0, 5.0))
  assert approx_equal(a.rms_deltas(), 2.7487370837451071)
  #
  u_cart = ((1,3,2,4,3,6),(-1,-1,-1,-1,-1,-1))
  u_iso = (-1,2)
  use_u_aniso = (True, False)
  a = adp_restraints.adp_similarity(
    u_cart[0], u_iso[1], weight=weight)
  assert approx_equal(a.use_u_aniso, use_u_aniso)
  assert a.weight == weight
  assert approx_equal(a.residual(), 124)
  assert approx_equal(a.gradients2(),
    ((-2, 2, 0, 16, 12, 24), (2, -2, 0, -16, -12, -24)))
  assert approx_equal(a.deltas(), (-1, 1, 0, 4, 3, 6))
  assert approx_equal(a.rms_deltas(), 3.711842908553348)
  #
  i_seqs_aa = (1,2) # () - ()
  i_seqs_ai = (1,0) # () - o
  i_seqs_ia = (3,2) #  o - ()
  i_seqs_ii = (0,3) #  o - o
  p_aa = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_aa,weight=weight)
  p_ai = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_ai,weight=weight)
  p_ia = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_ia,weight=weight)
  p_ii = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_ii,weight=weight)
  assert p_aa.i_seqs == i_seqs_aa
  assert p_aa.weight == weight
  u_cart = flex.sym_mat3_double(((-1,-1,-1,-1,-1,-1),
                                 (1,2,2,4,3,6),
                                 (2,4,2,6,5,1),
                                 (-1,-1,-1,-1,-1,-1)))
  u_iso = flex.double((1,-1,-1,2))
  use_u_aniso = flex.bool((False, True,True,False))
  for p in (p_aa,p_ai,p_ia,p_ii):
    params = adp_restraint_params(u_cart=u_cart, u_iso=u_iso, use_u_aniso=use_u_aniso)
    a = adp_restraints.adp_similarity(params, proxy=p)
    assert approx_equal(a.weight, weight)
    #
    gradients_aniso_cart = flex.sym_mat3_double(u_cart.size(), (0,0,0,0,0,0))
    gradients_iso = flex.double(u_cart.size(), 0)
    proxies = adp_restraints.shared_adp_similarity_proxy([p,p])
    residuals = adp_restraints.adp_similarity_residuals(params, proxies=proxies)
    assert approx_equal(residuals, (a.residual(),a.residual()))
    deltas_rms = adp_restraints.adp_similarity_deltas_rms(params, proxies=proxies)
    assert approx_equal(deltas_rms, (a.rms_deltas(),a.rms_deltas()))
    residual_sum = adp_restraints.adp_similarity_residual_sum(
      params,
      proxies=proxies,
      gradients_aniso_cart=gradients_aniso_cart,
      gradients_iso=gradients_iso)
    assert approx_equal(residual_sum, 2 * a.residual())
    fd_grads_aniso, fd_grads_iso = finite_difference_gradients(
      restraint_type=adp_restraints.adp_similarity,
      proxy=p,
      u_cart=u_cart,
      u_iso=u_iso,
      use_u_aniso=use_u_aniso)
    for g,e in zip(gradients_aniso_cart, fd_grads_aniso):
      assert approx_equal(g,  matrix.col(e)*2)
    for g,e in zip(gradients_iso, fd_grads_iso):
      assert approx_equal(g, e*2)
  #
  # check frame invariance of residual
  #
  u_cart_1 = matrix.sym(sym_mat3=(0.1,0.2,0.05,0.03,0.02,0.01))
  u_cart_2 = matrix.sym(sym_mat3=(0.21,0.32,0.11,0.02,0.02,0.07))
  u_cart = (u_cart_1.as_sym_mat3(),u_cart_2.as_sym_mat3())
  u_iso = (-1, -1)
  use_u_aniso = (True, True)
  a = adp_restraints.adp_similarity(u_cart, weight=1)
  expected_residual = a.residual()
  gen = flex.mersenne_twister()
  for i in range(20):
    R = matrix.rec(gen.random_double_r3_rotation_matrix(),(3,3))
    u_cart_1_rot = R * u_cart_1 * R.transpose()
    u_cart_2_rot = R * u_cart_2 * R.transpose()
    u_cart = (u_cart_1_rot.as_sym_mat3(),u_cart_2_rot.as_sym_mat3())
    a = adp_restraints.adp_similarity(u_cart, weight=1)
    assert approx_equal(a.residual(), expected_residual)
コード例 #24
0
def _show_sorted_impl(self,
                      proxy_type,
                      proxy_label,
                      item_label,
                      by_value,
                      u_cart,
                      u_iso=None,
                      use_u_aniso=None,
                      sites_cart=None,
                      site_labels=None,
                      f=None,
                      prefix="",
                      max_items=None):
    assert by_value in ["residual", "rms_deltas", "delta"]
    assert site_labels is None or len(site_labels) == u_cart.size()
    assert sites_cart is None or len(sites_cart) == u_cart.size()
    assert [u_iso, use_u_aniso].count(None) in (0, 2)
    if (f is None): f = sys.stdout
    print >> f, "%s%s restraints: %d" % (prefix, proxy_label, self.size())
    if (self.size() == 0): return
    if (max_items is not None and max_items <= 0): return

    from cctbx.adp_restraints import adp_restraint_params
    if use_u_aniso is None: use_u_aniso = []
    if sites_cart is None: sites_cart = []
    if u_iso is None: u_iso = []
    params = adp_restraint_params(sites_cart=sites_cart,
                                  u_cart=u_cart,
                                  u_iso=u_iso,
                                  use_u_aniso=use_u_aniso)
    if (by_value == "residual"):
        if proxy_type in (adp_similarity, adp_u_eq_similarity, adp_volume_similarity,\
                          isotropic_adp, fixed_u_eq_adp, rigid_bond):
            data_to_sort = self.residuals(params=params)
        else:
            raise AssertionError
    elif (by_value == "rms_deltas"):
        if proxy_type in (adp_similarity, adp_u_eq_similarity, adp_volume_similarity,\
                          isotropic_adp, fixed_u_eq_adp):
            data_to_sort = self.deltas_rms(params=params)
        else:
            raise AssertionError
    elif (by_value == "delta"):
        if proxy_type is rigid_bond:
            data_to_sort = flex.abs(self.deltas(params=params))
        else:
            raise AssertionError
    else:
        raise AssertionError
    i_proxies_sorted = flex.sort_permutation(data=data_to_sort, reverse=True)
    if (max_items is not None):
        i_proxies_sorted = i_proxies_sorted[:max_items]
    item_label_blank = " " * len(item_label)
    print >> f, "%sSorted by %s:" % (prefix, by_value)
    dynamic_proxy_types = (
        adp_u_eq_similarity,
        adp_volume_similarity,
    )
    for i_proxy in i_proxies_sorted:
        proxy = self[i_proxy]
        s = item_label
        if proxy_type in (isotropic_adp, fixed_u_eq_adp):
            if (site_labels is None): l = str(proxy.i_seqs[0])
            else: l = site_labels[proxy.i_seqs[0]]
            print >> f, "%s%s %s" % (prefix, s, l)
            s = item_label_blank
        elif proxy_type in dynamic_proxy_types:
            restraint = proxy_type(params=params, proxy=proxy)
            restraint._show_sorted_item(f=f, prefix=prefix)
            print >> f, \
              "%s         delta" % (prefix)
            for n, i_seq in enumerate(proxy.i_seqs):
                if (site_labels is None): l = str(i_seq)
                else: l = site_labels[i_seq]
                print >> f, "%s %s %9.2e" % (prefix, l, restraint.deltas()[n])
        else:
            for n, i_seq in enumerate(proxy.i_seqs):
                if (site_labels is None): l = str(i_seq)
                else: l = site_labels[i_seq]
                print >> f, "%s%s %s" % (prefix, s, l)
                s = item_label_blank
        if proxy_type in (adp_similarity, isotropic_adp, fixed_u_eq_adp,\
                          rigid_bond):
            restraint = proxy_type(params=params, proxy=proxy)
            restraint._show_sorted_item(f=f, prefix=prefix)
        elif proxy_type in dynamic_proxy_types:
            pass
        else:
            raise AssertionError
    n_not_shown = self.size() - i_proxies_sorted.size()
    if (n_not_shown != 0):
        print >> f, prefix + "... (remaining %d not shown)" % n_not_shown
コード例 #25
0
def exercise_rigid_bond():
  i_seqs = (1,2)
  weight = 1
  p = adp_restraints.rigid_bond_proxy(i_seqs=i_seqs,weight=weight)
  assert p.i_seqs == i_seqs
  assert p.weight == weight
  sites = ((1,2,3),(2,3,4))
  u_cart = ((1,2,3,4,5,6), (3,4,5,6,7,8))
  expected_gradients = ((-4, -4, -4, -8, -8, -8), (4, 4, 4, 8, 8, 8))
  r = adp_restraints.rigid_bond(sites=sites, u_cart=u_cart, weight=weight)
  assert r.weight == weight
  assert approx_equal(r.delta_z(), -6)
  assert approx_equal(r.residual(), 36)
  assert approx_equal(r.gradients(), expected_gradients)
  sites_cart = flex.vec3_double(((1,2,3),(2,5,4),(3,4,5)))
  u_cart = flex.sym_mat3_double(((1,2,3,4,5,6),
                                 (2,3,3,5,7,7),
                                 (3,4,5,3,7,8)))
  r = adp_restraints.rigid_bond(
    adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart),
    proxy=p)
  assert approx_equal(r.weight, weight)
  unit_cell = uctbx.unit_cell([15,25,30,90,90,90])
  sites_frac = unit_cell.fractionalize(sites_cart=sites_cart)
  u_star = flex.sym_mat3_double([
    adptbx.u_cart_as_u_star(unit_cell, u_cart_i)
    for u_cart_i in u_cart])
  pair = adp_restraints.rigid_bond_pair(sites_frac[1],
                                     sites_frac[2],
                                     u_star[1],
                                     u_star[2],
                                     unit_cell)
  assert approx_equal(pair.delta_z(), abs(r.delta_z()))
  assert approx_equal(pair.z_12(), r.z_12())
  assert approx_equal(pair.z_21(), r.z_21())
  #
  gradients_aniso_cart = flex.sym_mat3_double(sites_cart.size(), (0,0,0,0,0,0))
  gradients_iso = flex.double(sites_cart.size(), 0)
  proxies = adp_restraints.shared_rigid_bond_proxy([p,p])
  params = adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart)
  residuals = adp_restraints.rigid_bond_residuals(params, proxies=proxies)
  assert approx_equal(residuals, (r.residual(),r.residual()))
  deltas = adp_restraints.rigid_bond_deltas(params, proxies=proxies)
  assert approx_equal(deltas, (r.delta_z(),r.delta_z()))
  residual_sum = adp_restraints.rigid_bond_residual_sum(
    params=params,
    proxies=proxies,
    gradients_aniso_cart=gradients_aniso_cart)
  assert approx_equal(residual_sum, 2 * r.residual())
  for g,e in zip(gradients_aniso_cart[1:3], r.gradients()):
    assert approx_equal(g, matrix.col(e)*2)
  fd_grads_aniso, fd_grads_iso = finite_difference_gradients(
    restraint_type=adp_restraints.rigid_bond,
    proxy=p,
    sites_cart=sites_cart,
    u_cart=u_cart)
  for g,e in zip(gradients_aniso_cart, fd_grads_aniso):
    assert approx_equal(g, matrix.col(e)*2)
  #
  # check frame invariance of residual
  #
  u_cart_1 = matrix.sym(sym_mat3=(0.1,0.2,0.05,0.03,0.02,0.01))
  u_cart_2 = matrix.sym(sym_mat3=(0.21,0.32,0.11,0.02,0.02,0.07))
  u_cart = (u_cart_1.as_sym_mat3(),u_cart_2.as_sym_mat3())
  site_cart_1 = matrix.col((1,2,3))
  site_cart_2 = matrix.col((3,1,4.2))
  sites = (tuple(site_cart_1),tuple(site_cart_2))
  a = adp_restraints.rigid_bond(sites=sites, u_cart=u_cart, weight=1)
  expected_residual = a.residual()
  gen = flex.mersenne_twister()
  for i in range(20):
    R = matrix.rec(gen.random_double_r3_rotation_matrix(),(3,3))
    u_cart_1_rot = R * u_cart_1 * R.transpose()
    u_cart_2_rot = R * u_cart_2 * R.transpose()
    u_cart = (u_cart_1_rot.as_sym_mat3(),u_cart_2_rot.as_sym_mat3())
    site_cart_1_rot = R * site_cart_1
    site_cart_2_rot = R * site_cart_2
    sites = (tuple(site_cart_1_rot),tuple(site_cart_2_rot))
    a = adp_restraints.rigid_bond(
      sites=sites, u_cart=u_cart,
      weight=1)
    assert approx_equal(a.residual(), expected_residual)
コード例 #26
0
def exercise_adp_similarity():
  u_cart = ((1,3,2,4,3,6),(2,4,2,6,5,1))
  u_iso = (-1,-1)
  use_u_aniso = (True, True)
  weight = 1
  a = adp_restraints.adp_similarity(
    u_cart=u_cart,
    weight=weight)
  assert approx_equal(a.use_u_aniso, use_u_aniso)
  assert a.weight == weight
  assert approx_equal(a.residual(), 68)
  assert approx_equal(a.gradients2(),
    ((-2.0, -2.0, 0.0, -8.0, -8.0, 20.0), (2.0, 2.0, -0.0, 8.0, 8.0, -20.0)))
  assert approx_equal(a.deltas(), (-1.0, -1.0, 0.0, -2.0, -2.0, 5.0))
  assert approx_equal(a.rms_deltas(), 2.7487370837451071)
  #
  u_cart = ((1,3,2,4,3,6),(-1,-1,-1,-1,-1,-1))
  u_iso = (-1,2)
  use_u_aniso = (True, False)
  a = adp_restraints.adp_similarity(
    u_cart[0], u_iso[1], weight=weight)
  assert approx_equal(a.use_u_aniso, use_u_aniso)
  assert a.weight == weight
  assert approx_equal(a.residual(), 124)
  assert approx_equal(a.gradients2(),
    ((-2, 2, 0, 16, 12, 24), (2, -2, 0, -16, -12, -24)))
  assert approx_equal(a.deltas(), (-1, 1, 0, 4, 3, 6))
  assert approx_equal(a.rms_deltas(), 3.711842908553348)
  #
  i_seqs_aa = (1,2) # () - ()
  i_seqs_ai = (1,0) # () - o
  i_seqs_ia = (3,2) #  o - ()
  i_seqs_ii = (0,3) #  o - o
  p_aa = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_aa,weight=weight)
  p_ai = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_ai,weight=weight)
  p_ia = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_ia,weight=weight)
  p_ii = adp_restraints.adp_similarity_proxy(i_seqs=i_seqs_ii,weight=weight)
  assert p_aa.i_seqs == i_seqs_aa
  assert p_aa.weight == weight
  u_cart = flex.sym_mat3_double(((-1,-1,-1,-1,-1,-1),
                                 (1,2,2,4,3,6),
                                 (2,4,2,6,5,1),
                                 (-1,-1,-1,-1,-1,-1)))
  u_iso = flex.double((1,-1,-1,2))
  use_u_aniso = flex.bool((False, True,True,False))
  for p in (p_aa,p_ai,p_ia,p_ii):
    params = adp_restraint_params(u_cart=u_cart, u_iso=u_iso, use_u_aniso=use_u_aniso)
    a = adp_restraints.adp_similarity(params, proxy=p)
    assert approx_equal(a.weight, weight)
    #
    gradients_aniso_cart = flex.sym_mat3_double(u_cart.size(), (0,0,0,0,0,0))
    gradients_iso = flex.double(u_cart.size(), 0)
    proxies = adp_restraints.shared_adp_similarity_proxy([p,p])
    residuals = adp_restraints.adp_similarity_residuals(params, proxies=proxies)
    assert approx_equal(residuals, (a.residual(),a.residual()))
    deltas_rms = adp_restraints.adp_similarity_deltas_rms(params, proxies=proxies)
    assert approx_equal(deltas_rms, (a.rms_deltas(),a.rms_deltas()))
    residual_sum = adp_restraints.adp_similarity_residual_sum(
      params,
      proxies=proxies,
      gradients_aniso_cart=gradients_aniso_cart,
      gradients_iso=gradients_iso)
    assert approx_equal(residual_sum, 2 * a.residual())
    fd_grads_aniso, fd_grads_iso = finite_difference_gradients(
      restraint_type=adp_restraints.adp_similarity,
      proxy=p,
      u_cart=u_cart,
      u_iso=u_iso,
      use_u_aniso=use_u_aniso)
    for g,e in zip(gradients_aniso_cart, fd_grads_aniso):
      assert approx_equal(g,  matrix.col(e)*2)
    for g,e in zip(gradients_iso, fd_grads_iso):
      assert approx_equal(g, e*2)
  #
  # check frame invariance of residual
  #
  u_cart_1 = matrix.sym(sym_mat3=(0.1,0.2,0.05,0.03,0.02,0.01))
  u_cart_2 = matrix.sym(sym_mat3=(0.21,0.32,0.11,0.02,0.02,0.07))
  u_cart = (u_cart_1.as_sym_mat3(),u_cart_2.as_sym_mat3())
  u_iso = (-1, -1)
  use_u_aniso = (True, True)
  a = adp_restraints.adp_similarity(u_cart, weight=1)
  expected_residual = a.residual()
  gen = flex.mersenne_twister()
  for i in range(20):
    R = matrix.rec(gen.random_double_r3_rotation_matrix(),(3,3))
    u_cart_1_rot = R * u_cart_1 * R.transpose()
    u_cart_2_rot = R * u_cart_2 * R.transpose()
    u_cart = (u_cart_1_rot.as_sym_mat3(),u_cart_2_rot.as_sym_mat3())
    a = adp_restraints.adp_similarity(u_cart, weight=1)
    assert approx_equal(a.residual(), expected_residual)