Example #1
0
 def compute_target(self, sites_cart, selection=None):
     if (selection is not None):
         return maptbx.real_space_target_simple(unit_cell=self.unit_cell,
                                                density_map=self.target_map,
                                                sites_cart=sites_cart,
                                                selection=selection)
     else:
         return maptbx.real_space_target_simple(unit_cell=self.unit_cell,
                                                density_map=self.target_map,
                                                sites_cart=sites_cart)
Example #2
0
 def get_target_value(self, sites_cart, selection=None, target_map=None):
     if (target_map is None): target_map = self.target_map
     if (selection is None):
         return maptbx.real_space_target_simple(unit_cell=self.unit_cell,
                                                density_map=target_map,
                                                sites_cart=sites_cart)
     else:
         return maptbx.real_space_target_simple(unit_cell=self.unit_cell,
                                                density_map=target_map,
                                                sites_cart=sites_cart,
                                                selection=selection)
Example #3
0
 def get_target_value(self, sites_cart, selection=None):
   if(selection is None):
     return maptbx.real_space_target_simple(
       unit_cell   = self.unit_cell,
       density_map = self.target_map,
       sites_cart  = sites_cart)
   else:
     return maptbx.real_space_target_simple(
       unit_cell   = self.unit_cell,
       density_map = self.target_map,
       sites_cart  = sites_cart,
       selection   = selection)
Example #4
0
 def compute_functional_and_gradients(O):
   if (O.number_of_function_evaluations == 0):
     O.number_of_function_evaluations += 1
     return O.f_start, O.g_start
   O.number_of_function_evaluations += 1
   O.sites_cart_residue = flex.vec3_double(O.x)
   rs_f = maptbx.real_space_target_simple(
     unit_cell=O.unit_cell,
     density_map=O.density_map,
     sites_cart=O.sites_cart_residue,
     selection=flex.bool(O.sites_cart_residue.size(),True))
   O.real_space_target = rs_f
   rs_g = maptbx.real_space_gradients_simple(
     unit_cell=O.unit_cell,
     density_map=O.density_map,
     sites_cart=O.sites_cart_residue,
     delta=O.real_space_gradients_delta,
     selection=flex.bool(O.sites_cart_residue.size(),True))
   O.rs_f = rs_f
   rs_f *= -O.real_space_target_weight
   rs_g *= -O.real_space_target_weight
   if (O.geometry_restraints_manager is None):
     f = rs_f
     g = rs_g
   else:
     O.sites_cart_all.set_selected(O.residue_i_seqs, O.sites_cart_residue)
     gr_e = O.geometry_restraints_manager.energies_sites(
       sites_cart=O.sites_cart_all, compute_gradients=True)
     f = rs_f + gr_e.target
     g = rs_g + gr_e.gradients.select(indices=O.residue_i_seqs)
   return f, g.as_double()
Example #5
0
 def compute_functional_and_gradients(O):
   if (O.number_of_function_evaluations == 0):
     O.number_of_function_evaluations += 1
     return O.f_start, O.g_start
   O.number_of_function_evaluations += 1
   O.residue_tardy_model.unpack_q(q_packed=O.x)
   O.sites_cart_residue = O.residue_tardy_model.sites_moved()
   rs_f = maptbx.real_space_target_simple(
     unit_cell=O.unit_cell,
     density_map=O.density_map,
     sites_cart=O.sites_cart_residue,
     selection=flex.bool(O.sites_cart_residue.size(),True))
   rs_g = real_space_rigid_body_gradients_simple(
     unit_cell=O.unit_cell,
     density_map=O.density_map,
     sites_cart_0=O.sites_cart_residue_0,
     center_of_mass=O.residue_center_of_mass,
     q=O.x)
   O.rs_f = rs_f
   rs_f *= -O.real_space_target_weight
   rs_g *= -O.real_space_target_weight
   if (O.geometry_restraints_manager is None):
     f = rs_f
     g = rs_g
   else:
     O.sites_cart_all.set_selected(O.residue_i_seqs, O.sites_cart_residue)
     gr_e = O.geometry_restraints_manager.energies_sites(
       sites_cart=O.sites_cart_all, compute_gradients=True)
     O.__d_e_pot_d_sites = gr_e.gradients.select(indices=O.residue_i_seqs)
     f = rs_f + gr_e.target
     g = rs_g + O.residue_tardy_model.d_e_pot_d_q_packed()
   return f, g.as_double()
Example #6
0
 def __init__(self,
              unit_cell,
              target_map,
              residue,
              vector = None,
              selection=None):
   adopt_init_args(self, locals())
   self.target = None
   self.sites_cart = None
   self.i_seqs = []
   self.weights = flex.double()
   for el in self.residue.atoms().extract_element():
     std_lbl = eltbx.xray_scattering.get_standard_label(
       label=el, exact=True, optional=True)
     self.weights.append(tiny_pse.table(std_lbl).weight())
   self.occ = self.residue.atoms().extract_occ()
   self.vector_flat = None
   if(vector is not None):
     self.vector_flat = flex.size_t(flatten(self.vector))
   self.sites_cart = self.residue.atoms().extract_xyz()
   if(selection is None): selection = self.vector_flat
   self.target = maptbx.real_space_target_simple(
     unit_cell   = self.unit_cell,
     density_map = self.target_map,
     sites_cart  = self.sites_cart,
     selection   = selection)
Example #7
0
 def __init__(self, pdb_hierarchy, unit_cell, map_data):
   adopt_init_args(self, locals())
   self.sites_cart = self.pdb_hierarchy.atoms().extract_xyz()
   self.target = maptbx.real_space_target_simple(
     unit_cell   = self.unit_cell,
     density_map = self.map_data,
     sites_cart  = self.sites_cart)
Example #8
0
 def compute_functional_and_gradients(self):
   if (self.number_of_function_evaluations == 0):
     self.number_of_function_evaluations += 1
     return self.f_start, self.g_start
   self.number_of_function_evaluations += 1
   self.residue_tardy_model.unpack_q(q_packed=self.x)
   self.sites_cart_residue = self.residue_tardy_model.sites_moved()
   if(self.states_collector is not None):
     self.states_collector.add(sites_cart = self.sites_cart_residue)
   rs_f = maptbx.real_space_target_simple(
     unit_cell=self.unit_cell,
     density_map=self.density_map,
     sites_cart=self.sites_cart_residue,
     selection=flex.bool(self.sites_cart_residue.size(),True))
   rs_g = real_space_rigid_body_gradients_simple(
     unit_cell=self.unit_cell,
     density_map=self.density_map,
     sites_cart_0=self.sites_cart_residue_0,
     center_of_mass=self.residue_center_of_mass,
     q=self.x)
   self.rs_f = rs_f
   rs_f *= -self.real_space_target_weight
   rs_g *= -self.real_space_target_weight
   if (self.geometry_restraints_manager is None):
     f = rs_f
     g = rs_g
   else:
     gr_e = self.geometry_restraints_manager.energies_sites(
       sites_cart=self.sites_cart_residue,
       flags = self.cctbx_geometry_restraints_flags,
       compute_gradients=True)
     self.__d_e_pot_d_sites = gr_e.gradients
     f = rs_f + gr_e.target
     g = rs_g + self.residue_tardy_model.d_e_pot_d_q_packed()
   return f, g.as_double()
