Rosetta
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
ElecDensCenEnergy.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/methods/ElecDensEnergy.cc
11 /// @brief Scoring a structure's fit to electron density
12 /// @author Frank DiMaio
13 
14 
15 // Unit headers
18 #include <basic/options/option.hh>
19 
20 // Package headers
21 #include <core/chemical/AA.hh>
25 #include <core/scoring/Energies.hh>
28 #include <core/kinematics/Edge.hh>
30 #include <numeric/xyz.functions.hh>
31 #include <numeric/statistics/functions.hh>
34 
35 
36 // Project headers
37 #include <core/pose/Pose.hh>
39 
40 #include <basic/options/keys/edensity.OptionKeys.gen.hh>
41 
42 
43 #include <basic/Tracer.hh>
44 
46 #include <utility/vector1.hh>
47 
48 using basic::T;
49 using basic::Error;
50 using basic::Warning;
51 
52 #ifdef WIN32
53 #define _USE_MATH_DEFINES
54 #include <math.h>
55 #endif
56 // C++
57 
58 namespace core {
59 namespace scoring {
60 namespace electron_density {
61 
62 
63 /// @details This must return a fresh instance of the ElecDensCenEnergy class,
64 /// never an instance already in use
68 ) const {
70 }
71 
74  ScoreTypes sts;
75  sts.push_back( elec_dens_whole_structure_ca );
76  return sts;
77 }
78 
79 
80 using namespace core::scoring::methods;
81 
82 static THREAD_LOCAL basic::Tracer TR( "core.scoring.electron_density.ElecDensEnergy" );
83 
84 inline core::Real SQ( core::Real N ) { return N*N; }
85 
88 
89 /// c-tor
91 
92 
93 /// clone
96  return EnergyMethodOP( new ElecDensCenEnergy( *this ) );
97 }
98 
99 
100 /////////////////////////////////////////////////////////////////////////////
101 // scoring
102 /////////////////////////////////////////////////////////////////////////////
103 
104 bool
106  pose::Pose const & pose,
107  Size res1,
108  Size res2
109 ) const {
110  return ( pose.residue( res1 ).aa() == core::chemical::aa_vrt || pose.residue( res2 ).aa() == core::chemical::aa_vrt );
111 }
112 
113 
114 void
116 {
117  //if (!pose.is_fullatom()) return;
118 
121  symminfo = dynamic_cast<const core::conformation::symmetry::SymmetricConformation & >( pose.conformation()).Symmetry_Info();
122  }
124 
126 }
127 
128 
129 void
131  pose::Pose & pose,
132  ScoreFunction const &
133 ) const {
134  // Do we have a map?
135  if ( ! core::scoring::electron_density::getDensityMap().isMapLoaded() ) {
136  utility_exit_with_message("Density scoring function called but no map loaded.");
137  }
138 
139  // make sure the root of the FoldTree is a virtual atom and is followed by a jump
140  kinematics::Edge const &root_edge ( *pose.fold_tree().begin() );
141  int virt_res_idx = root_edge.start();
142  conformation::Residue const &root_res( pose.residue( virt_res_idx ) );
143 
144  pose_is_proper = true;
145  if ( root_res.type().name() != "VRT" || root_edge.label() < 0 ) {
146  utility_exit_with_message("Fold tree is not set properly for density scoring!");
147  //pose_is_proper = false;
148  }
149 
150  // create LR energy container
151  LongRangeEnergyType const & lr_type( long_range_type() );
152  Energies & energies( pose.energies() );
153  bool create_new_lre_container( false );
154 
155  if ( energies.long_range_container( lr_type ) == 0 ) {
156  create_new_lre_container = true;
157  } else {
158  LREnergyContainerOP lrc = energies.nonconst_long_range_container( lr_type );
159  OneToAllEnergyContainerOP dec( utility::pointer::static_pointer_cast< core::scoring::OneToAllEnergyContainer > ( lrc ) );
160  // make sure size or root did not change
161  if ( dec->size() != pose.total_residue() || dec->fixed() != virt_res_idx ) {
162  create_new_lre_container = true;
163  }
164  }
165 
166  if ( create_new_lre_container ) {
167  TR.Debug << "Creating new LRE container (" << pose.total_residue() << ")" << std::endl;
169  energies.set_long_range_container( lr_type, new_dec );
170  }
171 
172  // allocate space for per-AA stats
173  int nres = pose.total_residue();
175 
176  // grab symminfo (if defined) from the pose
177  // make a copy
180  symminfo = dynamic_cast<const core::conformation::symmetry::SymmetricConformation & >( pose.conformation() ).Symmetry_Info();
181  }
182 
183  // do the actual matching here; split scores among individual residues
185 
186  TR.Debug << "ElecDensCenEnergy::setup_for_scoring() returns CC = " << structure_score << std::endl;
187 
188  // # of scoring residues
189  nreses = 0;
190  for ( int i=1; i<=(int)pose.total_residue(); ++i ) {
191  if ( pose.residue(i).is_protein() && pose.residue(i).atom_name(2) == " CA " ) {
192  nreses++;
193  }
194  }
195 
197 }
198 
199 
200 void
202  conformation::Residue const &,
203  pose::Pose const &,
204  ScoreFunction const &,
205  EnergyMap &
206 ) const {
207  return;
208 }
209 
210 
211 void
213  pose::Pose const & ,
214  ScoreFunction const &,
215  EnergyMap &
216 ) const {
217  return;
218 }
219 
220 
221 void
223  conformation::Residue const & rsd1,
224  conformation::Residue const & rsd2,
225  pose::Pose const & , //pose,
226  ScoreFunction const &,
227  EnergyMap & emap
228 ) const
229 {
230  using namespace numeric::statistics;
231 
232  if ( rsd1.aa() != core::chemical::aa_vrt && rsd2.aa() != core::chemical::aa_vrt ) return;
233  if ( rsd1.aa() == core::chemical::aa_vrt && rsd2.aa() == core::chemical::aa_vrt ) return;
234 
236  Real z_CC = cc / 0.1;
237  Real p_null = 0.5 * errfc( z_CC/sqrt(2.0) );
238  Real edensScore = log ( p_null );
239 
240  emap[ elec_dens_whole_structure_ca ] += edensScore;
241  return;
242 }
243 
244 
245 void
247  id::AtomID const & id,
248  pose::Pose const & pose,
249  kinematics::DomainMap const &, // domain_map,
250  ScoreFunction const & /*sfxn*/,
251  EnergyMap const & weights,
252  Vector & F1,
253  Vector & F2
254 ) const {
255  using namespace numeric::statistics;
256 
257  if ( !pose_is_proper ) return;
258  //if (!pose.is_fullatom()) return;
259 
260  // derivative
261  int resid = id.rsd();
262  int atmid = id.atomno();
263 
264  // fn only defined for CA's
265  if ( pose.residue(resid).aa() != core::chemical::aa_vrt &&
266  ( !pose.residue(resid).is_protein() || pose.residue(resid).atom_name(atmid) != " CA ") ) return;
267 
268  numeric::xyzVector<core::Real> X = pose.xyz(id);
269  numeric::xyzVector< core::Real > dCCdx(0,0,0);
270  numeric::xyzMatrix< core::Real > R = numeric::xyzMatrix<core::Real>::rows(1,0,0, 0,1,0, 0,0,1);
271 
272  // if we're symmetric, but _not_ scoring the symmetric complex,
273  // we need to scale derivatives by the score
275  //////////////////////
276  // SYMMETRIC CASE
277  //////////////////////
279  (dynamic_cast<const core::conformation::symmetry::SymmetricConformation &>(pose.conformation()).Symmetry_Info());
280  core::Size nsubunits = symminfo->subunits();
281  core::Size nres_per = symminfo->num_independent_residues();
282  bool remapSymm = basic::options::option[ basic::options::OptionKeys::edensity::score_symm_complex ]();
283 
284  if ( pose.residue(resid).aa() == core::chemical::aa_vrt && remapSymm ) {
285 
286  // derivative is only defined for the 'ORIG' atom in the virtual
287  if ( atmid != 2 ) return;
288 
289  // if not a branch node, we're done
290  utility::vector1< core::kinematics::Edge > edges_i = pose.fold_tree().get_outgoing_edges(resid), edges_j;
291  int nchildren = edges_i.size();
292  if ( nchildren < 2 ) return;
293 
294  // odd case ... if this vrt is controlled by a cloned jump then we dont have to compute derivs
295  // for now we'll just check the parent, but perhaps we should trace root->here?
296  if ( !pose.fold_tree().is_root( resid ) ) {
297  core::kinematics::Edge edge_incoming = pose.fold_tree().get_residue_edge(resid);
298  if ( ! symminfo->jump_is_independent( edge_incoming.label() ) ) {
299  return;
300  }
301  }
302 
303  // if any child jumps are cloned such that the clone jump start is ALSO a branching vrt
304  // then we need to aggregate these as well
305  // TO DO: if a jump is _fixed_ we should move downstream to the next movable jump
306  // This isn't a problem with symm files generated by the perl script, however,
307  // it may be a problem in hand-coded ones
308  utility::vector1< core::Size > vrtclones;
309  for ( int j=1; j<=nchildren; ++j ) {
310  int basejump = edges_i[j].label();
311  if ( ! symminfo->jump_is_independent( basejump ) ) {
312  basejump = symminfo->jump_follows( basejump );
313  }
314  utility::vector1< core::Size > jumpclones = symminfo->jump_clones( basejump );
315  for ( int k=0; k<=(int)jumpclones.size(); ++k ) {
316  core::Size upstream = pose.fold_tree().jump_edge( k==0 ? basejump : jumpclones[k] ).start();
317  edges_j = pose.fold_tree().get_outgoing_edges(upstream);
318  if ( edges_j.size() > 1 && std::find( vrtclones.begin(), vrtclones.end(), upstream ) == vrtclones.end() ) {
319  vrtclones.push_back( upstream );
320  }
321  }
322  }
323 
324  // loop over all clones of this VRT
325  for ( int i=1; i<=(int)vrtclones.size(); ++i ) {
326  edges_i = pose.fold_tree().get_outgoing_edges(vrtclones[i]);
327 
328  // STEP 1: subtract children's contribution
329  for ( int j=1; j<=nchildren; ++j ) {
330  int downstream = edges_i[j].stop();
331  utility::vector1<int> mapping_j;
332  numeric::xyzMatrix< core::Real > R_j;
333  core::scoring::electron_density::getDensityMap().get_symmMap( downstream , mapping_j, R_j );
334 
335  for ( int k=1; k<=(int)nsubunits; ++k ) {
336  if ( mapping_j[k] == 0 ) continue; // subunit k is not under child j
337 
338  // loop over all atms in reses in subunit k
339  for ( int l=1, l_end=nres_per; l<=l_end; ++l ) {
340  // there is a mapping from k->mapping_j[k]
341  int source_res = (k-1)*nres_per+l;
342  int target_res = (mapping_j[k]-1)*nres_per+l;
343 
344  if ( !pose.residue(source_res).is_protein() || pose.residue(source_res).atom_name(2)!=" CA " ) continue;
345 
346  numeric::xyzVector<core::Real> X_lm_src = pose.residue(source_res).atom(2).xyz();
347  numeric::xyzVector<core::Real> X_lm_tgt = pose.residue(target_res).atom(2).xyz();
348 
349  core::scoring::electron_density::getDensityMap().dCCdx_cen( source_res, X_lm_src, pose, dCCdx );
350  Real CC = structure_score;
351  Real z_CC = CC / 0.1;
352  Real p_null = 0.5 * errfc( z_CC/sqrt(2.0) );
353  numeric::xyzVector< core::Real > dEdx = 0.5 * ( 1.0 / p_null ) *
354  (-2.0/sqrt(M_PI)) *
355  exp(-SQ( z_CC/sqrt(2.0) )) *
356  1/sqrt(0.02) *
357  nreses * R_j * dCCdx / ((core::Real)nsubunits);
358 
359  numeric::xyzVector<core::Real> atom_x = X_lm_tgt;
360  numeric::xyzVector<core::Real> const f2( dEdx );
361  numeric::xyzVector<core::Real> atom_y = -f2 + atom_x;
362  Vector const f1( atom_x.cross( atom_y ) );
363 
364  F1 -= weights[ elec_dens_whole_structure_ca ] * f1;
365  F2 -= weights[ elec_dens_whole_structure_ca ] * f2;
366  }
367  }
368  }
369 
370  // STEP 2: add my contribution
371  utility::vector1<int> mapping_i;
372  numeric::xyzMatrix< core::Real > R_i;
373  core::scoring::electron_density::getDensityMap().get_symmMap( vrtclones[i] , mapping_i, R_i );
374  for ( int k=1; k<=(int)nsubunits; ++k ) {
375  if ( mapping_i[k] == 0 ) continue; // subunit k is not under child j
376 
377  // loop over all atms in reses in subunit k
378  for ( int l=1, l_end=nres_per; l<=l_end; ++l ) {
379  // there is a mapping from k->mapping_i[k]
380  int source_res = (k-1)*nres_per+l;
381  int target_res = (mapping_i[k]-1)*nres_per+l;
382 
383  if ( !pose.residue(source_res).is_protein() || pose.residue(source_res).atom_name(2)!=" CA " ) continue;
384 
385  numeric::xyzVector<core::Real> X_lm_src = pose.residue(source_res).atom(2).xyz();
386  numeric::xyzVector<core::Real> X_lm_tgt = pose.residue(target_res).atom(2).xyz();
387 
388  core::scoring::electron_density::getDensityMap().dCCdx_cen( source_res, X_lm_src, pose, dCCdx );
389  Real CC = structure_score;
390  Real z_CC = CC / 0.1;
391  Real p_null = 0.5 * errfc( z_CC/sqrt(2.0) );
392  numeric::xyzVector< core::Real > dEdx = 0.5 * ( 1.0 / p_null ) *
393  (-2.0/sqrt(M_PI)) *
394  exp(-SQ( z_CC/sqrt(2.0) )) *
395  1/sqrt(0.02) *
396  nreses * R_i * dCCdx / ((core::Real)nsubunits);
397 
398  numeric::xyzVector<core::Real> atom_x = X_lm_tgt;
399  numeric::xyzVector<core::Real> const f2( dEdx );
400  numeric::xyzVector<core::Real> atom_y = -f2 + atom_x;
401  Vector const f1( atom_x.cross( atom_y ) );
402 
403  F1 += weights[ elec_dens_whole_structure_ca ] * f1;
404  F2 += weights[ elec_dens_whole_structure_ca ] * f2;
405  }
406  }
407  }
408  } else { // NON-VRT
409  if ( ! symminfo->bb_is_independent( resid ) ) return;
410 
411  if ( remapSymm ) {
412  utility::vector1< Size > myClones = symminfo->bb_clones(resid);
413  for ( int i=0; i<=(int)myClones.size(); ++i ) {
414  numeric::xyzVector<core::Real> X_i = (i==0) ? X : pose.xyz( id::AtomID( 2, myClones[i] ) );
415  core::scoring::electron_density::getDensityMap().dCCdx_cen( (i==0) ? resid : myClones[i], X_i, pose, dCCdx );
416 
417  // get R
418  core::scoring::electron_density::getDensityMap().get_R( symminfo->subunit_index( (i==0) ? resid : myClones[i] ), R );
419 
420  Real CC = structure_score;
421  Real z_CC = CC / 0.1;
422  Real p_null = 0.5 * errfc( z_CC/sqrt(2.0) );
423 
424  // divide by the number of subunits since rosetta will scale up later (??)
425  numeric::xyzVector< core::Real > dEdx = 0.5 * ( 1.0 / p_null ) *
426  (-2.0/sqrt(M_PI)) *
427  exp(-SQ( z_CC/sqrt(2.0) )) *
428  1/sqrt(0.02) *
429  nreses * R * dCCdx / ((core::Real)nsubunits);
430 
431  numeric::xyzVector<core::Real> atom_x = X;
432  numeric::xyzVector<core::Real> const f2( dEdx );
433  numeric::xyzVector<core::Real> atom_y = -f2 + atom_x;
434  Vector const f1( atom_x.cross( atom_y ) );
435 
436  F1 += weights[ elec_dens_whole_structure_ca ] * f1;
437  F2 += weights[ elec_dens_whole_structure_ca ] * f2;
438  }
439  } else {
440  Real CC = structure_score;
441  Real z_CC = CC / 0.1;
442  Real p_null = 0.5 * errfc( z_CC/sqrt(2.0) );
443 
445  numeric::xyzVector< core::Real > dEdx = ( 1.0 / p_null ) *
446  0.5 *
447  (-2.0/sqrt(M_PI)) *
448  exp(-SQ( z_CC/sqrt(2.0) )) *
449  1/sqrt(0.02) *
450  nreses *
451  dCCdx / ((core::Real)nsubunits);
452 
453  numeric::xyzVector<core::Real> atom_x = X;
454  numeric::xyzVector<core::Real> const f2( dEdx );
455  numeric::xyzVector<core::Real> atom_y = -f2 + atom_x; // a "fake" atom in the direcion of the gradient
456  Vector const f1( atom_x.cross( atom_y ) );
457 
458  F1 += weights[ elec_dens_whole_structure_ca ] * f1;
459  F2 += weights[ elec_dens_whole_structure_ca ] * f2;
460  }
461  }
462  } else {
463  //////////////////////
464  // ASYMMETRIC CASE
465  //////////////////////
466 
467  // the derivative of edens _score_ as a function of dCC/dx
468  Real CC = structure_score;
469  Real z_CC = CC / 0.1;
470  Real p_null = 0.5 * errfc( z_CC/sqrt(2.0) );
471 
473 
474  // divide by the number of subunits since rosetta will scale up later (??)
475  numeric::xyzVector< core::Real > dEdx = ( 1.0 / p_null ) *
476  0.5 *
477  (-2.0/sqrt(M_PI)) *
478  exp(-SQ( z_CC/sqrt(2.0) )) *
479  1/sqrt(0.02) *
480  nreses *
481  dCCdx;
482 
483  numeric::xyzVector<core::Real> atom_x = X;
484  numeric::xyzVector<core::Real> const f2( dEdx );
485  numeric::xyzVector<core::Real> atom_y = -f2 + atom_x; // a "fake" atom in the direcion of the gradient
486  Vector const f1( atom_x.cross( atom_y ) );
487 
488  F1 += weights[ elec_dens_whole_structure_ca ] * f1;
489  F2 += weights[ elec_dens_whole_structure_ca ] * f2;
490  }
491 }
494 {
495  return 1; // Initial versioning
496 }
497 
498 }
499 }
500 }
void get_symmMap(int vrtid, utility::vector1< int > &X_map, numeric::xyzMatrix< core::Real > &R)
virtual void setup_for_derivatives(pose::Pose &pose, ScoreFunction const &sf) const
Called immediately before atom- and DOF-derivatives are calculated allowing the derived class a chanc...
virtual void eval_atom_derivative(id::AtomID const &id, pose::Pose const &pose, kinematics::DomainMap const &, ScoreFunction const &sfxn, EnergyMap const &weights, Vector &F1, Vector &F2) const
called during gradient-based minimization inside dfunc
Fold tree class.
utility::pointer::shared_ptr< SymmetryInfo const > SymmetryInfoCOP
bool is_root(int const seqpos) const
Returns true if the the root.
Definition: FoldTree.hh:728
kinematics::FoldTree const & fold_tree() const
Returns the pose FoldTree.
Definition: Pose.cc:303
int start() const
start vertex, return by value
Definition: Edge.hh:57
Ramachandran R
Definition: Ramachandran.cc:80
utility functions for handling with symmetric conformations
This object defines a ScoreFunction, it contains methods for calculating the various scoring componen...
Edge const & jump_edge(int const jump_number) const
Returns the jump edge with jump number (const)
Definition: FoldTree.cc:2178
virtual void residue_pair_energy(conformation::Residue const &rsd1, conformation::Residue const &rsd2, pose::Pose const &pose, ScoreFunction const &sfxn, EnergyMap &emap) const
Evaluate the interaction between a given residue pair accumulating the unweighted energies in an Ener...
A cached energies object.
Definition: Energies.hh:98
std::string const & atom_name(int const atm) const
Returns the name of this residue's atom with index number
Definition: Residue.hh:1879
A molecular system including residues, kinematics, and energies.
Definition: Pose.hh:151
void get_R(int subunit, numeric::xyzMatrix< core::Real > &R)
virtual ScoreTypes score_types_for_method() const
Return the set of score types claimed by the EnergyMethod this EnergyMethodCreator creates in its cre...
Conformation const & conformation() const
Returns the pose Conformation (const-access)
Definition: Pose.hh:236
utility::vector1< Edge > get_outgoing_edges(int const seqpos) const
Returns all edges that build a residue directly off of
Definition: FoldTree.cc:2216
virtual core::Size version() const
Return the version of the energy method.
platform::Size Size
Definition: types.hh:30
methods::LongRangeEnergyType long_range_type() const
Instance Residue class, used for placed residues and rotamers.
Definition: Residue.hh:90
Size total_residue() const
Returns the number of residues in the pose conformation.
Definition: Pose.cc:732
Vector const & xyz() const
Returns the atom coordinates as an xyzVector.
Definition: Atom.hh:101
const_iterator begin() const
begin iterator of the edge_list
Definition: FoldTree.hh:155
Declaration for the class that connects ElecDensCenEnergy with the ScoringManager.
Fold tree edge class.
PointPosition const & xyz(AtomID const &id) const
Returns the location (xyz) of pose AtomID
Definition: Pose.cc:1389
ObjexxFCL::FArray1D_int DomainMap
ElectronDensity & getDensityMap(std::string filename, bool force_reload)
The EDM instance.
utility::pointer::shared_ptr< EnergyMethod > EnergyMethodOP
virtual methods::EnergyMethodOP create_energy_method(methods::EnergyMethodOptions const &) const
Instantiate a new ElecDensCenEnergy.
utility::vector1< ScoreType > ScoreTypes
Definition: ScoreType.hh:593
int label() const
label (edge type), return by value
Definition: Edge.hh:156
Atom identifier class. Defined by the atom number and the residue number.
Definition: AtomID.hh:38
static THREAD_LOCAL basic::Tracer TR("core.scoring.methods.ElecDensEnergy")
utility::pointer::shared_ptr< LREnergyContainer > LREnergyContainerOP
Atom const & atom(Size const atm_index) const
Returns this residue's Atom with index number (const)
Definition: Residue.hh:497
numeric::xyzVector< Length > Vector
Definition: types.hh:65
virtual methods::EnergyMethodOP clone() const
clone
void dCCdx_cen(int resid, numeric::xyzVector< core::Real > const &X, core::pose::Pose const &pose, numeric::xyzVector< core::Real > &gradX)
Return the gradient of CC w.r.t. res X's CA's movement Centroid-mode analogue of dCCdx.
platform::Real Real
Definition: types.hh:35
A symmetric conformation: has an additional data member "SymmetryInfo" class.
A container interface for storing and scoring long range energies.
utility::pointer::shared_ptr< OneToAllEnergyContainer > OneToAllEnergyContainerOP
Energies class.
virtual void finalize_total_energy(pose::Pose const &pose, ScoreFunction const &, EnergyMap &totals) const
called at the end of energy evaluation
virtual void eval_intrares_energy(conformation::Residue const &rsd, pose::Pose const &pose, ScoreFunction const &sfxn, EnergyMap &emap) const
Evaluate the intra-residue constraint energy for a given residue.
chemical::AA const & aa() const
Returns this residue's AA type, if any Used for knowledge-based scores, dunbrack, etc...
Definition: Residue.hh:1919
Method declarations and simple accessor definitions for the Residue class.
bool is_symmetric(scoring::Energies const &energies)
Definition: util.cc:66
utility::pointer::shared_ptr< EnergyMethodCreator > EnergyMethodCreatorOP
A vector for storing energy data, initially all values are 0.
Definition: EnergyMap.hh:42
Residue const & residue(Size const seqpos) const
Returns the Residue at position (read access) Note: this method will trigger a refold if eit...
Definition: Pose.cc:866
Class definitions for conformation::Atom.
void compute_symm_rotations(core::pose::Pose const &pose, core::conformation::symmetry::SymmetryInfoCOP symmInfo=NULL)
Computes the symmatric rotation matrices.
core::Real matchCentroidPose(core::pose::Pose const &pose, core::conformation::symmetry::SymmetryInfoCOP symmInfo=NULL, bool cacheCCs=false)
Quickly matches a centroid pose into a low-resolution density map by placing a single Gaussian at eac...
Energy graph class declaration.
virtual bool defines_residue_pair_energy(pose::Pose const &pose, Size res1, Size res2) const
single edge of the fold_tree
Definition: Edge.hh:41
Edge const & get_residue_edge(int const seqpos) const
Returns the edge that builds the residue Does not work for root atom (will fail) ...
Definition: FoldTree.cc:2198
bool is_protein() const
Returns true if this residue is an amino acid.
Definition: Residue.hh:1673
symmetry conformation container.
scoring::Energies const & energies() const
Returns the pose Energies (const-access)
Definition: Pose.hh:339
virtual void setup_for_scoring(pose::Pose &pose, ScoreFunction const &) const
if an energy method needs to cache something in the pose (e.g. in pose.energies()), before scoring begins, it must do so in this method. All long range energy functions must initialize their LREnergyContainers before scoring begins. The default is to do nothing.
Pose class.