示例#1
0
def get_bp_plan_proxies(a1, a2, base_pair, grm, mon_lib_srv, plane_cache):
    result_plan_p = []
    result_parr_p = []
    seqs = get_plane_i_seqs_from_residues(a1.parent(), a2.parent(), grm,
                                          mon_lib_srv, plane_cache)
    for i_seqs, j_seqs in seqs:
        if len(i_seqs) > 2 and len(j_seqs) > 2:
            if base_pair.restrain_parallelity:
                if base_pair.parallelity_sigma < 1e-5:
                    raise Sorry(
                        "Sigma for parallelity basepair restraints should be > 1e-5"
                    )
                proxy = geometry_restraints.parallelity_proxy(
                    i_seqs=flex.size_t(i_seqs),
                    j_seqs=flex.size_t(j_seqs),
                    weight=1 / (base_pair.parallelity_sigma**2),
                    target_angle_deg=0,
                    slack=0,
                    top_out=False,
                    limit=1,
                    origin_id=origin_ids.get_origin_id('hydrogen bonds'))
                result_parr_p.append(proxy)
            if base_pair.restrain_planarity:
                if base_pair.planarity_sigma < 1e-5:
                    raise Sorry(
                        "Sigma for planarity basepair restraints should be > 1e-5"
                    )
                w = 1. / (base_pair.planarity_sigma**2)
                proxy = geometry_restraints.planarity_proxy(
                    i_seqs=flex.size_t(i_seqs + j_seqs),
                    weights=[w] * len(i_seqs + j_seqs),
                    origin_id=origin_ids.get_origin_id('hydrogen bonds'))
                result_plan_p.append(proxy)
    return result_plan_p, result_parr_p
示例#2
0
def get_basepair_plane_proxies(pdb_hierarchy, bp_phil_params, grm, mon_lib_srv,
                               plane_cache):
    assert pdb_hierarchy is not None
    result_planarities = []
    result_parallelities = []
    if len(bp_phil_params) < 1:
        return result_planarities, result_parallelities
    if grm is None:
        return result_planarities, result_parallelities
    selection_cache = pdb_hierarchy.atom_selection_cache()
    pdb_atoms = pdb_hierarchy.atoms()
    for base_pair in bp_phil_params:
        if (base_pair.base1 is not None and base_pair.base2 is not None
                and base_pair.enabled):
            selected_atoms_1 = selection_cache.iselection(base_pair.base1)
            selected_atoms_2 = selection_cache.iselection(base_pair.base2)
            if len(selected_atoms_1) == 0:
                raise Sorry(
                    "Selection %s in base_pair retusulted in 0 atoms." %
                    (base_pair.base1))
            if len(selected_atoms_2) == 0:
                raise Sorry(
                    "Selection %s in base_pair retusulted in 0 atoms." %
                    (base_pair.base2))
            a1 = pdb_atoms[selected_atoms_1[0]]
            a2 = pdb_atoms[selected_atoms_2[0]]
            r1 = a1.parent()
            r2 = a2.parent()
            seqs = get_plane_i_seqs_from_residues(r1, r2, grm, mon_lib_srv,
                                                  plane_cache)
            for i_seqs, j_seqs in seqs:
                if len(i_seqs) > 2 and len(j_seqs) > 2:
                    if base_pair.restrain_parallelity:
                        if base_pair.parallelity_sigma < 1e-5:
                            raise Sorry(
                                "Sigma for parallelity basepair restraints should be > 1e-5"
                            )
                        proxy = geometry_restraints.parallelity_proxy(
                            i_seqs=flex.size_t(i_seqs),
                            j_seqs=flex.size_t(j_seqs),
                            weight=1 / (base_pair.parallelity_sigma**2),
                            target_angle_deg=0,
                            slack=0,
                            top_out=False,
                            limit=1,
                            origin_id=1)
                        result_parallelities.append(proxy)
                    if base_pair.restrain_planarity:
                        if base_pair.planarity_sigma < 1e-5:
                            raise Sorry(
                                "Sigma for planarity basepair restraints should be > 1e-5"
                            )
                        w = 1. / (base_pair.planarity_sigma**2)
                        proxy = geometry_restraints.planarity_proxy(
                            i_seqs=flex.size_t(i_seqs + j_seqs),
                            weights=[w] * len(i_seqs + j_seqs),
                            origin_id=1)
                        result_planarities.append(proxy)
    return result_planarities, result_parallelities