Example #9
0
 def __init__(self,
              unit_cell,
              target_map,
              residue,
              vector=None,
              selection=None):
     adopt_init_args(self, locals())
     self.target = None
     self.sites_cart = None
     self.i_seqs = []
     self.weights = flex.double()
     for el in self.residue.atoms().extract_element():
         std_lbl = eltbx.xray_scattering.get_standard_label(label=el,
                                                            exact=True,
                                                            optional=True)
         self.weights.append(tiny_pse.table(std_lbl).weight())
     self.occ = self.residue.atoms().extract_occ()
     self.vector_flat = None
     if (vector is not None):
         self.vector_flat = flex.size_t(flatten(self.vector))
     self.sites_cart = self.residue.atoms().extract_xyz()
     if (selection is None): selection = self.vector_flat
     self.target = maptbx.real_space_target_simple(
         unit_cell=self.unit_cell,
         density_map=self.target_map,
         sites_cart=self.sites_cart,
         selection=selection)
Example #10
0
 def compute_functional_and_gradients(self):
   if (self.number_of_function_evaluations == 0):
     self.number_of_function_evaluations += 1
     return self.f_start, self.g_start
   self.number_of_function_evaluations += 1
   self.residue_tardy_model.unpack_q(q_packed=self.x)
   self.sites_cart_residue = self.residue_tardy_model.sites_moved()
   if(self.states_collector is not None):
     self.states_collector.add(sites_cart = self.sites_cart_residue)
   rs_f = maptbx.real_space_target_simple(
     unit_cell=self.unit_cell,
     density_map=self.density_map,
     sites_cart=self.sites_cart_residue,
     selection=flex.bool(self.sites_cart_residue.size(),True))
   rs_g = real_space_rigid_body_gradients_simple(
     unit_cell=self.unit_cell,
     density_map=self.density_map,
     sites_cart_0=self.sites_cart_residue_0,
     center_of_mass=self.residue_center_of_mass,
     q=self.x)
   self.rs_f = rs_f
   rs_f *= -self.real_space_target_weight
   rs_g *= -self.real_space_target_weight
   if (self.geometry_restraints_manager is None):
     f = rs_f
     g = rs_g
   else:
     gr_e = self.geometry_restraints_manager.energies_sites(
       sites_cart=self.sites_cart_residue,
       flags = self.cctbx_geometry_restraints_flags,
       compute_gradients=True)
     self.__d_e_pot_d_sites = gr_e.gradients
     f = rs_f + gr_e.target
     g = rs_g + self.residue_tardy_model.d_e_pot_d_q_packed()
   return f, g.as_double()
 def update(self, sites_cart):
     target = maptbx.real_space_target_simple(unit_cell=self.unit_cell,
                                              density_map=self.map_data,
                                              sites_cart=sites_cart)
     if (target > self.target):
         self.target = target
         self.sites_cart = sites_cart
Example #12
0
 def compute_functional_and_gradients(O):
   if (O.number_of_function_evaluations == 0):
     O.number_of_function_evaluations += 1
     return O.f_start, O.g_start
   O.number_of_function_evaluations += 1
   O.sites_cart_variable = flex.vec3_double(O.x)
   if (O.real_space_target_weight == 0):
     rs_f = 0.
     rs_g = flex.vec3_double(O.sites_cart_variable.size(), (0,0,0))
   else:
     if (O.local_standard_deviations_radius is None):
       rs_f = maptbx.real_space_target_simple(
         unit_cell   = O.unit_cell,
         density_map = O.density_map,
         sites_cart  = O.sites_cart_variable,
         selection   = O.selection_variable_real_space)
       rs_g = maptbx.real_space_gradients_simple(
         unit_cell   = O.unit_cell,
         density_map = O.density_map,
         sites_cart  = O.sites_cart_variable,
         delta       = O.real_space_gradients_delta,
         selection   = O.selection_variable_real_space)
     else:
       rs_f = local_standard_deviations_target(
         unit_cell=O.unit_cell,
         density_map=O.density_map,
         weight_map=O.weight_map,
         weight_map_scale_factor=O.weight_map_scale_factor,
         sites_cart=O.sites_cart_variable,
         site_radii=O.site_radii)
       rs_g = local_standard_deviations_gradients(
         unit_cell=O.unit_cell,
         density_map=O.density_map,
         weight_map=O.weight_map,
         weight_map_scale_factor=O.weight_map_scale_factor,
         sites_cart=O.sites_cart_variable,
         site_radii=O.site_radii,
         delta=O.real_space_gradients_delta)
     rs_f *= -O.real_space_target_weight
     rs_g *= -O.real_space_target_weight
   if (O.geometry_restraints_manager is None):
     f = rs_f
     g = rs_g
   else:
     if (O.selection_variable is None):
       O.sites_cart = O.sites_cart_variable
     else:
       O.sites_cart.set_selected(O.selection_variable, O.sites_cart_variable)
       if(O.states_collector is not None):
         O.states_collector.add(sites_cart = O.sites_cart)
     gr_e = O.geometry_restraints_manager.energies_sites(
       sites_cart=O.sites_cart,
       compute_gradients=True)
     gr_e_gradients = gr_e.gradients
     if (O.selection_variable is not None):
       gr_e_gradients = gr_e.gradients.select(O.selection_variable)
     f = rs_f + gr_e.target
     g = rs_g + gr_e_gradients
   return f, g.as_double()
Example #13
0
 def update(self, sites_cart):
     target = maptbx.real_space_target_simple(
         unit_cell=self.unit_cell, density_map=self.map_data, sites_cart=sites_cart
     )
     if target > self.target:
         self.target = target
         self.sites_cart = sites_cart
     print self.target, target  # XXX for debugging
 def show_target(self, prefix):
     if (self.show):
         print(prefix,
               maptbx.real_space_target_simple(
                   unit_cell=self.xray_structure.unit_cell(),
                   density_map=self.map_data,
                   sites_cart=self.xray_structure.sites_cart()),
               file=self.log)
Example #15
0
 def update(self, sites_cart, selection=None):
     if (selection is None): selection = self.vector_flat
     target = maptbx.real_space_target_simple(unit_cell=self.unit_cell,
                                              density_map=self.target_map,
                                              sites_cart=sites_cart,
                                              selection=selection)
     if (target > self.target):
         self.sites_cart = sites_cart
         self.target = target
