1 """@namespace IMP.pmi.restraints.stereochemistry
2 Restraints for keeping correct stereochemistry.
5 from __future__
import print_function
12 from operator
import itemgetter
17 """Create a restraint between consecutive TempResidue objects
18 or an entire PMI Molecule object."""
23 disorderedlength=
False,
28 @param objects - a list of hierarchies, PMI TempResidues OR a
30 @param scale Scale the maximal distance between the beads by this
31 factor when disorderedlength is False. The maximal distance
32 is calculated as ((float(residuegap) + 1.0) * 3.6) * scale.
33 @param disorderedlength - This flag uses either disordered length
34 calculated for random coil peptides (True) or zero
35 surface-to-surface distance between beads (False)
36 as optimal distance for the sequence connectivity restraint.
37 @param upperharmonic - This flag uses either harmonic (False)
38 or upperharmonic (True) in the intra-pair
39 connectivity restraint.
40 @param resolution - The resolution to connect things at - only used
41 if you pass PMI objects
42 @param label - A string to identify this restraint in the
50 raise Exception(
"ConnectivityRestraint: only pass stuff from "
51 "one Molecule, please")
55 self.m = list(hiers)[0].get_model()
70 SortedSegments.append((start, end, startres))
71 SortedSegments = sorted(SortedSegments, key=itemgetter(2))
74 self.particle_pairs = []
75 for x
in range(len(SortedSegments) - 1):
77 last = SortedSegments[x][1]
78 first = SortedSegments[x + 1][0]
80 apply_restraint =
True
97 apply_restraint =
False
106 residuegap = firstresn - lastresn - 1
107 if disorderedlength
and (nreslast / 2 + nresfirst / 2
108 + residuegap) > 20.0:
111 optdist = math.sqrt(5 / 3) * 1.93 * \
112 (nreslast / 2 + nresfirst / 2 + residuegap) ** 0.6
119 optdist = (0.0 + (float(residuegap) + 1.0) * 3.6) * scale
126 pt0 = last.get_particle()
127 pt1 = first.get_particle()
128 self.particle_pairs.append((pt0, pt1))
130 self.m, dps, (pt0.get_index(), pt1.get_index()))
132 print(
"Adding sequence connectivity restraint between",
133 pt0.get_name(),
" and ", pt1.get_name(),
'of distance',
135 self.rs.add_restraint(r)
137 def set_label(self, label):
140 def get_weight(self):
143 def add_to_model(self):
146 def get_restraint(self):
149 def set_weight(self, weight):
151 self.rs.set_weight(weight)
153 def get_output(self):
155 score = self.weight * self.rs.unprotected_evaluate(
None)
156 output[
"_TotalScore"] = str(score)
157 output[
"ConnectivityRestraint_" + self.label] = str(score)
161 """ Returns number of connectivity restraints """
162 return len(self.rs.get_restraints())
165 """ Returns the list of connected particles pairs """
166 return self.particle_pairs
169 return self.weight * self.rs.unprotected_evaluate(
None)
173 """A class to create an excluded volume restraint for a set of particles
174 at a given resolution.
175 Can be initialized as a bipartite restraint between two sets of particles.
176 # Potential additional function: Variable resolution for each PMI object.
177 Perhaps passing selection_tuples with (PMI_object, resolution)
186 @param included_objects Can be one of the following inputs:
187 IMP Hierarchy, PMI System/State/Molecule/TempResidue,
188 or a list/set of them
189 @param other_objects Initializes a bipartite restraint between
190 included_objects and other_objects
191 Same format as included_objects
192 @param resolution The resolution particles at which to impose the
193 restraint. By default, the coarsest particles will be chosen.
194 If a number is chosen, for each particle, the closest
195 resolution will be used (see IMP.atom.Selection).
196 @param kappa Restraint strength
210 if other_objects
is not None:
218 if hierarchies
is None:
219 raise Exception(
"Must at least pass included objects")
220 self.mdl = hierarchies[0].get_model()
221 included_ps = [h.get_particle()
for h
in hierarchies]
223 other_ps = [h.get_particle()
for h
in other_hierarchies]
246 self.rs.add_restraint(evr)
248 def add_excluded_particle_pairs(self, excluded_particle_pairs):
250 inverted = [(p1, p0)
for p0, p1
in excluded_particle_pairs]
255 self.cpc.add_pair_filter(icpf)
257 def set_label(self, label):
260 def add_to_model(self):
264 def get_restraint(self):
267 def set_weight(self, weight):
269 self.rs.set_weight(weight)
271 def get_output(self):
273 score = self.weight * self.rs.unprotected_evaluate(
None)
274 output[
"_TotalScore"] = str(score)
275 output[
"ExcludedVolumeSphere_" + self.label] = str(score)
279 return self.weight * self.rs.unprotected_evaluate(
None)
283 """Enforce ideal Helix dihedrals and bonds for a selection
291 @param hierarchy the root node
292 @param selection_tuple (start, stop, molname, copynum=0)
295 self.mdl = hierarchy.get_model()
299 start = selection_tuple[0]
300 stop = selection_tuple[1]
301 mol = selection_tuple[2]
303 if len(selection_tuple) > 3:
304 copy_index = selection_tuple[3]
307 hierarchy, molecule=mol, copy_index=copy_index,
308 residue_indexes=range(start, stop+1))
309 ps = sel.get_selected_particles(with_representation=
False)
313 self.rs.add_restraint(self.r)
314 print(
'Created helix %s.%i.%i-%i with %i dihedrals and %i bonds'
315 % (mol, copy_index, start, stop, self.get_number_of_bonds(),
316 self.get_number_of_dihedrals()))
318 def set_label(self, label):
321 def get_weight(self):
324 def add_to_model(self):
327 def get_restraint(self):
330 def set_weight(self, weight):
332 self.rs.set_weight(weight)
334 def get_number_of_bonds(self):
335 return self.r.get_number_of_bonds()
337 def get_number_of_dihedrals(self):
338 return self.r.get_number_of_dihedrals()
341 return self.weight * self.rs.unprotected_evaluate(
None)
343 def get_output(self):
345 score = self.evaluate()
346 output[
"_TotalScore"] = str(score)
347 output[
"HelixRestraint_" + self.label] = str(score)
352 """ Add bond restraint between pair of consecutive
353 residues/beads to enforce the stereochemistry.
355 def __init__(self, objects, distance=3.78, strength=10.0, jitter=None):
357 @param objects Objects to restrain
358 @param distance Resting distance for restraint
359 @param strength Bond constant
360 @param jitter Defines the +- added to the optimal distance in
361 the harmonic well restraint used to increase the tolerance
365 self.m = particles[0].get_model()
376 (distance - jitter, distance + jitter), strength)
381 raise ValueError(
"wrong length of pair")
384 raise TypeError(
"%s is not a residue" % p)
387 print(
"ResidueBondRestraint: adding a restraint between %s %s"
388 % (pair[0].get_name(), pair[1].get_name()))
389 self.rs.add_restraint(
394 def set_label(self, label):
396 self.rs.set_name(label)
397 for r
in self.rs.get_restraints():
400 def add_to_model(self):
403 def get_restraint(self):
406 def set_weight(self, weight):
408 self.rs.set_weight(weight)
410 def get_excluded_pairs(self):
411 return self.pairslist
413 def get_output(self):
415 score = self.weight * self.rs.unprotected_evaluate(
None)
416 output[
"_TotalScore"] = str(score)
417 output[
"ResidueBondRestraint_" + self.label] = str(score)
422 """Add angular restraint between triplets of consecutive
423 residues/beads to enforce the stereochemistry.
425 def __init__(self, objects, anglemin=100.0, anglemax=140.0, strength=10.0):
428 self.m = particles[0].get_model()
436 (math.pi * anglemin / 180.0,
437 math.pi * anglemax / 180.0),
443 raise ValueError(
"wrong length of triplet")
446 raise TypeError(
"%s is not a residue" % p)
449 print(
"ResidueAngleRestraint: adding a restraint between %s %s %s"
450 % (triplet[0].get_name(), triplet[1].get_name(),
451 triplet[2].get_name()))
452 self.rs.add_restraint(
460 def set_label(self, label):
462 self.rs.set_name(label)
463 for r
in self.rs.get_restraints():
466 def add_to_model(self):
469 def get_restraint(self):
472 def set_weight(self, weight):
474 self.rs.set_weight(weight)
476 def get_excluded_pairs(self):
477 return self.pairslist
479 def get_output(self):
481 score = self.weight * self.rs.unprotected_evaluate(
None)
482 output[
"_TotalScore"] = str(score)
483 output[
"ResidueAngleRestraint_" + self.label] = str(score)
488 """Add dihedral restraints between quadruplet of consecutive
489 residues/beads to enforce the stereochemistry.
490 Give as input a string of "C" and "T", meaning cys (0+-40)
491 or trans (180+-40) dihedral. The length of the string must be #residue-3.
492 Without the string, the dihedral will be assumed trans.
494 def __init__(self, objects, stringsequence=None, strength=10.0):
497 self.m = particles[0].get_model()
504 if stringsequence
is None:
505 stringsequence =
"T" * (len(particles) - 3)
507 for n, ps
in enumerate(
511 raise ValueError(
"wrong length of quadruplet")
514 raise TypeError(
"%s is not a residue" % p)
517 dihedraltype = stringsequence[n]
518 if dihedraltype ==
"C":
522 (math.pi * anglemin / 180.0,
523 math.pi * anglemax / 180.0),
525 print(
"ResidueDihedralRestraint: adding a CYS restraint "
526 "between %s %s %s %s"
527 % (quadruplet[0].get_name(), quadruplet[1].get_name(),
528 quadruplet[2].get_name(), quadruplet[3].get_name()))
529 if dihedraltype ==
"T":
530 anglemin = 180 - 70.0
531 anglemax = 180 + 70.0
533 (math.pi * anglemin / 180.0,
534 math.pi * anglemax / 180.0),
536 print(
"ResidueDihedralRestraint: adding a TRANS restraint "
537 "between %s %s %s %s"
538 % (quadruplet[0].get_name(),
539 quadruplet[1].get_name(), quadruplet[2].get_name(),
540 quadruplet[3].get_name()))
541 self.rs.add_restraint(
547 self.pairslist.append(
549 self.pairslist.append(
552 def set_label(self, label):
554 self.rs.set_name(label)
555 for r
in self.rs.get_restraints():
558 def add_to_model(self):
561 def get_restraint(self):
564 def set_weight(self, weight):
566 self.rs.set_weight(weight)
568 def get_excluded_pairs(self):
569 return self.pairslist
571 def get_output(self):
573 score = self.weight * self.rs.unprotected_evaluate(
None)
574 output[
"_TotalScore"] = str(score)
575 output[
"ResidueDihedralRestraint_" + self.label] = str(score)
580 """Add harmonic restraints between all pairs
582 def __init__(self, hierarchy, selection_tuples=None, resolution=1,
583 strength=0.01, dist_cutoff=10.0, ca_only=
True):
585 @param hierarchy Root hierarchy to select from
586 @param selection_tuples Selecting regions for the restraint
587 [[start,stop,molname,copy_index=0],...]
588 @param resolution Resolution for applying restraint
589 @param strength Bond strength
590 @param dist_cutoff Cutoff for making restraints
591 @param ca_only Selects only CAlphas. Only matters if resolution=0.
595 self.m = hierarchy.get_model()
596 for st
in selection_tuples:
602 hierarchy, molecule=st[2],
603 residue_indexes=range(st[0], st[1]+1),
604 copy_index=copy_index)
607 hierarchy, molecule=st[2],
608 residue_indexes=range(st[0], st[1]+1),
609 copy_index=copy_index,
611 particles += sel.get_selected_particles()
619 particles, dist_cutoff, strength)
620 for r
in self.rs.get_restraints():
621 a1, a2 = r.get_inputs()
624 print(
'ElasticNetwork: created', self.rs.get_number_of_restraints(),
627 def set_label(self, label):
629 self.rs.set_name(label)
630 for r
in self.rs.get_restraints():
633 def add_to_model(self):
636 def get_restraint(self):
639 def set_weight(self, weight):
641 self.rs.set_weight(weight)
643 def get_excluded_pairs(self):
644 return self.pairslist
646 def get_output(self):
648 score = self.weight * self.rs.unprotected_evaluate(
None)
649 output[
"_TotalScore"] = str(score)
650 output[
"ElasticNetworkRestraint_" + self.label] = str(score)
655 """ Enable CHARMM force field """
656 def __init__(self, root, ff_temp=300.0, zone_ps=None, zone_size=10.0,
657 enable_nonbonded=
True, enable_bonded=
True,
658 zone_nonbonded=
False):
659 """Setup the CHARMM restraint on a selection. Expecting atoms.
660 @param root The node at which to apply the restraint
661 @param ff_temp The temperature of the force field
662 @param zone_ps Create a zone around this set of particles
663 Automatically includes the entire residue (incl. backbone)
664 @param zone_size The size for looking for neighbor residues
665 @param enable_nonbonded Allow the repulsive restraint
666 @param enable_bonded Allow the bonded restraint
667 @param zone_nonbonded EXPERIMENTAL: exclude from nonbonded all
668 sidechains that aren't in zone!
671 kB = (1.381 * 6.02214) / 4184.0
673 self.mdl = root.get_model()
684 topology = ff.create_topology(root)
685 topology.apply_default_patches()
686 topology.setup_hierarchy(root)
687 if zone_ps
is not None:
688 limit_to_ps = IMP.pmi.topology.get_particles_within_zone(
689 root, zone_ps, zone_size, entire_residues=
True,
690 exclude_backbone=
False)
694 self.ps = limit_to_ps
698 print(
'init bonds score', r.unprotected_evaluate(
None))
699 self.bonds_rs.add_restraint(r)
701 ff.add_well_depths(root)
703 atoms = IMP.atom.get_by_type(root, IMP.atom.ATOM_TYPE)
706 if (zone_ps
is not None)
and zone_nonbonded:
707 print(
'stereochemistry: zone_nonbonded is True')
709 backbone_types = [
'C',
'N',
'CB',
'O']
712 for n
in backbone_types])
713 backbone_atoms = sel.get_selected_particles()
714 sel_ps = IMP.pmi.topology.get_particles_within_zone(
715 root, zone_ps, zone_size, entire_residues=
True,
716 exclude_backbone=
True)
726 self.nbl.add_pair_filter(r.get_full_pair_filter())
729 self.nonbonded_rs.add_restraint(pr)
730 print(
'CHARMM is set up')
732 def set_label(self, label):
734 self.rs.set_name(label)
735 for r
in self.rs.get_restraints():
738 def add_to_model(self):
742 def get_restraint(self):
745 def get_close_pair_container(self):
748 def set_weight(self, weight):
750 self.rs.set_weight(weight)
752 def get_output(self):
754 bonds_score = self.weight * self.bonds_rs.unprotected_evaluate(
None)
756 self.weight * self.nonbonded_rs.unprotected_evaluate(
None)
757 score = bonds_score+nonbonded_score
758 output[
"_TotalScore"] = str(score)
759 output[
"CHARMM_BONDS"] = str(bonds_score)
760 output[
"CHARMM_NONBONDED"] = str(nonbonded_score)
765 """Add bonds and improper dihedral restraints for the CBs
768 self, rnums, representation, selection_tuple, strength=10.0, kappa=1.0,
769 jitter_angle=0.0, jitter_improper=0.0):
773 ca-cb is a constraint, no restraint needed
778 self.m = representation.prot.get_model()
787 ca, cb = self.get_ca_cb(
788 IMP.pmi.tools.select_by_tuple(representation,
789 (rnum, rnum,
'chainA'),
794 ca_prev, cb_prev = self.get_ca_cb(
795 IMP.pmi.tools.select_by_tuple(representation,
797 'chainA'), resolution=0))
798 ca_next, cb_next = self.get_ca_cb(
799 IMP.pmi.tools.select_by_tuple(representation,
801 'chainA'), resolution=0))
835 self.rset_angles.add_restraint(ar13u)
836 self.rset_angles.add_restraint(ar13l)
842 self.rset_angles.add_restraint(ar23u)
843 self.rset_angles.add_restraint(ar23l)
844 if not nter
and not cter:
868 self.rset_angles.add_restraint(idru)
869 self.rset_angles.add_restraint(idrl)
870 self.rs.add_restraint(self.rset_bonds)
871 self.rs.add_restraint(self.rset_angles)
873 def get_ca_cb(self, atoms):
878 ca = a.get_particle()
880 cb = a.get_particle()
883 def set_label(self, label):
885 self.rs.set_name(label)
886 for r
in self.rs.get_restraints():
889 def add_to_model(self):
892 def get_restraint(self):
895 def set_weight(self, weight):
897 self.rs.set_weight(weight)
899 def get_excluded_pairs(self):
900 return self.pairslist
902 def get_output(self):
904 score = self.weight * self.rs.unprotected_evaluate(
None)
905 output[
"_TotalScore"] = str(score)
906 output[
"PseudoAtomicRestraint_" + self.label] = str(score)
911 """Create harmonic restraints between the reference and (transformed)
914 @note Wraps IMP::core::TransformedDistancePairScore with an
917 def __init__(self, references, clones_list, transforms,
918 label=
'', strength=10.0, ca_only=
False):
920 @param references Can be one of the following inputs:
921 IMP Hierarchy, PMI System/State/Molecule/TempResidue,
922 or a list/set of them
923 @param clones_list List of lists of the above
924 @param transforms Transforms moving each selection to the first
926 @param label Label for output
927 @param strength The elastic bond strength
928 @param ca_only Optionally select so only CAlpha particles are used
932 self.mdl = refs[0].get_model()
936 if len(clones_list) != len(transforms):
938 'Error: There should be as many clones as transforms')
941 for tmp_clones, trans
in zip(clones_list, transforms):
943 if len(clones) != len(refs):
944 raise Exception(
"Error: len(references)!=len(clones)")
946 for p0, p1
in zip(refs, clones):
953 self.mdl, pair_score, [p0.get_particle_index(),
954 p1.get_particle_index()])
955 self.rs.add_restraint(r)
956 print(
'created symmetry network with',
957 self.rs.get_number_of_restraints(),
'restraints')
959 def set_label(self, label):
961 self.rs.set_name(label)
962 for r
in self.rs.get_restraints():
965 def add_to_model(self):
968 def get_restraint(self):
971 def set_weight(self, weight):
973 self.rs.set_weight(weight)
975 def get_excluded_pairs(self):
976 return self.pairslist
978 def get_output(self):
980 score = self.weight * self.rs.unprotected_evaluate(
None)
981 output[
"SymmetryRestraint_" + self.label] = str(score)
982 output[
"_TotalScore"] = str(score)
987 """Creates a restraint between the termini two polypeptides, to simulate
988 the sequence connectivity."""
989 def __init__(self, nterminal, cterminal, scale=1.0, disorderedlength=False,
990 upperharmonic=
True, resolution=1, label=
"None"):
992 @param nterminal - single PMI2 Hierarchy/molecule at the nterminal
993 @param cterminal - single PMI2 Hierarchy/molecule at the cterminal
994 @param scale Scale the maximal distance between the beads by this
995 factor when disorderedlength is False.
996 The maximal distance is calculated as
997 ((float(residuegap) + 1.0) * 3.6) * scale.
998 @param disorderedlength - This flag uses either disordered length
999 calculated for random coil peptides (True) or zero
1000 surface-to-surface distance between beads (False)
1001 as optimal distance for the sequence connectivity
1003 @param upperharmonic - This flag uses either harmonic (False)
1004 or upperharmonic (True) in the intra-pair
1005 connectivity restraint.
1006 @param resolution - The resolution to connect things at - only used
1007 if you pass PMI objects
1008 @param label - A string to identify this restraint in the
1015 nter_lastres = ssn[-1][1]
1016 cter_firstres = ssc[0][0]
1017 self.m = nter_lastres.get_model()
1021 optdist = (3.6) * scale
1028 pt0 = nter_lastres.get_particle()
1029 pt1 = cter_firstres.get_particle()
1031 (pt0.get_index(), pt1.get_index()))
1033 print(
"Adding fusion connectivity restraint between", pt0.get_name(),
1034 " and ", pt1.get_name(),
'of distance', optdist)
1035 self.rs.add_restraint(r)
1037 def set_label(self, label):
1040 def get_weight(self):
1043 def add_to_model(self):
1046 def get_restraint(self):
1049 def set_weight(self, weight):
1050 self.weight = weight
1051 self.rs.set_weight(weight)
1053 def get_output(self):
1055 score = self.weight * self.rs.unprotected_evaluate(
None)
1056 output[
"_TotalScore"] = str(score)
1057 output[
"FusionRestraint_" + self.label] = str(score)
1061 return self.weight * self.rs.unprotected_evaluate(
None)
1066 """Restrain the dihedral between planes defined by three particles.
1068 This restraint is useful for restraining the twist of a string of
1069 more or less identical rigid bodies, so long as the curvature is mild.
1072 def __init__(self, particle_triplets, angle=0., k=1., label=None,
1075 @param particle_triplets List of lists of 3 particles. Each triplet
1076 defines a plane. Dihedrals of adjacent planes
1078 @param angle Angle of plane dihedral in degrees
1079 @param k Strength of restraint
1080 @param label Label for output
1081 @param weight Weight of restraint
1082 @note Particles defining planes should be rigid and more or less
1083 parallel for proper behavior
1085 model = particle_triplets[0][0].get_model()
1086 super(PlaneDihedralRestraint, self).
__init__(model, label=label,
1089 angle = math.pi * angle / 180.
1091 for i, t1
in enumerate(particle_triplets[:-1]):
1092 t2 = particle_triplets[i + 1]
1093 q1 = [t1[1], t1[0], t2[0], t2[1]]
1094 q2 = [t1[2], t1[0], t2[0], t2[2]]
1095 self.rs.add_restraint(
1097 self.rs.add_restraint(
A filter which returns true if a container containers the Pair.
Add dihedral restraints between quadruplet of consecutive residues/beads to enforce the stereochemist...
CHARMMParameters * get_heavy_atom_CHARMM_parameters()
Lower bound harmonic function (non-zero when feature < mean)
static bool get_is_setup(const IMP::ParticleAdaptor &p)
Enforce CHARMM stereochemistry on the given Hierarchy.
A member of a rigid body, it has internal (local) coordinates.
static bool get_is_setup(const IMP::ParticleAdaptor &p)
Various classes to hold sets of particles.
Upper bound harmonic function (non-zero when feature > mean)
Enable CHARMM force field.
A class to store an fixed array of same-typed values.
Enforce ideal Helix dihedrals and bonds for a selection at resolution 0.
Creates a restraint between the termini two polypeptides, to simulate the sequence connectivity...
Add harmonic restraints between all pairs.
Restrain the dihedral between planes defined by three particles.
Dihedral restraint between four particles.
A score on the distance between the surfaces of two spheres.
Return all close unordered pairs of particles taken from the SingletonContainer.
static bool get_is_setup(const IMP::ParticleAdaptor &p)
Return all spatially-proximals pairs of particles (a,b) from the two SingletonContainers A and B...
GenericHierarchies get_leaves(Hierarchy mhd)
Get all the leaves of the bit of hierarchy.
Distance restraint between two particles.
Object used to hold a set of restraints.
Store a list of ParticleIndexPairs.
A well with harmonic barriers.
Angle restraint between three particles.
ParticleIndexPairs get_indexes(const ParticlePairsTemp &ps)
Get the indexes from a list of particle pairs.
Add bond restraint between pair of consecutive residues/beads to enforce the stereochemistry.
The standard decorator for manipulating molecular structures.
RestraintSet * create_elastic_network(const Particles &ps, Float dist_cutoff, Float strength)
Create an elastic network restraint set.
Add bonds and improper dihedral restraints for the CBs.
Store a list of ParticleIndexes.
A decorator for a particle representing an atom.
def get_particle_pairs
Returns the list of connected particles pairs.
def __init__
Setup the CHARMM restraint on a selection.
Create harmonic restraints between the reference and (transformed) clones.
Add angular restraint between triplets of consecutive residues/beads to enforce the stereochemistry...
def get_num_restraints
Returns number of connectivity restraints.
A decorator for a residue.
Basic functionality that is expected to be used by a wide variety of IMP users.
Create a restraint between consecutive TempResidue objects or an entire PMI Molecule object...
A class to create an excluded volume restraint for a set of particles at a given resolution.
The general base class for IMP exceptions.
def __init__
need to add: ca-ca bond ca-cb is a constraint, no restraint needed ca-ca-ca cb-ca-ca-cb ...
Applies a PairScore to a Pair.
Functionality for loading, creating, manipulating and scoring atomic structures.
Select hierarchy particles identified by the biological name.
Applies a PairScore to each Pair in a list.
A repulsive potential on the distance between two atoms.
Perform more efficient close pair finding when rigid bodies are involved.
Inferential scoring building on methods developed as part of the Inferential Structure Determination ...
Harmonic function (symmetric about the mean)
Restraint a set of residues to use ideal helix dihedrals and bonds.