def get_basepair_plane_proxies(
    pdb_hierarchy,
    bp_phil_params,
    grm,
    mon_lib_srv,
    plane_cache):
  assert pdb_hierarchy is not None
  result_planarities = []
  result_parallelities = []
  if len(bp_phil_params) < 1:
    return result_planarities, result_parallelities
  if grm is None:
    return result_planarities, result_parallelities
  selection_cache = pdb_hierarchy.atom_selection_cache()
  pdb_atoms = pdb_hierarchy.atoms()
  for base_pair in bp_phil_params:
    if (base_pair.base1 is not None and base_pair.base2 is not None
        and base_pair.enabled):
      selected_atoms_1 = selection_cache.iselection(base_pair.base1)
      selected_atoms_2 = selection_cache.iselection(base_pair.base2)
      if len(selected_atoms_1) == 0:
        raise Sorry("Selection %s in base_pair retusulted in 0 atoms." % (
            base_pair.base1))
      if len(selected_atoms_2) == 0:
        raise Sorry("Selection %s in base_pair retusulted in 0 atoms." % (
            base_pair.base2))
      a1 = pdb_atoms[selected_atoms_1[0]]
      a2 = pdb_atoms[selected_atoms_2[0]]
      r1 = a1.parent()
      r2 = a2.parent()
      seqs = get_plane_i_seqs_from_residues(r1, r2, grm,mon_lib_srv, plane_cache)
      for i_seqs, j_seqs in seqs:
        if len(i_seqs) > 2 and len(j_seqs) > 2:
          if base_pair.restrain_parallelity:
            if base_pair.parallelity_sigma < 1e-5:
              raise Sorry("Sigma for parallelity basepair restraints should be > 1e-5")
            proxy=geometry_restraints.parallelity_proxy(
              i_seqs=flex.size_t(i_seqs),
              j_seqs=flex.size_t(j_seqs),
              weight=1/(base_pair.parallelity_sigma**2),
              target_angle_deg=0,
              slack=0,
              top_out=False,
              limit=1,
              origin_id=1)
            result_parallelities.append(proxy)
          if base_pair.restrain_planarity:
            if base_pair.planarity_sigma < 1e-5:
              raise Sorry("Sigma for planarity basepair restraints should be > 1e-5")
            w = 1./(base_pair.planarity_sigma**2)
            proxy=geometry_restraints.planarity_proxy(
              i_seqs=flex.size_t(i_seqs+j_seqs),
              weights=[w]*len(i_seqs+j_seqs),
              origin_id=1)
            result_planarities.append(proxy)
  return result_planarities, result_parallelities
示例#4
0
def get_stacking_proxies(pdb_hierarchy, stacking_phil_params, grm, mon_lib_srv,
                         plane_cache):
    result = []
    assert pdb_hierarchy is not None
    if len(stacking_phil_params) < 1:
        return result
    if grm is None:
        return result
    selection_cache = pdb_hierarchy.atom_selection_cache()
    pdb_atoms = pdb_hierarchy.atoms()
    for stacking_pair in stacking_phil_params:
        if (stacking_pair.base1 is not None and stacking_pair.base2 is not None
                and stacking_pair.enabled):
            selected_atoms_1 = selection_cache.iselection(stacking_pair.base1)
            selected_atoms_2 = selection_cache.iselection(stacking_pair.base2)
            if len(selected_atoms_1) == 0:
                raise Sorry(
                    "Selection %s in stacking_pair retusulted in 0 atoms." %
                    (stacking_pair.base1))
            if len(selected_atoms_2) == 0:
                raise Sorry(
                    "Selection %s in stacking_pair retusulted in 0 atoms." %
                    (stacking_pair.base2))
            a1 = pdb_atoms[selected_atoms_1[0]]
            a2 = pdb_atoms[selected_atoms_2[0]]
            r1 = a1.parent()
            r2 = a2.parent()
            seqs = get_plane_i_seqs_from_residues(r1, r2, grm, mon_lib_srv,
                                                  plane_cache)
            for i_seqs, j_seqs in seqs:
                if len(i_seqs) > 2 and len(j_seqs) > 2:
                    if stacking_pair.sigma < 1e-5:
                        raise Sorry(
                            "Sigma for stacking restraints should be > 1e-5")
                    proxy = geometry_restraints.parallelity_proxy(
                        i_seqs=flex.size_t(i_seqs),
                        j_seqs=flex.size_t(j_seqs),
                        weight=1 / (stacking_pair.sigma**2),
                        target_angle_deg=0,
                        slack=0,
                        top_out=False,
                        limit=1,
                        origin_id=0
                    )  # special case default but not "covalent geometry"
                    result.append(proxy)
    return result
def get_stacking_proxies(pdb_hierarchy, stacking_phil_params, grm,
    mon_lib_srv, plane_cache):
  result = []
  assert pdb_hierarchy is not None
  if len(stacking_phil_params) < 1:
    return result
  if grm is None:
    return result
  selection_cache = pdb_hierarchy.atom_selection_cache()
  pdb_atoms = pdb_hierarchy.atoms()
  for stacking_pair in stacking_phil_params:
    if (stacking_pair.base1 is not None and stacking_pair.base2 is not None
        and stacking_pair.enabled):
      selected_atoms_1 = selection_cache.iselection(stacking_pair.base1)
      selected_atoms_2 = selection_cache.iselection(stacking_pair.base2)
      if len(selected_atoms_1) == 0:
        raise Sorry("Selection %s in stacking_pair retusulted in 0 atoms." % (
            stacking_pair.base1))
      if len(selected_atoms_2) == 0:
        raise Sorry("Selection %s in stacking_pair retusulted in 0 atoms." % (
            stacking_pair.base2))
      a1 = pdb_atoms[selected_atoms_1[0]]
      a2 = pdb_atoms[selected_atoms_2[0]]
      r1 = a1.parent()
      r2 = a2.parent()
      seqs = get_plane_i_seqs_from_residues(r1, r2, grm, mon_lib_srv, plane_cache)
      for i_seqs, j_seqs in seqs:
        if len(i_seqs) > 2 and len(j_seqs) > 2:
          if stacking_pair.sigma < 1e-5:
            raise Sorry("Sigma for stacking restraints should be > 1e-5")
          proxy=geometry_restraints.parallelity_proxy(
            i_seqs=flex.size_t(i_seqs),
            j_seqs=flex.size_t(j_seqs),
            weight=1/(stacking_pair.sigma**2),
            target_angle_deg=0,
            slack=0,
            top_out=False,
            limit=1,
            origin_id=0)
          result.append(proxy)
  return result