Example #16
0
 def e_pot(O, sites_moved):
   if (   O.last_sites_moved is None
       or O.last_sites_moved.id() is not sites_moved.id()):
     O.last_sites_moved = sites_moved
     sites_cart = sites_moved
     #
     if (O.reduced_geo_manager is None):
       flags = None
       if (O.orca_experiments):
         flags = cctbx.geometry_restraints.flags.flags(
           nonbonded=False, default=True)
     else:
       # computing nonbonded interactions only with geo_manager,
       # contributions from other restraints below with reduced_geo_manager
       flags = cctbx.geometry_restraints.flags.flags(
         nonbonded=True, default=False)
     geo_energies = O.geo_manager.energies_sites(
       sites_cart=sites_cart,
       flags=flags,
       custom_nonbonded_function=O.custom_nonbonded_function,
       compute_gradients=True)
     if (0): # XXX orca_experiments
       print "geo_energies:"
       geo_energies.show()
     if (0): # XXX orca_experiments
       O.geo_manager.show_sorted(site_labels=O.site_labels)
     O.f = geo_energies.target
     O.g = geo_energies.gradients
     if (O.reduced_geo_manager is not None):
       reduced_geo_energies = O.reduced_geo_manager.energies_sites(
         sites_cart=sites_cart,
         compute_gradients=True)
       O.f += reduced_geo_energies.target
       O.g += reduced_geo_energies.gradients
     O.last_grms = group_args(geo=flex.mean_sq(O.g.as_double())**0.5)
     #
     if (O.density_map is not None):
       rs_f = maptbx.real_space_target_simple(
         unit_cell=O.geo_manager.crystal_symmetry.unit_cell(),
         density_map=O.density_map,
         sites_cart=sites_cart,
         selection=flex.bool(sites_cart.size(),True))
       rs_g = maptbx.real_space_gradients_simple(
         unit_cell=O.geo_manager.crystal_symmetry.unit_cell(),
         density_map=O.density_map,
         sites_cart=sites_cart,
         delta=O.real_space_gradients_delta,
         selection=flex.bool(sites_cart.size(),True))
       rs_f *= -O.real_space_target_weight
       rs_g *= -O.real_space_target_weight
       O.f += rs_f
       O.g += rs_g
       O.last_grms.real = flex.mean_sq(rs_g.as_double())**0.5
       O.last_grms.real_or_xray = "real"
     #
     O.last_grms.total = flex.mean_sq(O.g.as_double())**0.5
   return O.f
Example #17
0
 def update(self, sites_cart, selection=None):
   if(selection is None): selection = self.vector_flat
   target = maptbx.real_space_target_simple(
     unit_cell   = self.unit_cell,
     density_map = self.target_map,
     sites_cart  = sites_cart,
     selection   = selection)
   if(target > self.target):
     self.sites_cart = sites_cart
     self.target = target
Example #18
0
 def check():
   map = flex.double(flex.grid(22,26,36).set_focus(22,26,34))
   site_frac = [i/n for i,n in zip(grid_point, map.focus())]
   sites_cart = flex.vec3_double([uc.orthogonalize(site_frac)])
   target = maptbx.real_space_target_simple(
     unit_cell=uc, density_map=map, sites_cart=sites_cart,
     selection=flex.bool(sites_cart.size(), True))
   assert approx_equal(target, 0)
   terms = maptbx.real_space_target_simple_per_site(
     unit_cell=uc, density_map=map, sites_cart=sites_cart)
   assert approx_equal(terms, [0])
   grads = maptbx.real_space_gradients_simple(
     unit_cell=uc, density_map=map, sites_cart=sites_cart, delta=0.1,
     selection=flex.bool(sites_cart.size(), True))
   assert approx_equal(grads, [(0,0,0)])
   grid_point_mod = [i%n for i,n in zip(grid_point, map.focus())]
   map[grid_point_mod] = 1
   target = maptbx.real_space_target_simple(
     unit_cell=uc, density_map=map, sites_cart=sites_cart,
     selection=flex.bool(sites_cart.size(), True))
   assert approx_equal(target, 1)
   terms = maptbx.real_space_target_simple_per_site(
     unit_cell=uc, density_map=map, sites_cart=sites_cart)
   assert approx_equal(terms, [1])
   grads = maptbx.real_space_gradients_simple(
     unit_cell=uc, density_map=map, sites_cart=sites_cart, delta=0.1,
     selection=flex.bool(sites_cart.size(), True))
   assert approx_equal(grads, [(0,0,0)])
   i,j,k = grid_point_mod
   u,v,w = map.focus()
   map[((i+1)%u,j,k)] = 0.3
   map[(i,(j+1)%v,k)] = 0.5
   map[(i,j,(k+1)%w)] = 0.7
   target = maptbx.real_space_target_simple(
     unit_cell=uc, density_map=map, sites_cart=sites_cart,
     selection=flex.bool(sites_cart.size(), True))
   assert approx_equal(target, 1)
   for delta in [0.1, 0.2]:
     grads = maptbx.real_space_gradients_simple(
       unit_cell=uc, density_map=map, sites_cart=sites_cart, delta=delta,
       selection=flex.bool(sites_cart.size(), True))
     assert approx_equal(grads, [(0.3,0.5,0.7)])
Example #19
0
 def __init__(self,
              unit_cell,
              target_map,
              residue,
              rotamer_eval):
   adopt_init_args(self, locals())
   self.target = None
   self.sites_cart = self.residue.atoms().extract_xyz()
   self.target_start = maptbx.real_space_target_simple(
       unit_cell   = self.unit_cell,
       density_map = self.target_map,
       sites_cart  = self.sites_cart)
Example #20
0
 def one_residue_tune_up(self, residue):
     re = self.rotamer_manager.rotamer_evaluator
     if (re.evaluate_residue(residue) == "OUTLIER"):
         sites_cart_start = residue.atoms().extract_xyz()
         mv1 = maptbx.real_space_target_simple(
             unit_cell=self.crystal_symmetry.unit_cell(),
             density_map=self.target_map,
             sites_cart=sites_cart_start)
         mmtbx.refinement.real_space.fit_residue.tune_up(
             residue=residue,
             unit_cell=self.crystal_symmetry.unit_cell(),
             target_map=self.target_map,
             mon_lib_srv=self.mon_lib_srv,
             rotamer_manager=self.rotamer_manager.rotamer_evaluator)
         mv2 = maptbx.real_space_target_simple(
             unit_cell=self.crystal_symmetry.unit_cell(),
             density_map=self.target_map,
             sites_cart=residue.atoms().extract_xyz())
         pshift = abs(abs(mv1) - abs(mv2)) / (
             (abs(mv1) + abs(mv2)) / 2) * 100.
         if (pshift < 3):
             self.sites_cart = self.pdb_hierarchy.atoms().extract_xyz()
         else:
             residue.atoms().set_xyz(sites_cart_start)
Example #21
0
 def get(i, delta):
   fs = []
   for signed_delta in [delta, -delta]:
     q_delta[i] = q[i] + signed_delta
     aja = matrix.rt(scitbx.rigid_body.joint_lib_six_dof_aja_simplified(
       center_of_mass=center_of_mass,
       q=q_delta))
     sites_cart_delta = aja * sites_cart_0
     rs_f = maptbx.real_space_target_simple(
       unit_cell=unit_cell,
       density_map=density_map,
       sites_cart=sites_cart_delta,
       selection=flex.bool(sites_cart_delta.size(),True))
     fs.append(rs_f)
   result.append((fs[0]-fs[1])/(2*delta))
