Rosetta 3.5
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
DNATorsionPotential.cc
Go to the documentation of this file.
1 // -*- mode:c++;tab-width:2;indent-tabs-mode:t;show-trailing-whitespace:t;rm-trailing-spaces:t -*-
2 // vi: set ts=2 noet:
3 //
4 // (c) Copyright Rosetta Commons Member Institutions.
5 // (c) This file is part of the Rosetta software suite and is made available under license.
6 // (c) The Rosetta software is developed by the contributing members of the Rosetta Commons.
7 // (c) For more information, see http://www.rosettacommons.org. Questions about this can be
8 // (c) addressed to University of Washington UW TechTransfer, email: license@u.washington.edu.
9 
10 /// @file core/scoring/dna/DNATorsionPotential.cc
11 /// @brief DNATorsionPotential potential class implementation
12 /// @author Andrew Leaver-Fay (leaverfa@email.unc.edu)
13 /// @author Rhiju Das
14 /// @author Jim Havranek
15 
16 // Unit Headers
17 #include <core/scoring/dna/DNATorsionPotential.hh>
18 
19 // Package Headers
20 #include <core/scoring/ScoreFunction.hh>
21 //#include <core/scoring/dna/DNA_Util.hh>
22 
23 // Project Headers
24 #include <core/pose/Pose.hh>
25 //#include <core/io/database/open.hh>
26 //#include <basic/options/option.hh>
27 #include <basic/basic.hh>
28 #include <core/chemical/AA.hh>
29 #include <core/scoring/constraints/HarmonicFunc.hh>
30 #include <core/scoring/constraints/AmberPeriodicFunc.hh>
31 #include <core/scoring/constraints/AtomPairConstraint.hh>
32 #include <core/scoring/constraints/AngleConstraint.hh>
33 #include <core/scoring/constraints/DihedralConstraint.hh>
34 #include <core/scoring/constraints/ConstraintSet.hh>
35 #include <core/scoring/constraints/ConstraintSet.fwd.hh>
36 
37 // Numeric Headers
38 #include <numeric/angle.functions.hh>
39 #include <numeric/interpolation/periodic_range/half/interpolation.hh>
40 
41 // Utility Headers
42 #include <utility/pointer/ReferenceCount.hh>
43 #include <utility/io/izstream.hh>
44 
45 // ObjexxFCL Headers
46 #include <ObjexxFCL/FArray1D.hh>
47 #include <ObjexxFCL/FArray2D.hh>
48 #include <ObjexxFCL/FArray4D.hh>
49 //#include <ObjexxFCL/fmt/formatted.o.hh>
50 
51 #include <basic/Tracer.hh>
52 #include <numeric/conversions.hh>
53 #include <iostream>
54 static basic::Tracer tr( "core.scoring.dna.DNATorsionPotential" );
55 
56 namespace core {
57 namespace scoring {
58 namespace dna {
59 
60 enum{ WHATEVER, ALPHA, BETA, GAMMA, DELTA, EPSILON, ZETA, CHI, NU0, NU1, NU2, NU3, NU4 };
61 
62 DNATorsionPotential::DNATorsionPotential():
63  ////////////////////////////////////////////////////////////////////////////
64  // Parameters for alpha,beta,gamma,delta, etc. torsion constraints...
65  ////////////////////////////////////////////////////////////////////////////
66  DELTA_CUTOFF_( 115.0 ),
67 // scale_dna_torsion_tether_( 0.05 ), // THIS IS A SCALING FACTOR FOR ALL CONSTRAINTS.
68  scale_dna_torsion_tether_( 0.05 ), // THIS IS A SCALING FACTOR FOR ALL CONSTRAINTS.
69  scale_dna_torsion_sd_( 1.0 / std::sqrt( scale_dna_torsion_tether_ ) ),
70  ////////////////////////////////////////////////////////////////////////////
71  // Ribose closure weights
72  ////////////////////////////////////////////////////////////////////////////
73  c2star_c3star_bond_length_( 1.526 ),
74  c2star_c3star_sd_( 1.0/ sqrt( 310.0 ) ), // 310.0 is the value of k
75  c2star_c3star_dist_harm_func_( new constraints::HarmonicFunc( c2star_c3star_bond_length_, scale_dna_torsion_sd_ * c2star_c3star_sd_ )),
76 
77  c4star_c3star_c2star_bond_angle_( numeric::conversions::radians( 109.50 ) ),
78  c4star_c3star_c2star_angle_harm_func_(
79  new constraints::HarmonicFunc( c4star_c3star_c2star_bond_angle_, scale_dna_torsion_sd_ * 1.0/sqrt( numeric::conversions::radians( 40.0 ) ) ) ),
80 
81  o3star_c3star_c2star_bond_angle_( numeric::conversions::radians( 109.50 ) ),
82  o3star_c3star_c2star_angle_harm_func_(
83  new constraints::HarmonicFunc( o3star_c3star_c2star_bond_angle_, scale_dna_torsion_sd_ * 1.0/sqrt( numeric::conversions::radians( 50.0 ) ) ) ),
84 
85  c3star_c2star_c1star_bond_angle_( numeric::conversions::radians( 109.50 ) ),
86  c3star_c2star_c1star_angle_harm_func_(
87  new constraints::HarmonicFunc( c3star_c2star_c1star_bond_angle_, scale_dna_torsion_sd_ * 1.0/sqrt( numeric::conversions::radians( 40.0 ) ) ) ),
88 
89  // Might also be good to have additional angle or torsional potentials
90  // to preserve sugar geometry.
91  ////////////////////////////////////////////////////////////////////////////
92  verbose_( false )
93 {
94  init_dna_torsion_parameters();
95 }
96 
97 
98 /////////////////////////////////////////////////////////////////////////////////////////
99 void
100 DNATorsionPotential::setup_constraints(
101  pose::Pose & pose,
102  constraints::ConstraintSetOP & dna_torsion_constraints,
103  constraints::ConstraintSetOP & dna_sugar_close_constraints,
104  constraints::ConstraintSetOP & dna_base_distance_constraints) const
105 {
106 
107  // dna_torsion_constraints->clear() ... doesn't exist!
108  //Constraints are atom-pair, angle, dihedral...
109  dna_sugar_close_constraints = constraints::ConstraintSetOP( new constraints::ConstraintSet );
110  add_sugar_ring_closure_constraints( pose, *dna_sugar_close_constraints );
111  // add_o2star_torsion_constraints( pose, *dna_torsion_constraints );
112 
113  // Why can't these terms be "constraints", in dna_torsion_constraints above? Because
114  // some involve atoms that change types when residues are switched in and out (during design!).
115  // Could either define a different sort of constraint ("TorsionConstraint")
116  dna_torsion_constraints = constraints::ConstraintSetOP( new constraints::ConstraintSet );
117  add_dna_torsion_tethers( pose, *dna_torsion_constraints );
118 
119  dna_base_distance_constraints = constraints::ConstraintSetOP( new constraints::ConstraintSet );
120  add_dna_base_distance_constraints( pose, *dna_base_distance_constraints );
121 }
122 
123 /////////////////////////////////////////////////////////////////////////////////////////
124 void
125 DNATorsionPotential::add_sugar_ring_closure_constraints( pose::Pose & pose, constraints::ConstraintSet & cst_set ) const {
126  for (Size i = 1; i <= pose.total_residue(); i++ ){
127  add_sugar_ring_closure_constraints( pose.residue( i ), cst_set );
128  }
129 }
130 
131 /////////////////////////////////////////////////////////////////////////////////////////
132 void
133 DNATorsionPotential::add_sugar_ring_closure_constraints( conformation::Residue const & rsd, constraints::ConstraintSet & cst_set ) const {
134  if ( !rsd.is_DNA() ) return;
135 
136  Size const & i( rsd.seqpos() );
137 
138  Size const c1star_index = rsd.atom_index( "C1*" );
139  Size const c2star_index = rsd.atom_index( "C2*" );
140  Size const c3star_index = rsd.atom_index( "C3*" );
141  Size const o3star_index = rsd.atom_index( "O3*" );
142  Size const c4star_index = rsd.atom_index( "C4*" );
143 
144  cst_set.add_constraint( new constraints::AtomPairConstraint( id::AtomID( c2star_index, i),
145  id::AtomID( c3star_index, i),
146  c2star_c3star_dist_harm_func_,
147  dna_sugar_close ) );
148 
149  constraints::ConstraintOP angle1 = new constraints::AngleConstraint( id::AtomID( c4star_index, i),
150  id::AtomID( c3star_index, i),
151  id::AtomID( c2star_index, i),
152  c4star_c3star_c2star_angle_harm_func_,
153  dna_sugar_close );
154  cst_set.add_constraint( angle1 );
155 
156  constraints::ConstraintOP angle2 = new constraints::AngleConstraint( id::AtomID( o3star_index, i),
157  id::AtomID( c3star_index, i),
158  id::AtomID( c2star_index, i),
159  o3star_c3star_c2star_angle_harm_func_,
160  dna_sugar_close );
161  cst_set.add_constraint( angle2 );
162 
163  constraints::ConstraintOP angle3 = new constraints::AngleConstraint( id::AtomID( c3star_index, i),
164  id::AtomID( c2star_index, i),
165  id::AtomID( c1star_index, i),
166  c3star_c2star_c1star_angle_harm_func_,
167  dna_sugar_close );
168  cst_set.add_constraint( angle3 );
169 
170  // Need to add an improper dihedral to keep the hydrogens correct on C2*
171 
172 
173 
174 }
175 ///////////////////////////////////////
176 void
177 DNATorsionPotential::add_dna_base_distance_constraints(
178  pose::Pose & pose,
179  constraints::ConstraintSet & cst_set ) const
180 {
181  using namespace core::chemical;
182  Size const nres = pose.total_residue();
183  for( Size i = 1; i < nres; ++i ){
184  conformation::Residue const & rsd( pose.residue( i ) );
185  conformation::Residue const & next_rsd( pose.residue( i + 1 ) );
186  if( !rsd.is_DNA() || !next_rsd.is_DNA() || rsd.is_upper_terminus() ) continue; //job undone: need to add conditions when the rsd is not basepaired
187 
188  Size const H2star_index = pose.residue( i ).atom_index( "2H2*" );
189  Size const H1star_index = pose.residue( i ).atom_index( "1H2*" );
190  Size H68_index, next_H68_index;
191  if( rsd.type().aa() == na_ade || rsd.type().aa() == na_gua )
192  H68_index = pose.residue( i ).atom_index( "H8" );
193  else
194  H68_index = pose.residue( i ).atom_index( "H6" );
195 
196  if( next_rsd.type().aa() == na_ade || next_rsd.type().aa() == na_gua )
197  next_H68_index = pose.residue( i + 1 ).atom_index( "H8" );
198  else
199  next_H68_index = pose.residue( i + 1 ).atom_index( "H6" );
200 //set up harmonic function
201  Real angle_diff ( rsd.mainchain_torsion(5) - rsd.mainchain_torsion(6) );
202  Real dist_1H = 0.0041 * angle_diff + 2.7092;
203  constraints::HarmonicFuncOP H1_harm_func( new constraints::HarmonicFunc( dist_1H, 0.307 ) );
204  cst_set.add_constraint( new constraints::AtomPairConstraint( id::AtomID( H1star_index, i),
205  id::AtomID( next_H68_index, i + 1),
206  H1_harm_func,
207  dna_base_distance ) );
208 
209  Real dist_2H = 0.0081 * angle_diff + 4.0213;
210  constraints::HarmonicFuncOP H2_harm_func( new constraints::HarmonicFunc( dist_2H, 0.381 ) );
211  cst_set.add_constraint( new constraints::AtomPairConstraint( id::AtomID( H2star_index, i),
212  id::AtomID( next_H68_index, i + 1),
213  H2_harm_func,
214  dna_base_distance ) );
215 
216  Real dist_H68 = 0.0068 * angle_diff + 5.4228;
217  constraints::HarmonicFuncOP H68_harm_func( new constraints::HarmonicFunc( dist_H68, 0.373 ) );
218  cst_set.add_constraint( new constraints::AtomPairConstraint( id::AtomID( H68_index, i),
219  id::AtomID( next_H68_index, i + 1),
220  H68_harm_func,
221  dna_base_distance ) );
222 // std::cout << "TEST" << " angle " << angle_diff << " dist_1H " << dist_1H << std::endl;
223 }
224 }
225 
226 ///////////////////////////////////////////////////////////////////////////////
227 void
228 DNATorsionPotential::add_dna_torsion_tethers(
229  pose::Pose & pose,
230  constraints::ConstraintSet & cst_set ) const
231 {
232  using namespace numeric;
233 
234  Size const nres = pose.total_residue();
235 
236  for (Size i = 1; i <=nres; i++ ){
237 
238  conformation::Residue const & rsd( pose.residue( i ) );
239  if (!rsd.is_DNA() ) continue;
240 
241  /////////////////////////////////////
242  // alpha --
243  /////////////////////////////////////
244  add_DNA_torsion_constraint( pose, i, cst_set, ALPHA, alpha_components_ );
245 
246  /////////////////////////////////////
247  // beta -- 1 harmonic potential
248  /////////////////////////////////////
249  add_DNA_torsion_constraint( pose, i, cst_set, BETA, beta_components_ );
250 
251  /////////////////////////////////////
252  // gamma
253  /////////////////////////////////////
254  add_DNA_torsion_constraint( pose, i, cst_set, GAMMA, gamma_components_ );
255 
256 
257  /////////////////////////////////////
258  // delta
259  /////////////////////////////////////
260 
261  add_DNA_torsion_constraint( pose, i, cst_set, DELTA, delta_components_ );
262 
263  /////////////////////////////////////
264  // epsilon
265  /////////////////////////////////////
266 
267  add_DNA_torsion_constraint( pose, i, cst_set, EPSILON, epsilon_components_ );
268 
269  /////////////////////////////////////
270  // zeta
271  /////////////////////////////////////
272 
273  add_DNA_torsion_constraint( pose, i, cst_set, ZETA, zeta_components_ );
274 
275  /////////////////////////////////////
276  // nu0
277  /////////////////////////////////////
278  add_DNA_torsion_constraint( pose, i, cst_set, NU0, nu0_components_ );
279 
280  /////////////////////////////////////
281  // nu1
282  /////////////////////////////////////
283  add_DNA_torsion_constraint( pose, i, cst_set, NU1, nu1_components_ );
284 
285  /////////////////////////////////////
286  // nu2
287  /////////////////////////////////////
288  add_DNA_torsion_constraint( pose, i, cst_set, NU2, nu2_components_ );
289 
290  /////////////////////////////////////
291  // nu4
292  /////////////////////////////////////
293  add_DNA_torsion_constraint( pose, i, cst_set, NU4, nu4_components_ );
294 
295 #ifdef NOTDEF
296 
297  /////////////////////////////////////
298  // nu3
299  /////////////////////////////////////
300  add_DNA_torsion_constraint( pose, i, cst_set, NU3, nu3_components_ );
301 
302  /////////////////////////////////////
303  // chi
304  /////////////////////////////////////
305  add_DNA_torsion_constraint( pose, i, cst_set, CHI, gaussian_parameter_set_chi_south_);
306 
307  /////////////////////////////////////
308  // nu2
309  /////////////////////////////////////
310  add_DNA_torsion_constraint( pose, i, cst_set, NU2, gaussian_parameter_set_nu2_south_);
311 
312 #endif
313 
314  }
315 }
316 
317 
318 ///////////////////////////////////////////////////////////////////////////////
319 void
320 DNATorsionPotential::add_DNA_torsion_constraint(
321  pose::Pose & pose,
322  Size const i,
323  constraints::ConstraintSet & cst_set,
324  Size const dna_torsion_number,
325  utility::vector1< constraints::AmberPeriodicFuncOP > const & torsion_components ) const
326 {
327 
328  conformation::Residue rsd( pose.residue( i ) );
329 
330  // Get the atoms involved
331  id::AtomID id1,id2,id3,id4;
332  bool fail = get_atom_ids_by_torsion( dna_torsion_number, pose, i, id1, id2, id3, id4 );
333  if( fail ) {
334 // tr << "Failed to get atom ids at residue " << i << " for torsion number " << dna_torsion_number << std::endl;
335  return;
336  }
337 
338  // Generate dihedral constraints for each term in the vector of Fourier components
339 
340  for( Size this_comp = 1 ; this_comp <= torsion_components.size() ; ++this_comp ) {
341 // tr << "Adding torsion at residue " << i << " ids " << id1 << " " << id2 << " " << id3 << " " << id4 << std::endl;
342  constraints::ConstraintOP dihedral = new constraints::DihedralConstraint( id1, id2, id3, id4,
343  torsion_components[ this_comp ], dna_bb_torsion );
344  cst_set.add_constraint( dihedral );
345 
346  }
347 
348 }
349 
350 ///////////////////////////////////////////////////////////////////////////////
351 void
352 DNATorsionPotential::init_dna_torsion_parameters()
353 {
354 
355  // Parameters for DNA backbone torsions are taken from the Amber MM code -
356  // Alpha and gamma are from the refitting of Perez et.al. in Biophys. J. (2007)
357  // v92 pp. 3816-3829.
358  // The rest are taken from the parm99 parameter set available with the Ambertools
359  // online.
360  // It is my understanding that these should also work for RNA.
361  // -jjh
362 
363  // Note there are scaling factors to move Amber parameters into our Amber format
364  alpha_components_.push_back( new constraints::AmberPeriodicFunc( numeric::conversions::radians( 31.79508), 0.185181, 1.0 ) );
365  alpha_components_.push_back( new constraints::AmberPeriodicFunc( numeric::conversions::radians(351.95960), 1.256531, 2.0 ) );
366  alpha_components_.push_back( new constraints::AmberPeriodicFunc( numeric::conversions::radians(357.24748), 0.354858, 3.0 ) );
367 
368  beta_components_.push_back( new constraints::AmberPeriodicFunc( 0.00000, 1.150000, 3.0 ) );
369 
370  gamma_components_.push_back( new constraints::AmberPeriodicFunc( numeric::conversions::radians(190.97653), 1.178040, 1.0 ) );
371  gamma_components_.push_back( new constraints::AmberPeriodicFunc( numeric::conversions::radians(295.63279), 0.092102, 2.0 ) );
372  gamma_components_.push_back( new constraints::AmberPeriodicFunc( numeric::conversions::radians(348.09535), 0.962830, 3.0 ) );
373 
374  delta_components_.push_back( new constraints::AmberPeriodicFunc( 0.00000, 1.400000, 3.0 ) );
375 
376  epsilon_components_.push_back( new constraints::AmberPeriodicFunc( 0.00000, 1.150000, 3.0 ) );
377 
378  zeta_components_.push_back( new constraints::AmberPeriodicFunc( 0.00000, 1.200000, 2.0 ) );
379  zeta_components_.push_back( new constraints::AmberPeriodicFunc( 0.00000, 0.250000, 3.0 ) );
380 
381  // CT-CT-OS-CT
382  nu0_components_.push_back( new constraints::AmberPeriodicFunc( numeric::conversions::radians(180.00000), 0.100000, 2.0 ) );
383  nu0_components_.push_back( new constraints::AmberPeriodicFunc( 0.00000, 0.383000, 3.0 ) );
384 
385  // CT-CT-CT-OS
386  nu1_components_.push_back( new constraints::AmberPeriodicFunc( 0.00000, 1.400000, 3.0 ) );
387 
388  // CT-CT-CT-CT
389  nu2_components_.push_back( new constraints::AmberPeriodicFunc( numeric::conversions::radians(180.00000), 0.200000, 1.0 ) );
390  nu2_components_.push_back( new constraints::AmberPeriodicFunc( numeric::conversions::radians(180.00000), 0.250000, 2.0 ) );
391  nu2_components_.push_back( new constraints::AmberPeriodicFunc( 0.00000, 0.180000, 3.0 ) );
392 
393  // CT-CT-CT-OS
394  nu3_components_.push_back( new constraints::AmberPeriodicFunc( 0.00000, 1.400000, 3.0 ) );
395 
396  // CT-CT-OS-CT
397  nu4_components_.push_back( new constraints::AmberPeriodicFunc( numeric::conversions::radians(180.00000), 0.100000, 2.0 ) );
398  nu4_components_.push_back( new constraints::AmberPeriodicFunc( 0.00000, 0.383000, 3.0 ) );
399 
400  // Now the relevant atom names
401 
402  alpha_atom_names_.push_back( "O3*" );
403  alpha_atom_names_.push_back( "P" );
404  alpha_atom_names_.push_back( "O5*" );
405  alpha_atom_names_.push_back( "C5*" );
406 
407  beta_atom_names_.push_back( "P" );
408  beta_atom_names_.push_back( "O5*" );
409  beta_atom_names_.push_back( "C5*" );
410  beta_atom_names_.push_back( "C4*" );
411 
412  gamma_atom_names_.push_back( "O5*" );
413  gamma_atom_names_.push_back( "C5*" );
414  gamma_atom_names_.push_back( "C4*" );
415  gamma_atom_names_.push_back( "C3*" );
416 
417  delta_atom_names_.push_back( "C5*" );
418  delta_atom_names_.push_back( "C4*" );
419  delta_atom_names_.push_back( "C3*" );
420  delta_atom_names_.push_back( "O3*" );
421 
422  epsilon_atom_names_.push_back( "C4*" );
423  epsilon_atom_names_.push_back( "C3*" );
424  epsilon_atom_names_.push_back( "O3*" );
425  epsilon_atom_names_.push_back( "P" );
426 
427  zeta_atom_names_.push_back( "C3*" );
428  zeta_atom_names_.push_back( "O3*" );
429  zeta_atom_names_.push_back( "P" );
430  zeta_atom_names_.push_back( "O5*" );
431 
432  nu0_atom_names_.push_back( "C4*" );
433  nu0_atom_names_.push_back( "O4*" );
434  nu0_atom_names_.push_back( "C1*" );
435  nu0_atom_names_.push_back( "C2*" );
436 
437  nu1_atom_names_.push_back( "O4*" );
438  nu1_atom_names_.push_back( "C1*" );
439  nu1_atom_names_.push_back( "C2*" );
440  nu1_atom_names_.push_back( "C3*" );
441 
442  nu2_atom_names_.push_back( "C1*" );
443  nu2_atom_names_.push_back( "C2*" );
444  nu2_atom_names_.push_back( "C3*" );
445  nu2_atom_names_.push_back( "C4*" );
446 
447  nu3_atom_names_.push_back( "C2*" );
448  nu3_atom_names_.push_back( "C3*" );
449  nu3_atom_names_.push_back( "C4*" );
450  nu3_atom_names_.push_back( "O4*" );
451 
452  nu4_atom_names_.push_back( "C3*" );
453  nu4_atom_names_.push_back( "C4*" );
454  nu4_atom_names_.push_back( "O4*" );
455  nu4_atom_names_.push_back( "C1*" );
456 
457 }
458 
459  bool
460  DNATorsionPotential::get_atom_ids_by_torsion(
461  Size const dna_torsion_number,
462  pose::Pose & pose,
463  Size const resid,
464  id::AtomID & id1,
465  id::AtomID & id2,
466  id::AtomID & id3,
467  id::AtomID & id4 ) const
468 {
469 
470  // Note: A return value of 'true' denotes failure / not applicable!
471 
472  if( ( dna_torsion_number == ALPHA ) &&
473  ( pose.residue_type( resid ).is_lower_terminus() ) ) {
474  return true;
475  }
476 
477  if( ( dna_torsion_number == EPSILON ) &&
478  ( pose.residue_type( resid ).is_upper_terminus() ) ) {
479  return true;
480  }
481 
482  if( ( dna_torsion_number == ZETA ) &&
483  ( pose.residue_type( resid ).is_upper_terminus() ) ) {
484  return true;
485  }
486 
487 
488  switch ( dna_torsion_number ) {
489  case ALPHA:
490  id1 = id::AtomID( pose.residue( resid - 1 ).atom_index( alpha_atom_names_[1] ), resid - 1 );
491  id2 = id::AtomID( pose.residue( resid ).atom_index( alpha_atom_names_[2] ), resid );
492  id3 = id::AtomID( pose.residue( resid ).atom_index( alpha_atom_names_[3] ), resid );
493  id4 = id::AtomID( pose.residue( resid ).atom_index( alpha_atom_names_[4] ), resid );
494  return false;
495  case BETA:
496  id1 = id::AtomID( pose.residue( resid ).atom_index( beta_atom_names_[1] ), resid );
497  id2 = id::AtomID( pose.residue( resid ).atom_index( beta_atom_names_[2] ), resid );
498  id3 = id::AtomID( pose.residue( resid ).atom_index( beta_atom_names_[3] ), resid );
499  id4 = id::AtomID( pose.residue( resid ).atom_index( beta_atom_names_[4] ), resid );
500  return false;
501  case GAMMA:
502  id1 = id::AtomID( pose.residue( resid ).atom_index( gamma_atom_names_[1] ), resid );
503  id2 = id::AtomID( pose.residue( resid ).atom_index( gamma_atom_names_[2] ), resid );
504  id3 = id::AtomID( pose.residue( resid ).atom_index( gamma_atom_names_[3] ), resid );
505  id4 = id::AtomID( pose.residue( resid ).atom_index( gamma_atom_names_[4] ), resid );
506  return false;
507  case DELTA:
508  id1 = id::AtomID( pose.residue( resid ).atom_index( delta_atom_names_[1] ), resid );
509  id2 = id::AtomID( pose.residue( resid ).atom_index( delta_atom_names_[2] ), resid );
510  id3 = id::AtomID( pose.residue( resid ).atom_index( delta_atom_names_[3] ), resid );
511  id4 = id::AtomID( pose.residue( resid ).atom_index( delta_atom_names_[4] ), resid );
512  return false;
513  case EPSILON:
514  id1 = id::AtomID( pose.residue( resid ).atom_index( epsilon_atom_names_[1] ), resid );
515  id2 = id::AtomID( pose.residue( resid ).atom_index( epsilon_atom_names_[2] ), resid );
516  id3 = id::AtomID( pose.residue( resid ).atom_index( epsilon_atom_names_[3] ), resid );
517  id4 = id::AtomID( pose.residue( resid + 1 ).atom_index( epsilon_atom_names_[4] ), resid + 1);
518  return false;
519  case ZETA:
520  id1 = id::AtomID( pose.residue( resid ).atom_index( zeta_atom_names_[1] ), resid );
521  id2 = id::AtomID( pose.residue( resid ).atom_index( zeta_atom_names_[2] ), resid );
522  id3 = id::AtomID( pose.residue( resid + 1 ).atom_index( zeta_atom_names_[3] ), resid + 1);
523  id4 = id::AtomID( pose.residue( resid + 1 ).atom_index( zeta_atom_names_[4] ), resid + 1);
524  return false;
525  case NU0:
526  id1 = id::AtomID( pose.residue( resid ).atom_index( nu0_atom_names_[1] ), resid );
527  id2 = id::AtomID( pose.residue( resid ).atom_index( nu0_atom_names_[2] ), resid );
528  id3 = id::AtomID( pose.residue( resid ).atom_index( nu0_atom_names_[3] ), resid );
529  id4 = id::AtomID( pose.residue( resid ).atom_index( nu0_atom_names_[4] ), resid );
530  return false;
531  case NU1:
532  id1 = id::AtomID( pose.residue( resid ).atom_index( nu1_atom_names_[1] ), resid );
533  id2 = id::AtomID( pose.residue( resid ).atom_index( nu1_atom_names_[2] ), resid );
534  id3 = id::AtomID( pose.residue( resid ).atom_index( nu1_atom_names_[3] ), resid );
535  id4 = id::AtomID( pose.residue( resid ).atom_index( nu1_atom_names_[4] ), resid );
536  return false;
537  case NU2:
538  id1 = id::AtomID( pose.residue( resid ).atom_index( nu2_atom_names_[1] ), resid );
539  id2 = id::AtomID( pose.residue( resid ).atom_index( nu2_atom_names_[2] ), resid );
540  id3 = id::AtomID( pose.residue( resid ).atom_index( nu2_atom_names_[3] ), resid );
541  id4 = id::AtomID( pose.residue( resid ).atom_index( nu2_atom_names_[4] ), resid );
542  return false;
543  case NU3:
544  id1 = id::AtomID( pose.residue( resid ).atom_index( nu3_atom_names_[1] ), resid );
545  id2 = id::AtomID( pose.residue( resid ).atom_index( nu3_atom_names_[2] ), resid );
546  id3 = id::AtomID( pose.residue( resid ).atom_index( nu3_atom_names_[3] ), resid );
547  id4 = id::AtomID( pose.residue( resid ).atom_index( nu3_atom_names_[4] ), resid );
548  return false;
549  case NU4:
550  id1 = id::AtomID( pose.residue( resid ).atom_index( nu4_atom_names_[1] ), resid );
551  id2 = id::AtomID( pose.residue( resid ).atom_index( nu4_atom_names_[2] ), resid );
552  id3 = id::AtomID( pose.residue( resid ).atom_index( nu4_atom_names_[3] ), resid );
553  id4 = id::AtomID( pose.residue( resid ).atom_index( nu4_atom_names_[4] ), resid );
554  return false;
555  default:
556  utility_exit_with_message("bad dna torsion type for DNATorsionPotential: " );
557  }
558 
559  return true;
560 }
561 
562 
563 
564 
565 
566 
567 }
568 }
569 }
Generated on Sat Jun 1 2013 11:36:12 for Rosetta 3.5 by   doxygen 1.8.4