Example #22
0
 def get(i, delta):
   fs = []
   for signed_delta in [delta, -delta]:
     q_delta[i] = q[i] + signed_delta
     aja = matrix.rt(scitbx.rigid_body.joint_lib_six_dof_aja_simplified(
       center_of_mass=center_of_mass,
       q=q_delta))
     sites_cart_delta = aja * sites_cart_0
     rs_f = maptbx.real_space_target_simple(
       unit_cell=unit_cell,
       density_map=density_map,
       sites_cart=sites_cart_delta,
       selection=flex.bool(sites_cart_delta.size(),True))
     fs.append(rs_f)
   result.append((fs[0]-fs[1])/(2*delta))
Example #23
0
def compute_functional_lite(pdb_hierarchy,
                            residue,
                            density_map,
                            geometry_restraints_manager,
                            real_space_target_weight):
  unit_cell = geometry_restraints_manager.crystal_symmetry.unit_cell()
  sites_cart_all = pdb_hierarchy.atoms().extract_xyz()
  residue_i_seqs = residue.atoms().extract_i_seq()
  x = sites_cart_all.select(indices=residue_i_seqs).as_double()
  sites_cart_residue = flex.vec3_double(x)
  rs_f = maptbx.real_space_target_simple(
    unit_cell=unit_cell,
    density_map=density_map,
    sites_cart=sites_cart_residue,
    selection=flex.bool(sites_cart_residue.size(),True))
  return rs_f
Example #24
0
def get_mean_side_chain_density_value_residue(residue, map_data, unit_cell):
    results = flex.double()
    get_class = iotbx.pdb.common_residue_names_get_class
    main_chain = ["N", "CA", "CB", "C", "O"]
    if (get_class(residue.resname) != "common_amino_acid"): return None
    sites_cart = flex.vec3_double()
    atoms = residue.atoms()
    for a in atoms:
        if (a.name.strip() in main_chain): continue
        sites_cart.append(a.xyz)
    if (sites_cart.size() == 0): return None
    mv = maptbx.real_space_target_simple(unit_cell=unit_cell,
                                         density_map=map_data,
                                         sites_cart=sites_cart)
    results.append(mv)
    return flex.mean_default(results, 0)
def exercise_03():
    """
  Exercise maptbx.target_and_gradients_simple.
  """
    def compute_map(xray_structure, d_min=1.5, resolution_factor=1. / 4):
        fc = xray_structure.structure_factors(d_min=d_min).f_calc()
        fft_map = fc.fft_map(resolution_factor=resolution_factor)
        fft_map.apply_sigma_scaling()
        result = fft_map.real_map_unpadded()
        return result, fc, fft_map

    xrs = random_structure.xray_structure(
        space_group_info=sgtbx.space_group_info("P212121"),
        elements=["N", "C", "O", "S", "P"] * 10,
        volume_per_atom=50)
    map_target, tmp, tmp = compute_map(xray_structure=xrs)
    xrs_sh = xrs.deep_copy_scatterers()
    xrs_sh.shake_sites_in_place(mean_distance=0.8)
    #
    t1 = maptbx.real_space_target_simple(unit_cell=xrs.unit_cell(),
                                         density_map=map_target,
                                         sites_cart=xrs_sh.sites_cart(),
                                         selection=flex.bool(
                                             xrs_sh.scatterers().size(), True))
    g1 = maptbx.real_space_gradients_simple(unit_cell=xrs.unit_cell(),
                                            density_map=map_target,
                                            sites_cart=xrs_sh.sites_cart(),
                                            delta=0.25,
                                            selection=flex.bool(
                                                xrs_sh.scatterers().size(),
                                                True))
    o = maptbx.target_and_gradients_simple(unit_cell=xrs.unit_cell(),
                                           map_target=map_target,
                                           sites_cart=xrs_sh.sites_cart(),
                                           delta=0.25,
                                           selection=flex.bool(
                                               xrs_sh.scatterers().size(),
                                               True))
    assert approx_equal(t1, o.target())
    for gi, gj in zip(g1, o.gradients()):
        assert approx_equal(gi, gj)
Example #26
0
def get_mean_side_chain_density_value(hierarchy, map_data, unit_cell):
    results = flex.double()
    get_class = iotbx.pdb.common_residue_names_get_class
    main_chain = ["N", "CA", "CB", "C", "O"]
    for model in hierarchy.models():
        for chain in model.chains():
            for residue_group in chain.residue_groups():
                conformers = residue_group.conformers()
                if (len(conformers) > 1): continue
                for conformer in residue_group.conformers():
                    residue = conformer.only_residue()
                    if (get_class(residue.resname) != "common_amino_acid"):
                        continue
                    sites_cart = flex.vec3_double()
                    atoms = residue.atoms()
                    for a in atoms:
                        if (a.name.strip() in main_chain): continue
                        sites_cart.append(a.xyz)
                    if (sites_cart.size() == 0): continue
                    mv = maptbx.real_space_target_simple(unit_cell=unit_cell,
                                                         density_map=map_data,
                                                         sites_cart=sites_cart)
                    results.append(mv)
    return flex.mean_default(results, 0)
  def fix_rama_outlier(self,
      pdb_hierarchy, out_res_num_list, prefix="", minimize=True,
      ss_annotation=None,
      tried_rama_angles_for_chain={},
      tried_final_rama_angles_for_chain={}):

    def comb_pair_in_bad_pairs(comb_pair, bad_pairs):
      if None in comb_pair:
        return False
      all_combs = [comb_pair]
      all_combs.append((comb_pair[0]-20, comb_pair[1]))
      all_combs.append((comb_pair[0]+20, comb_pair[1]))
      all_combs.append((comb_pair[0], comb_pair[1]-20))
      all_combs.append((comb_pair[0], comb_pair[1]+20))
      all_c_adj = []
      for p in all_combs:
        new_p = p
        if p[0] > 180:
          new_p = (p[0]-180, p[1])
        if p[0] < -180:
          new_p = (p[0]+180, p[1])
        if p[1] > 180:
          new_p = (p[0], p[1]-180)
        if p[0] < -180:
          new_p = (p[0], p[1]+180)
        all_c_adj.append(new_p)
      for p in all_c_adj:
        if p in bad_pairs:
          return True
      return False

    original_pdb_h = pdb_hierarchy.deep_copy()
    original_pdb_h.reset_atom_i_seqs()
    original_pdb_h_asc = original_pdb_h.atom_selection_cache()
    chain_id = original_pdb_h.only_model().only_chain().id
    all_results = []
    # only forward
    # variants_searches = [
    #     #ccd_radius, change_all, change_radius, direction_forward
    #     ((1, False, 0, True ),1),
    #     # ((1, False, 0, False),1),
    #     ((2, False, 0, True ),1),
    #     # ((2, False, 0, False),1),
    #     ((3, False, 0, True ),2),
    #     # ((3, False, 0, False),2),
    #     ((2, True,  1, True ),1),
    #     # ((2, True,  1, False),1),
    #     ((3, True,  1, True ),2),
    #     # ((3, True,  1, False),2),
    #     ((3, True,  2, True ),3),
    #     # ((3, True,  2, False),3),
    # ]
    # only backward
    # variants_searches = [
    #     #ccd_radius, change_all, change_radius, direction_forward
    #     # ((1, False, 0, True ),1),
    #     ((1, False, 0, False),1),
    #     # ((2, False, 0, True ),1),
    #     ((2, False, 0, False),1),
    #     # ((3, False, 0, True ),2),
    #     ((3, False, 0, False),2),
    #     # ((2, True,  1, True ),1),
    #     ((2, True,  1, False),1),
    #     # ((3, True,  1, True ),2),
    #     ((3, True,  1, False),2),
    #     # ((3, True,  2, True ),3),
    #     ((3, True,  2, False),3),
    # ]
    # both
    variants_searches = [
        #ccd_radius, change_all, change_radius, direction_forward
        ((1, False, 0, True ),1),
        ((1, False, 0, False),1),
        ((2, False, 0, True ),1),
        ((2, False, 0, False),1),
        ((3, False, 0, True ),2),
        ((3, False, 0, False),2),
        ((2, True,  1, True ),1),
        ((2, True,  1, False),1),
        ((3, True,  1, True ),2),
        ((3, True,  1, False),2),
        ((3, True,  2, True ),3),
        ((3, True,  2, False),3),
    ]
    decided_variants = []
    for variant, level in variants_searches:
      if level <= self.params.variant_search_level:
        decided_variants.append(variant)

    for ccd_radius, change_all, change_radius, direction_forward in decided_variants:
    # while ccd_radius <= 3:
      fixing_omega = False
      print >> self.log, "  Starting optimization with radius=%d, " % ccd_radius,
      print >> self.log, "change_all=%s, change_radius=%d, " % (change_all, change_radius),
      print >> self.log, "direction=forward" if direction_forward else "direction=backwards"
      self.log.flush()
      #
      (moving_h, moving_ref_atoms_iseqs, fixed_ref_atoms,
          m_selection, contains_ss_element, anchor_present) = get_fixed_moving_parts(
              pdb_hierarchy=pdb_hierarchy,
              out_res_num_list=out_res_num_list,
              # n_following=1,
              # n_previous=ccd_radius+ccd_radius-1,
              n_following=ccd_radius,
              n_previous=ccd_radius,
              ss_annotation=ss_annotation,
              direction_forward=direction_forward,
              log=self.log)
      # print "  moving_ref_atoms_iseqs", moving_ref_atoms_iseqs
      print "  moving_h resseqs:", [x.resseq for x in moving_h.residue_groups()]
      moving_h_set = []
      all_angles_combination_f = starting_conformations.get_all_starting_conformations(
          moving_h,
          change_radius,
          n_outliers=len(out_res_num_list),
          direction_forward=direction_forward,
          cutoff=self.params.variant_number_cutoff,
          change_all=change_all,
          # log=self.log,
          check_omega=self.params.make_all_trans,
          )

      #

      # print "len(all_angles_combination_f)", len(all_angles_combination_f)
      if len(all_angles_combination_f) == 0:
        print "In starting conformations - outlier was fixed?"
        # return result
      else:
        # here we should filter  first ones that in
        # tried_rama_angles_for_chain
        filter_out = [] # [[tried values],[tried values],...]
        for three in generate_protein_threes(
            hierarchy=moving_h,
            geometry=None):
          if three[1].resseq in tried_rama_angles_for_chain.keys():
            filter_out.append(tried_rama_angles_for_chain[three[1].resseq])
          else:
            filter_out.append((None, None))
        ff_all_angles = []
        print "filter_out", filter_out
        for comb in all_angles_combination_f:
          good = True
          for comb_pair, bad_pairs in zip(comb, filter_out):
            if bad_pairs == (None, None):
              continue
            # print "comb_pair, bad_pairs", comb_pair, bad_pairs
            # if comb_pair in bad_pairs:
            if comb_pair_in_bad_pairs(comb_pair, bad_pairs):
              good = False
              # print "  Rejecting comb_pair", comb_pair
              break
          if good:
            ff_all_angles.append(comb)
        print "len(all_angles_combination_f)", len(all_angles_combination_f)
        print "len(ff_all_angles)", len(ff_all_angles)
        n_added = 0
        n_all_combination = len(ff_all_angles)
        if n_all_combination == 0:
          print >> self.log, "Strange - got 0 combinations."
        i_max = min(self.params.variant_number_cutoff, n_all_combination)
        # assert i_max > 0
        step = 0
        if i_max > 1:
          step = float(n_all_combination-1)/float(i_max-1)
        if step < 1:
          step = 1
        for i in range(i_max):
          comb = ff_all_angles[int(round(step*i))]
          setted_h, fixed_omega = starting_conformations.set_rama_angles(
                  moving_h,
                  list(comb),
                  direction_forward=direction_forward,
                  check_omega=self.params.make_all_trans)
          fixing_omega = fixing_omega or fixed_omega
          moving_h_set.append(setted_h)
          # print >> self.log, "Model %d, angles:" % i, comb
          if self.params.make_all_trans and utils.n_bad_omegas(moving_h_set[-1]) != 0:
            print "Model_%d_angles_%s.pdb" % (i, comb),
            print "got ", utils.n_bad_omegas(moving_h_set[-1]), "bad omegas"
            moving_h_set[-1].write_pdb_file("Model_%d_angles_%s.pdb" % (i, comb))
            utils.list_omega(moving_h_set[-1], self.log)
            assert 0

      if len(moving_h_set) == 0:
        # outlier was fixed before somehow...
        # or there's a bug in get_starting_conformations
        print >> self.log, "outlier was fixed before somehow"
        return original_pdb_h
      print "self.tried_rama_angles inside", self.tried_rama_angles
      print "tried_rama_angles_for_chain", tried_rama_angles_for_chain
      print "checking values", ccd_radius, change_all, change_radius, direction_forward
      for i, h in enumerate(moving_h_set):
        # if [x in tried_rama_angles_for_chain.keys() for x in out_res_num_list].count(True) > 0:
        #   print >> self.log, "Warning!!! make something here (check angles or so)"
        #   print >> self.log, "Skipping nonstable solution, tried previously:", (ccd_radius, change_all, change_radius, direction_forward, i)
        #   continue
        resulting_rmsd = None
        n_iter = 0
        if anchor_present:
          fixed_ref_atoms_coors = [x.xyz for x in fixed_ref_atoms]
          # print "params to constructor", fixed_ref_atoms, h, moving_ref_atoms_iseqs
          # easy_pickle.dump(file_name="crash.pkl", obj=[
          #     fixed_ref_atoms_coors,
          #     h,
          #     moving_ref_atoms_iseqs,
          #     direction_forward,
          #     self.params.save_states])
          ccd_obj = ccd_cpp(fixed_ref_atoms_coors, h, moving_ref_atoms_iseqs)
          ccd_obj.run(direction_forward=direction_forward, save_states=self.params.save_states)
          resulting_rmsd = ccd_obj.resulting_rmsd
          n_iter = ccd_obj.n_iter

          if self.params.save_states:
            states = ccd_obj.states
            states.write(file_name="%s%s_%d_%s_%d_%i_states.pdb" % (chain_id, out_res_num_list[0], ccd_radius, change_all, change_radius, i))
        map_target = 0
        if self.reference_map is not None:
          map_target = maptbx.real_space_target_simple(
              unit_cell   = self.xrs.crystal_symmetry().unit_cell(),
              density_map = self.reference_map,
              sites_cart  = h.atoms().extract_xyz())

        mc_rmsd = get_main_chain_rmsd_range(moving_h, h, all_atoms=True)
        if self.verbose:
          print >> self.log, "Resulting anchor and backbone RMSDs, mapcc, n_iter for model %d:" % i,
          print >> self.log, resulting_rmsd, ",", mc_rmsd, ",", map_target, ",", n_iter
          self.log.flush()
        #
        # setting new coordinates
        #
        moved_with_side_chains_h = pdb_hierarchy.deep_copy()

        # setting xyz
        #
        for i_source, i_dest in enumerate(m_selection):
          moved_with_side_chains_h.atoms()[i_dest].set_xyz(h.atoms()[i_source].xyz)

        # set_xyz_smart(
        #     dest_h=moved_with_side_chains_h,
        #     source_h=h)

        #
        # placing side-chains
        #
        # moved_with_side_chains_h.write_pdb_file(
        #     file_name="%s_before_sc_placement_%d.pdb" % (prefix, i))
        placing_range = get_res_nums_around(moved_with_side_chains_h,
            center_resnum_list=out_res_num_list,
            n_following=ccd_radius,
            n_previous=ccd_radius,
            include_intermediate=True,
            avoid_ss_annot=ss_annotation)
        place_side_chains(moved_with_side_chains_h, original_pdb_h, original_pdb_h_asc,
            self.rotamer_manager, placing_range, self.ideal_res_dict)
        # moved_with_side_chains_h.write_pdb_file(
        #     file_name="%s_after_sc_placement_%d.pdb" % (prefix, i))


        #
        # finalizing with geometry_minimization
        #

        # determining angles of interest
        # print "Recording picked angle for outliers"
        threes = generate_protein_threes(
          # hierarchy=moving_h,
          hierarchy=h,
          geometry=None)
        start_angles = []
        final_angles = []
        for angle_pair, three in zip(ff_all_angles[int(round(step*i))], threes):
          # print "three[1].resseq in out_res_num_list, angle_pair", three[1].resseq, out_res_num_list, angle_pair
          if three[1].resseq in out_res_num_list:
            # if three[1].resseq not in tried_rama_angles_for_chain.keys():
            #   tried_rama_angles_for_chain[three[1].resseq] = []
            start_angles.append((three[1].resseq, angle_pair))
            ps_angles = three.get_phi_psi_angles()
            final_angles.append((three[1].resseq, tuple(ps_angles)))
            # tried_rama_angles_for_chain[three[1].resseq].append(angle_pair)
            # print >> self.log, "Ended up with", three[1].resseq, "%.1f %.1f" % (ps_angles[0], ps_angles[1])
        # print "Updated tried_rama_angles_for_chain:", tried_rama_angles_for_chain
        if (not self.ccd_solution_is_duplicated(
            final_angles=final_angles,
            tried_final_rama_angles_for_chain=tried_final_rama_angles_for_chain)):
          all_results.append((moved_with_side_chains_h.deep_copy(), mc_rmsd, resulting_rmsd, map_target, n_iter))
        else:
          continue
        if self.ccd_solution_is_ok(
            anchor_rmsd=resulting_rmsd,
            mc_rmsd=mc_rmsd,
            n_outliers=len(out_res_num_list),
            ccd_radius=ccd_radius,
            change_all_angles=change_all,
            change_radius=change_radius,
            contains_ss_element=contains_ss_element,
            fixing_omega=fixing_omega):
          print "Choosen result (mc_rmsd, anchor_rmsd, map_target, n_iter):", mc_rmsd, resulting_rmsd, map_target, n_iter
          # Save to tried_ccds
          for rn, angles in start_angles:
            if rn not in tried_rama_angles_for_chain.keys():
              tried_rama_angles_for_chain[rn] = []
            tried_rama_angles_for_chain[rn].append(angles)
          # Save final angles
          for rn, angles in final_angles:
            if rn not in tried_final_rama_angles_for_chain.keys():
              tried_final_rama_angles_for_chain[rn] = []
            tried_final_rama_angles_for_chain[rn].append(angles)
          print >> self.log, "Ended up with", final_angles
          print >> self.log, "Updated tried_rama_angles_for_chain:", tried_rama_angles_for_chain
          print >> self.log, "Updated tried_final_rama_angles_for_chain:", tried_final_rama_angles_for_chain

          self.log.flush()
          if minimize:
            print >> self.log, "minimizing..."
            # moved_with_side_chains_h.write_pdb_file(
            #     file_name="%s_result_before_min_%d.pdb" % (prefix, i))
            if self.reference_map is None:
              minimize_wrapper_for_ramachandran(
                  hierarchy=moved_with_side_chains_h,
                  xrs=xrs,
                  original_pdb_h=original_pdb_h,
                  log=self.log,
                  grm=self.grm,
                  ss_annotation=self.secondary_structure_annotation)
            else:
              mwwm = minimize_wrapper_with_map(
                  pdb_h=moved_with_side_chains_h,
                  xrs=xrs,
                  target_map=self.reference_map,
                  grm=self.grm,
                  ss_annotation=self.secondary_structure_annotation,
                  log=self.log)
          # moved_with_side_chains_h.write_pdb_file(
          #     file_name="%s_result_minimized_%d.pdb" % (prefix, i))
          final_rmsd = get_main_chain_rmsd_range(moved_with_side_chains_h,
              original_pdb_h, placing_range)
          print >> self.log, "FINAL RMSD after minimization:", final_rmsd
          return moved_with_side_chains_h


    all_results.sort(key=lambda tup: tup[1])
    if self.verbose:
      print >> self.log, "ALL RESULTS:"
      i = 0
      for ar in all_results:
        print >> self.log, ar[1:],
        if ar[2] < 0.4:
          # fn = "variant_%d.pdb" % i
          # ar[0].write_pdb_file(file_name=fn)
          # print fn
          i += 1
        else:
          print >> self.log, "  no output"
    if self.params.force_rama_fixes:
      # find and apply the best varian from all_results. This would be the one
      # with the smallest rmsd given satisfactory closure
      print >> self.log, "Applying the best found variant:",
      i = 0
      while i < len(all_results) and all_results[i][2] > 1.5:
        i += 1
      # apply
      # === duplication!!!!
      if i < len(all_results):
        print >> self.log, all_results[i][1:]
        if minimize:
          print >> self.log, "minimizing..."
          # all_results[i][0].write_pdb_file(
          #     file_name="%s_result_before_min_%d.pdb" % (prefix, i))
          if self.reference_map is None:
            minimize_wrapper_for_ramachandran(
                hierarchy=all_results[i][0],
                xrs=xrs,
                original_pdb_h=original_pdb_h,
                log=self.log,
                grm=self.grm,
                ss_annotation=self.secondary_structure_annotation)
          else:
            mwwm = minimize_wrapper_with_map(
                pdb_h=all_results[i][0],
                xrs=xrs,
                target_map=self.reference_map,
                grm=self.grm,
                ss_annotation=self.secondary_structure_annotation,
                log=self.log)
        # all_results[i][0].write_pdb_file(
        #     file_name="%s_result_minimized_%d.pdb" % (prefix, i))
        final_rmsd = get_main_chain_rmsd_range(all_results[i][0],
            original_pdb_h, placing_range)
        print >> self.log, "FINAL RMSD after minimization:", final_rmsd
        return all_results[i][0]
      else:
        print >> self.log, " NOT FOUND!"
        for i in all_results:
          print >> self.log, i[1:]
      # === end of duplication!!!!

    else:
      print >> self.log, "Epic FAIL: failed to fix rama outlier:", out_res_num_list
      print >> self.log, "  Options were: (mc_rmsd, resultign_rmsd, n_iter)"
      for i in all_results:
        print >> self.log, i[1:]
    return original_pdb_h
 def target(self):
   return -1.*maptbx.real_space_target_simple(
     unit_cell   = self.unit_cell,
     density_map = self.density_map,
     sites_cart  = self.sites_cart,
     selection   = self.selection)
 def show_target(self, prefix):
   if(self.show):
     print >> self.log, prefix, maptbx.real_space_target_simple(
         unit_cell   = self.xray_structure.unit_cell(),
         density_map = self.map_data,
         sites_cart  = self.xray_structure.sites_cart())
Example #30
0
 def target(self):
     return -1. * maptbx.real_space_target_simple(
         unit_cell=self.unit_cell,
         density_map=self.density_map,
         sites_cart=self.sites_cart,
         selection=self.selection)
Example #31
0
    def fix_rama_outlier(self,
                         pdb_hierarchy,
                         out_res_num,
                         prefix="",
                         minimize=True,
                         ss_annotation=None):

        original_pdb_h = pdb_hierarchy.deep_copy()
        original_pdb_h.reset_atom_i_seqs()
        chain_id = original_pdb_h.only_model().only_chain().id
        all_results = []
        variants_searches = [
            ((1, False, 0), 1),
            ((2, False, 0), 1),
            ((3, False, 0), 2),
            ((2, True, 1), 1),
            ((3, True, 1), 2),
            ((3, True, 2), 3),
        ]
        decided_variants = []
        for variant, level in variants_searches:
            if level <= self.params.variant_search_level:
                decided_variants.append(variant)

        for ccd_radius, change_all, change_radius in decided_variants:
            # while ccd_radius <= 3:
            print >> self.log, "  Starting optimization with radius, change_all, change_radius:", ccd_radius, change_all, change_radius
            self.log.flush()
            #
            moving_h, moving_ref_atoms_iseqs, fixed_ref_atoms, m_selection, contains_ss_element = get_fixed_moving_parts(
                pdb_hierarchy=pdb_hierarchy,
                out_res_num=out_res_num,
                n_following=ccd_radius,
                n_previous=ccd_radius,
                ss_annotation=ss_annotation)
            moving_h_set = None
            if change_all:
                moving_h_set = starting_conformations.get_all_starting_conformations(
                    moving_h,
                    change_radius,
                    cutoff=self.params.variant_number_cutoff,
                    # log=self.log,
                )
            else:
                moving_h_set = starting_conformations.get_starting_conformations(
                    moving_h,
                    cutoff=self.params.variant_number_cutoff,
                    # log=self.log,
                )

            if len(moving_h_set) == 0:
                # outlier was fixed before somehow...
                # or there's a bug in get_starting_conformations
                return original_pdb_h

            for i, h in enumerate(moving_h_set):
                fixed_ref_atoms_coors = [x.xyz for x in fixed_ref_atoms]
                # print "params to constructor", fixed_ref_atoms, h, moving_ref_atoms_iseqs
                ccd_obj = ccd_cpp(fixed_ref_atoms_coors, h,
                                  moving_ref_atoms_iseqs)
                ccd_obj.run()
                resulting_rmsd = ccd_obj.resulting_rmsd
                n_iter = ccd_obj.n_iter

                # states = ccd_obj.states
                # if self.params.save_states:
                #   states.write(file_name="%s%s_%d_%s_%d_%i_states.pdb" % (chain_id, out_res_num, ccd_radius, change_all, change_radius, i))
                map_target = 0
                if self.reference_map is not None:
                    map_target = maptbx.real_space_target_simple(
                        unit_cell=self.xrs.crystal_symmetry().unit_cell(),
                        density_map=self.reference_map,
                        sites_cart=h.atoms().extract_xyz())

                mc_rmsd = get_main_chain_rmsd_range(moving_h,
                                                    h,
                                                    all_atoms=True)
                if self.verbose:
                    print >> self.log, "Resulting anchor and backbone RMSDs, mapcc, n_iter for model %d:" % i,
                    print >> self.log, resulting_rmsd, ",", mc_rmsd, ",", map_target, ",", n_iter
                    self.log.flush()
                #
                # setting new coordinates
                #
                moved_with_side_chains_h = pdb_hierarchy.deep_copy()

                # setting xyz
                #
                for i_source, i_dest in enumerate(m_selection):
                    moved_with_side_chains_h.atoms()[i_dest].set_xyz(
                        h.atoms()[i_source].xyz)

                # set_xyz_smart(
                #     dest_h=moved_with_side_chains_h,
                #     source_h=h)

                #
                # placing side-chains
                #
                # moved_with_side_chains_h.write_pdb_file(
                #     file_name="%s_before_sc_placement_%d.pdb" % (prefix, i))
                placing_range = get_res_nums_around(moved_with_side_chains_h,
                                                    center_resnum=out_res_num,
                                                    n_following=ccd_radius,
                                                    n_previous=ccd_radius,
                                                    include_intermediate=True)
                place_side_chains(moved_with_side_chains_h, original_pdb_h,
                                  self.rotamer_manager, placing_range)
                # moved_with_side_chains_h.write_pdb_file(
                #     file_name="%s_after_sc_placement_%d.pdb" % (prefix, i))

                #
                # finalizing with geometry_minimization
                #
                all_results.append(
                    (moved_with_side_chains_h.deep_copy(), mc_rmsd,
                     resulting_rmsd, map_target, n_iter))
                if self.ccd_solution_is_ok(
                        anchor_rmsd=resulting_rmsd,
                        mc_rmsd=mc_rmsd,
                        ccd_radius=ccd_radius,
                        change_all_angles=change_all,
                        change_radius=change_radius,
                        contains_ss_element=contains_ss_element):
                    print "Choosen result (mc_rmsd, anchor_rmsd, map_target, n_iter):", mc_rmsd, resulting_rmsd, map_target, n_iter
                    self.log.flush()
                    if minimize:
                        print >> self.log, "minimizing..."
                        # moved_with_side_chains_h.write_pdb_file(
                        #     file_name="%s_result_before_min_%d.pdb" % (prefix, i))
                        if self.reference_map is None:
                            minimize_wrapper_for_ramachandran(
                                hierarchy=moved_with_side_chains_h,
                                xrs=xrs,
                                original_pdb_h=original_pdb_h,
                                log=self.log,
                                grm=self.grm,
                                ss_annotation=self.
                                secondary_structure_annotation)
                        else:
                            mwwm = minimize_wrapper_with_map(
                                pdb_h=moved_with_side_chains_h,
                                xrs=xrs,
                                target_map=self.reference_map,
                                grm=self.grm,
                                ss_annotation=self.
                                secondary_structure_annotation,
                                log=self.log)
                    # moved_with_side_chains_h.write_pdb_file(
                    #     file_name="%s_result_minimized_%d.pdb" % (prefix, i))
                    final_rmsd = get_main_chain_rmsd_range(
                        moved_with_side_chains_h, original_pdb_h,
                        placing_range)
                    print >> self.log, "FINAL RMSD after minimization:", final_rmsd
                    return moved_with_side_chains_h

        all_results.sort(key=lambda tup: tup[1])
        if self.verbose:
            print >> self.log, "ALL RESULTS:"
            i = 0
            for ar in all_results:
                print >> self.log, ar[1:],
                if ar[2] < 0.4:
                    # fn = "variant_%d.pdb" % i
                    # ar[0].write_pdb_file(file_name=fn)
                    # print fn
                    i += 1
                else:
                    print >> self.log, "  no output"
        if self.params.force_rama_fixes:
            # find and apply the best varian from all_results. This would be the one
            # with the smallest rmsd given satisfactory closure
            print >> self.log, "Applying the best found variant:",
            i = 0
            while i < len(all_results) and all_results[i][2] > 0.1:
                i += 1
            # apply
            # === duplication!!!!
            if i < len(all_results):
                print >> self.log, all_results[i][1:]
                if minimize:
                    print >> self.log, "minimizing..."
                    # all_results[i][0].write_pdb_file(
                    #     file_name="%s_result_before_min_%d.pdb" % (prefix, i))
                    minimize_wrapper_for_ramachandran(
                        hierarchy=all_results[i][0],
                        xrs=xrs,
                        original_pdb_h=original_pdb_h,
                        log=self.log,
                        ss_annotation=self.secondary_structure_annotation)
                # all_results[i][0].write_pdb_file(
                #     file_name="%s_result_minimized_%d.pdb" % (prefix, i))
                final_rmsd = get_main_chain_rmsd_range(all_results[i][0],
                                                       original_pdb_h,
                                                       placing_range)
                print >> self.log, "FINAL RMSD after minimization:", final_rmsd
                return moved_with_side_chains_h
            else:
                print >> self.log, " NOT FOUND!"
                for i in all_results:
                    print >> self.log, i[1:]
            # === end of duplication!!!!

        else:
            print >> self.log, "Epic FAIL: failed to fix rama outlier"
            print >> self.log, "  Options were: (mc_rmsd, resultign_rmsd, n_iter)"
            for i in all_results:
                print >> self.log, i[1:]
        # STOP()
        return original_pdb_h
Example #32
0
 def __init__(self, pdb_hierarchy, unit_cell, map_data):
     adopt_init_args(self, locals())
     self.sites_cart = self.pdb_hierarchy.atoms().extract_xyz()
     self.target = maptbx.real_space_target_simple(
         unit_cell=self.unit_cell, density_map=self.map_data, sites_cart=self.sites_cart
     )
Example #33
0
def exercise_real_space_gradients_simple(timing):
  uc = uctbx.unit_cell((11,13,17))
  def check():
    map = flex.double(flex.grid(22,26,36).set_focus(22,26,34))
    site_frac = [i/n for i,n in zip(grid_point, map.focus())]
    sites_cart = flex.vec3_double([uc.orthogonalize(site_frac)])
    target = maptbx.real_space_target_simple(
      unit_cell=uc, density_map=map, sites_cart=sites_cart,
      selection=flex.bool(sites_cart.size(), True))
    assert approx_equal(target, 0)
    terms = maptbx.real_space_target_simple_per_site(
      unit_cell=uc, density_map=map, sites_cart=sites_cart)
    assert approx_equal(terms, [0])
    grads = maptbx.real_space_gradients_simple(
      unit_cell=uc, density_map=map, sites_cart=sites_cart, delta=0.1,
      selection=flex.bool(sites_cart.size(), True))
    assert approx_equal(grads, [(0,0,0)])
    grid_point_mod = [i%n for i,n in zip(grid_point, map.focus())]
    map[grid_point_mod] = 1
    target = maptbx.real_space_target_simple(
      unit_cell=uc, density_map=map, sites_cart=sites_cart,
      selection=flex.bool(sites_cart.size(), True))
    assert approx_equal(target, 1)
    terms = maptbx.real_space_target_simple_per_site(
      unit_cell=uc, density_map=map, sites_cart=sites_cart)
    assert approx_equal(terms, [1])
    grads = maptbx.real_space_gradients_simple(
      unit_cell=uc, density_map=map, sites_cart=sites_cart, delta=0.1,
      selection=flex.bool(sites_cart.size(), True))
    assert approx_equal(grads, [(0,0,0)])
    i,j,k = grid_point_mod
    u,v,w = map.focus()
    map[((i+1)%u,j,k)] = 0.3
    map[(i,(j+1)%v,k)] = 0.5
    map[(i,j,(k+1)%w)] = 0.7
    target = maptbx.real_space_target_simple(
      unit_cell=uc, density_map=map, sites_cart=sites_cart,
      selection=flex.bool(sites_cart.size(), True))
    assert approx_equal(target, 1)
    for delta in [0.1, 0.2]:
      grads = maptbx.real_space_gradients_simple(
        unit_cell=uc, density_map=map, sites_cart=sites_cart, delta=delta,
        selection=flex.bool(sites_cart.size(), True))
      assert approx_equal(grads, [(0.3,0.5,0.7)])
  for grid_point in [(0,0,0), (3,4,5), (-3,15,20)]:
    check()
  for i_trial in xrange(10):
    grid_point = [random.randrange(-100,100) for i in [0,1,2]]
    check()
  if (timing): n = 1000000
  else:        n = 10
  sites_cart = flex.vec3_double(flex.random_double(size=n*3)*40-20)
  map = flex.double(flex.grid(22,26,36).set_focus(22,26,34), 1)
  target = maptbx.real_space_target_simple(
    unit_cell=uc, density_map=map, sites_cart=sites_cart,
    selection=flex.bool(sites_cart.size(), True))
  assert approx_equal(target, n)
  t0 = time.time()
  maptbx.real_space_gradients_simple(
    unit_cell=uc, density_map=map, sites_cart=sites_cart, delta=0.1,
    selection=flex.bool(sites_cart.size(), True))
  tm = time.time() - t0
  msg = "real_space_gradients_simple: %.2f s / %d sites" % (tm, n)
  if (tm >= 0.01): msg += ", %.0f sites / s" % (n / tm)
  if (timing): print msg