ARestraint Class Reference

#include <FreeEnergyRestrain.h>

Inheritance diagram for ARestraint:

ADiheRestraint ADistRestraint AnAngleRestraint APosRestraint ABoundDiheRestraint AFixedDiheRestraint AForcingDiheRestraint ABoundDistRestraint AFixedDistRestraint AForcingDistRestraint ABoundAngleRestraint AFixedAngleRestraint AForcingAngleRestraint ABoundPosRestraint AFixedPosRestraint AForcingPosRestraint List of all members.

Public Member Functions

 ARestraint ()
virtual ~ARestraint ()
int GetNumGroups ()
void SetKf (double Kf)
double GetKf ()
void SetLambdaKf (double LambdaKf)
void SetLambdaRef (double LambdaRef)
double GetLambdaKf ()
double GetLambdaRef ()
void SetGroup (AGroup &Group, int GroupIndex)
void SetGroups (AGroup &Group1)
void SetGroups (AGroup &Group1, AGroup &Group2)
void SetGroups (AGroup &Group1, AGroup &Group2, AGroup &Group3)
void SetGroups (AGroup &Group1, AGroup &Group2, AGroup &Group3, AGroup &Group4)
void UpdateCOMs (GlobalMasterFreeEnergy &CFE)
void DistributeForce (int WhichGroup, AVector Force, GlobalMasterFreeEnergy &CFE)
virtual AVector GetGradient (int WhichGroup)=0
virtual double GetEnergy ()=0
virtual void GetStr (char *Str)=0
virtual void PrintInfo ()=0
virtual Bool_t IsForcing ()
virtual double Get_dU_dLambda ()
virtual void SetRefPos (AVector)
virtual void SetRefDist (double)
virtual void SetRefAngle (double)
virtual void SetBound (Bound_t)
virtual void SetLowerAngle (double)
virtual void SetUpperAngle (double)
virtual void SetIntervalAngle (double)
virtual void SetStartPos (AVector)
virtual void SetStopPos (AVector)
virtual void SetStartDist (double)
virtual void SetStopDist (double)
virtual void SetStartAngle (double)
virtual void SetStopAngle (double)

Protected Member Functions

double GetAngle (AVector &A, AVector &B, AVector &C)
double GetDihe (AVector &A, AVector &B, AVector &C, AVector &D)
void EarlyExit (const char *Str, int AtomID)

Protected Attributes

double m_Kf
int m_NumGroups
AGroupm_pGroups
AVectorm_pCOMs

Static Protected Attributes

static double m_LambdaKf = 1.0
static double m_LambdaRef = 0.0

Detailed Description

Definition at line 17 of file FreeEnergyRestrain.h.


Constructor & Destructor Documentation

ARestraint::ARestraint (  ) 

Definition at line 42 of file FreeEnergyRestrain.C.

References m_NumGroups, m_pCOMs, and m_pGroups.

00042                        {
00043 //-----------------------------------------------------------------
00044 // constructor for base class
00045 //-----------------------------------------------------------------
00046   m_pGroups = NULL;
00047   m_pCOMs = NULL;
00048   m_NumGroups = 0;
00049 }

ARestraint::~ARestraint (  )  [virtual]

Definition at line 52 of file FreeEnergyRestrain.C.

References ASSERT, m_pCOMs, and m_pGroups.

00052                         {
00053 //-----------------------------------------------------------------
00054 // free space that may have been allocated for Groups and COM's
00055 //-----------------------------------------------------------------
00056   if (m_pGroups != NULL) {
00057     ASSERT(m_pCOMs != NULL);
00058     delete []m_pGroups;
00059     delete []m_pCOMs;
00060   }
00061 }


Member Function Documentation

void ARestraint::DistributeForce ( int  WhichGroup,
AVector  Force,
GlobalMasterFreeEnergy CFE 
)

Definition at line 179 of file FreeEnergyRestrain.C.

References GlobalMasterFreeEnergy::addForce(), ASSERT, EarlyExit(), GlobalMasterFreeEnergy::getMass(), AGroup::GetNumInGroup(), m_NumGroups, m_pGroups, and SetEqual().

Referenced by ARestraintManager::AddForces().

00180                                                               {
00181 //----------------------------------------------------------------------
00182 // Distribute Force among the group of atoms specified by WhichGroup
00183 //
00184 // note:  m_pGroups points to an array of Groups
00185 //        m_pGroups[WhichGroup] references one of the Groups
00186 //        m_pGroups[WhichGroup][i] returns an AtomID from the Group
00187 //        (operator[] is defined to return an item from the Group)
00188 //----------------------------------------------------------------------
00189   int     i, AtomID, NumAtoms, RetVal;
00190   double  Mass, TotalMass=0;
00191   AVector SmallForce;
00192   Vector  NAMD_Vector;
00193 
00194   ASSERT( (WhichGroup>=0) && (WhichGroup<m_NumGroups) );
00195 
00196   // calculate the total mass for the group
00197   NumAtoms = m_pGroups[WhichGroup].GetNumInGroup();
00198   for (i=0; i<NumAtoms; i++) {
00199     AtomID = m_pGroups[WhichGroup][i];
00200     Mass = CFE.getMass(AtomID);
00201     if (Mass < 0) {EarlyExit("Negative Mass", AtomID);};
00202     TotalMass += Mass;
00203   }
00204 
00205   // distribute Force according to mass of each atom in the group
00206   for (i=0; i<NumAtoms; i++) {
00207     AtomID = m_pGroups[WhichGroup][i];
00208     Mass = CFE.getMass(AtomID);
00209     if (Mass < 0) {EarlyExit("Negative Mass", AtomID);}
00210     SmallForce = Force * (Mass/TotalMass);
00211     // cast SmallForce to a NAMD-type vector (addForce uses Vector class)
00212     SetEqual(NAMD_Vector, SmallForce);
00213     RetVal = CFE.addForce(AtomID, NAMD_Vector);
00214     if (RetVal < 0) {EarlyExit("Can't add Force", AtomID);}
00215   }
00216 }

void ARestraint::EarlyExit ( const char *  Str,
int  AtomID 
) [protected]

Definition at line 64 of file FreeEnergyRestrain.C.

References endi(), iout, and NAMD_die().

Referenced by DistributeForce(), and UpdateCOMs().

00064                                                       {
00065 //-----------------------------------------------------------------
00066 // unrecoverable error
00067 //-----------------------------------------------------------------
00068   iout << "FreeEnergy: " << std::endl << endi;
00069   iout << "FreeEnergy: " << Str;
00070   iout << " for AtomID: " << AtomID;
00071   iout << std::endl << endi;
00072   NAMD_die("FreeEnergy: Fatal Error with Fixed or Forcing Restraints");
00073 }

virtual double ARestraint::Get_dU_dLambda (  )  [inline, virtual]

Reimplemented in AForcingPosRestraint, AForcingDistRestraint, AForcingAngleRestraint, and AForcingDiheRestraint.

Definition at line 77 of file FreeEnergyRestrain.h.

Referenced by ARestraintManager::Print_dU_dLambda_Info().

00077 {return(0.0);}

double ARestraint::GetAngle ( AVector A,
AVector B,
AVector C 
) [protected]

Definition at line 127 of file FreeEnergyRestrain.C.

References A, and B.

Referenced by AForcingAngleRestraint::Get_dU_dLambda(), AnAngleRestraint::GetE(), ABoundAngleRestraint::GetEnergy(), ABoundAngleRestraint::GetGradient(), and AnAngleRestraint::PrintInfo().

00127                                                               {
00128 //-----------------------------------------------------------------
00129 // determine the angle formed by the points A-B-C
00130 //-----------------------------------------------------------------
00131   double u;
00132   double a = B.Dist(C);
00133   double b = A.Dist(C);
00134   double c = A.Dist(B);
00135 
00136   u = (a*a + c*c - b*b) / (2.0*a*c);
00137   // protect against acos(<-1.0) and acos(>1.0)
00138   if (u < -1.0) {u = -1.0;}
00139   if (u >  1.0) {u =  1.0;}
00140   return(acos(u));
00141 }

double ARestraint::GetDihe ( AVector A,
AVector B,
AVector C,
AVector D 
) [protected]

Definition at line 144 of file FreeEnergyRestrain.C.

References A, B, AVector::cross(), AVector::Dist(), dot(), and AVector::dot().

Referenced by AForcingDiheRestraint::Get_dU_dLambda(), ADiheRestraint::GetE(), ABoundDiheRestraint::GetEnergy(), ADiheRestraint::GetGrad(), ABoundDiheRestraint::GetGradient(), and ADiheRestraint::PrintInfo().

00144                                                                          {
00145 //-----------------------------------------------------------------
00146 // determine the dihedral angle formed by the points A-B-C-D
00147 //-----------------------------------------------------------------
00148   AVector CD(D - C);
00149   AVector CB(B - C);
00150   AVector BC(C - B);
00151   AVector BA(A - B);
00152   AVector CDxCB, BCxBA;
00153   double  top, bot, cos_u, sin_u, Angle;
00154   AVector topVec;
00155 
00156   CDxCB = CD.cross(CB);
00157   BCxBA = BC.cross(BA);
00158 
00159   top = CDxCB.dot(BCxBA);
00160   bot = CDxCB.Dist() * BCxBA.Dist();
00161   cos_u = top/bot;
00162 
00163   // protect against acos(<-1.0) and acos(>1.0)
00164   if (cos_u < -1.0) {cos_u = -1.0;}
00165   if (cos_u >  1.0) {cos_u =  1.0;}
00166 
00167   topVec = CDxCB.cross(BCxBA);
00168   sin_u = (topVec/bot).dot(CB/CB.Dist());
00169 
00170   // protect against asin(<-1.0) and asin(>1.0)
00171   if (sin_u < -1.0) {sin_u = -1.0;}
00172   if (sin_u >  1.0) {sin_u =  1.0;}
00173 
00174   Angle = atan2(sin_u, cos_u);
00175   return(Angle);
00176 }

virtual double ARestraint::GetEnergy (  )  [pure virtual]

Implemented in AFixedPosRestraint, ABoundPosRestraint, AForcingPosRestraint, AFixedDistRestraint, ABoundDistRestraint, AForcingDistRestraint, AFixedAngleRestraint, ABoundAngleRestraint, AForcingAngleRestraint, AFixedDiheRestraint, ABoundDiheRestraint, and AForcingDiheRestraint.

Referenced by ARestraintManager::PrintEnergyInfo().

virtual AVector ARestraint::GetGradient ( int  WhichGroup  )  [pure virtual]

Implemented in AFixedPosRestraint, ABoundPosRestraint, AForcingPosRestraint, AFixedDistRestraint, ABoundDistRestraint, AForcingDistRestraint, AFixedAngleRestraint, ABoundAngleRestraint, AForcingAngleRestraint, AFixedDiheRestraint, ABoundDiheRestraint, and AForcingDiheRestraint.

double ARestraint::GetKf (  )  [inline]

Definition at line 51 of file FreeEnergyRestrain.h.

References m_Kf.

00051 {return(m_Kf);}

double ARestraint::GetLambdaKf (  )  [inline]

Definition at line 54 of file FreeEnergyRestrain.h.

References m_LambdaKf.

00054 {return(m_LambdaKf);}

double ARestraint::GetLambdaRef (  )  [inline]

Definition at line 55 of file FreeEnergyRestrain.h.

References m_LambdaRef.

00055 {return(m_LambdaRef);}

int ARestraint::GetNumGroups (  )  [inline]

Definition at line 49 of file FreeEnergyRestrain.h.

References m_NumGroups.

00049 {return(m_NumGroups);}

virtual void ARestraint::GetStr ( char *  Str  )  [pure virtual]

Implemented in AFixedPosRestraint, ABoundPosRestraint, AForcingPosRestraint, AFixedDistRestraint, ABoundDistRestraint, AForcingDistRestraint, AFixedAngleRestraint, ABoundAngleRestraint, AForcingAngleRestraint, AFixedDiheRestraint, ABoundDiheRestraint, and AForcingDiheRestraint.

Referenced by ARestraintManager::PrintPreInfo().

virtual Bool_t ARestraint::IsForcing (  )  [inline, virtual]

Reimplemented in AForcingPosRestraint, AForcingDistRestraint, AForcingAngleRestraint, and AForcingDiheRestraint.

Definition at line 76 of file FreeEnergyRestrain.h.

References kFalse.

00076 {return(kFalse);}

virtual void ARestraint::PrintInfo (  )  [pure virtual]

Implemented in APosRestraint, ADistRestraint, AnAngleRestraint, and ADiheRestraint.

Referenced by ARestraintManager::PrintRestraintInfo().

virtual void ARestraint::SetBound ( Bound_t   )  [inline, virtual]

Reimplemented in ABoundPosRestraint, ABoundDistRestraint, and ABoundAngleRestraint.

Definition at line 82 of file FreeEnergyRestrain.h.

References ASSERT, and kFalse.

Referenced by GetRestraint().

00082 {ASSERT(kFalse);}

void ARestraint::SetGroup ( AGroup Group,
int  GroupIndex 
)

Definition at line 76 of file FreeEnergyRestrain.C.

References ASSERT, m_NumGroups, and m_pGroups.

00076                                                        {
00077 //-----------------------------------------------------------------
00078 // set one group of atoms
00079 //-----------------------------------------------------------------
00080   ASSERT( (GroupIndex>=0) && (GroupIndex<m_NumGroups) );
00081   m_pGroups[GroupIndex] = Group;
00082 }

void ARestraint::SetGroups ( AGroup Group1,
AGroup Group2,
AGroup Group3,
AGroup Group4 
)

Definition at line 115 of file FreeEnergyRestrain.C.

References ASSERT, m_NumGroups, and m_pGroups.

00115                                                                                          {
00116 //-----------------------------------------------------------------
00117 // set four groups of atoms
00118 //-----------------------------------------------------------------
00119   ASSERT(m_NumGroups >= 4);
00120   m_pGroups[0] = Group1;
00121   m_pGroups[1] = Group2;
00122   m_pGroups[2] = Group3;
00123   m_pGroups[3] = Group4;
00124 }

void ARestraint::SetGroups ( AGroup Group1,
AGroup Group2,
AGroup Group3 
)

Definition at line 104 of file FreeEnergyRestrain.C.

References ASSERT, m_NumGroups, and m_pGroups.

00104                                                                          {
00105 //-----------------------------------------------------------------
00106 // set three groups of atoms
00107 //-----------------------------------------------------------------
00108   ASSERT(m_NumGroups >= 3);
00109   m_pGroups[0] = Group1;
00110   m_pGroups[1] = Group2;
00111   m_pGroups[2] = Group3;
00112 }

void ARestraint::SetGroups ( AGroup Group1,
AGroup Group2 
)

Definition at line 94 of file FreeEnergyRestrain.C.

References ASSERT, m_NumGroups, and m_pGroups.

00094                                                          {
00095 //-----------------------------------------------------------------
00096 // set two groups of atoms
00097 //-----------------------------------------------------------------
00098   ASSERT(m_NumGroups >= 2);
00099   m_pGroups[0] = Group1;
00100   m_pGroups[1] = Group2;
00101 }

void ARestraint::SetGroups ( AGroup Group1  ) 

Definition at line 85 of file FreeEnergyRestrain.C.

References ASSERT, m_NumGroups, and m_pGroups.

Referenced by GetRestraint().

00085                                          {
00086 //-----------------------------------------------------------------
00087 // set one group of atoms
00088 //-----------------------------------------------------------------
00089   ASSERT(m_NumGroups >= 1);
00090   m_pGroups[0] = Group1;
00091 }

virtual void ARestraint::SetIntervalAngle ( double   )  [inline, virtual]

Reimplemented in ABoundDiheRestraint.

Definition at line 85 of file FreeEnergyRestrain.h.

References ASSERT, and kFalse.

Referenced by GetRestraint().

00085 {ASSERT(kFalse);}

void ARestraint::SetKf ( double  Kf  )  [inline]

Definition at line 50 of file FreeEnergyRestrain.h.

References m_Kf.

Referenced by GetRestraint().

00050 {m_Kf=Kf;}

void ARestraint::SetLambdaKf ( double  LambdaKf  )  [inline]

Definition at line 52 of file FreeEnergyRestrain.h.

References m_LambdaKf.

Referenced by ARestraintManager::SetLambdaKf(), and ARestraintManager::SetLambdas().

00052 {m_LambdaKf=LambdaKf;}

void ARestraint::SetLambdaRef ( double  LambdaRef  )  [inline]

Definition at line 53 of file FreeEnergyRestrain.h.

References m_LambdaRef.

Referenced by ARestraintManager::SetLambdaRef(), and ARestraintManager::SetLambdas().

00053 {m_LambdaRef=LambdaRef;}

virtual void ARestraint::SetLowerAngle ( double   )  [inline, virtual]

Reimplemented in ABoundDiheRestraint.

Definition at line 83 of file FreeEnergyRestrain.h.

References ASSERT, and kFalse.

Referenced by GetRestraint().

00083 {ASSERT(kFalse);}

virtual void ARestraint::SetRefAngle ( double   )  [inline, virtual]

Reimplemented in AFixedAngleRestraint, ABoundAngleRestraint, and AFixedDiheRestraint.

Definition at line 81 of file FreeEnergyRestrain.h.

References ASSERT, and kFalse.

Referenced by GetRestraint().

00081 {ASSERT(kFalse);}

virtual void ARestraint::SetRefDist ( double   )  [inline, virtual]

Reimplemented in ABoundPosRestraint, AFixedDistRestraint, and ABoundDistRestraint.

Definition at line 80 of file FreeEnergyRestrain.h.

References ASSERT, and kFalse.

Referenced by GetRestraint().

00080 {ASSERT(kFalse);}

virtual void ARestraint::SetRefPos ( AVector   )  [inline, virtual]

Reimplemented in AFixedPosRestraint, and ABoundPosRestraint.

Definition at line 79 of file FreeEnergyRestrain.h.

References ASSERT, and kFalse.

Referenced by GetRestraint().

00079 {ASSERT(kFalse);}

virtual void ARestraint::SetStartAngle ( double   )  [inline, virtual]

Reimplemented in AForcingAngleRestraint, and AForcingDiheRestraint.

Definition at line 90 of file FreeEnergyRestrain.h.

References ASSERT, and kFalse.

Referenced by GetRestraint().

00090 {ASSERT(kFalse);}

virtual void ARestraint::SetStartDist ( double   )  [inline, virtual]

Reimplemented in AForcingDistRestraint.

Definition at line 88 of file FreeEnergyRestrain.h.

References ASSERT, and kFalse.

Referenced by GetRestraint().

00088 {ASSERT(kFalse);}

virtual void ARestraint::SetStartPos ( AVector   )  [inline, virtual]

Reimplemented in AForcingPosRestraint.

Definition at line 86 of file FreeEnergyRestrain.h.

References ASSERT, and kFalse.

Referenced by GetRestraint().

00086 {ASSERT(kFalse);}

virtual void ARestraint::SetStopAngle ( double   )  [inline, virtual]

Reimplemented in AForcingAngleRestraint, and AForcingDiheRestraint.

Definition at line 91 of file FreeEnergyRestrain.h.

References ASSERT, and kFalse.

Referenced by GetRestraint().

00091 {ASSERT(kFalse);}

virtual void ARestraint::SetStopDist ( double   )  [inline, virtual]

Reimplemented in AForcingDistRestraint.

Definition at line 89 of file FreeEnergyRestrain.h.

References ASSERT, and kFalse.

Referenced by GetRestraint().

00089 {ASSERT(kFalse);}

virtual void ARestraint::SetStopPos ( AVector   )  [inline, virtual]

Reimplemented in AForcingPosRestraint.

Definition at line 87 of file FreeEnergyRestrain.h.

References ASSERT, and kFalse.

Referenced by GetRestraint().

00087 {ASSERT(kFalse);}

virtual void ARestraint::SetUpperAngle ( double   )  [inline, virtual]

Reimplemented in ABoundDiheRestraint.

Definition at line 84 of file FreeEnergyRestrain.h.

References ASSERT, and kFalse.

Referenced by GetRestraint().

00084 {ASSERT(kFalse);}

void ARestraint::UpdateCOMs ( GlobalMasterFreeEnergy CFE  ) 

Definition at line 219 of file FreeEnergyRestrain.C.

References ASSERT, EarlyExit(), GlobalMasterFreeEnergy::getMass(), AGroup::GetNumInGroup(), GlobalMasterFreeEnergy::getPosition(), j, m_NumGroups, m_pCOMs, m_pGroups, AVector::Set(), and SetEqual().

00219                                                        {
00220 //-----------------------------------------------------------------
00221 // calculate the center-of-mass of each group of atoms
00222 //
00223 // note:  m_pGroups points to an array of Groups
00224 //        m_pGroups[i] references one of the Groups
00225 //        m_pGroups[i][j] returns an AtomID from the Group
00226 //        (operator[] is defined to return an item from the Group)
00227 //-----------------------------------------------------------------
00228   int      i, j, AtomID, RetVal;
00229   Vector   NAMD_Vector;
00230   AVector  COM, Pos;
00231   double   Mass, TotalMass;
00232 
00233   ASSERT(m_NumGroups > 0);
00234   // for each group of atoms
00235   for (i=0; i<m_NumGroups; i++) {
00236     TotalMass = 0;
00237     COM.Set(0,0,0);
00238     // for each atom in the group
00239     for (j=0; j<m_pGroups[i].GetNumInGroup(); j++) {
00240       AtomID = m_pGroups[i][j];
00241       // get its position, weight position with atom's mass
00242       RetVal = CFE.getPosition(AtomID, NAMD_Vector);
00243       if (RetVal < 0) {EarlyExit("Can't get Position", AtomID);}
00244       // cast NAMD_Vector to AVector (getPosition uses Vector class)
00245       SetEqual(Pos, NAMD_Vector);
00246       Mass = CFE.getMass(AtomID);
00247       if (Mass < 0) {EarlyExit("Negative Mass", AtomID);}
00248       TotalMass += Mass;
00249       COM += Pos * Mass;
00250     }
00251     m_pCOMs[i] = COM / TotalMass;
00252   }
00253 }


Member Data Documentation

double ARestraint::m_Kf [protected]

Definition at line 37 of file FreeEnergyRestrain.h.

Referenced by AForcingDiheRestraint::Get_dU_dLambda(), AForcingAngleRestraint::Get_dU_dLambda(), AForcingDistRestraint::Get_dU_dLambda(), AForcingPosRestraint::Get_dU_dLambda(), AnAngleRestraint::GetE(), ADistRestraint::GetE(), APosRestraint::GetE(), AForcingDiheRestraint::GetEnergy(), ABoundDiheRestraint::GetEnergy(), AFixedDiheRestraint::GetEnergy(), ABoundPosRestraint::GetEnergy(), AnAngleRestraint::GetGrad(), ADistRestraint::GetGrad(), APosRestraint::GetGrad(), AForcingDiheRestraint::GetGradient(), ABoundDiheRestraint::GetGradient(), AFixedDiheRestraint::GetGradient(), ABoundPosRestraint::GetGradient(), GetKf(), and SetKf().

double ARestraint::m_LambdaKf = 1.0 [static, protected]

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved.

Definition at line 43 of file FreeEnergyRestrain.h.

Referenced by AForcingDiheRestraint::Get_dU_dLambda(), AForcingAngleRestraint::Get_dU_dLambda(), AForcingDistRestraint::Get_dU_dLambda(), AForcingPosRestraint::Get_dU_dLambda(), AForcingDiheRestraint::GetEnergy(), AForcingAngleRestraint::GetEnergy(), AForcingDistRestraint::GetEnergy(), AForcingPosRestraint::GetEnergy(), AForcingDiheRestraint::GetGradient(), AForcingAngleRestraint::GetGradient(), AForcingDistRestraint::GetGradient(), AForcingPosRestraint::GetGradient(), GetLambdaKf(), and SetLambdaKf().

double ARestraint::m_LambdaRef = 0.0 [static, protected]

Definition at line 44 of file FreeEnergyRestrain.h.

Referenced by AForcingDiheRestraint::Get_dU_dLambda(), AForcingAngleRestraint::Get_dU_dLambda(), AForcingDistRestraint::Get_dU_dLambda(), AForcingPosRestraint::Get_dU_dLambda(), AForcingAngleRestraint::GetAngleTarget(), AForcingDiheRestraint::GetDiheTarget1(), AForcingPosRestraint::GetDistance(), AForcingDistRestraint::GetDistTarget(), AForcingDiheRestraint::GetEnergy(), AForcingAngleRestraint::GetEnergy(), AForcingDistRestraint::GetEnergy(), AForcingPosRestraint::GetEnergy(), AForcingDiheRestraint::GetGradient(), AForcingAngleRestraint::GetGradient(), AForcingDistRestraint::GetGradient(), AForcingPosRestraint::GetGradient(), GetLambdaRef(), AForcingPosRestraint::GetPosTarget(), and SetLambdaRef().

int ARestraint::m_NumGroups [protected]

Definition at line 38 of file FreeEnergyRestrain.h.

Referenced by ADiheRestraint::ADiheRestraint(), ADistRestraint::ADistRestraint(), AnAngleRestraint::AnAngleRestraint(), APosRestraint::APosRestraint(), ARestraint(), DistributeForce(), GetNumGroups(), SetGroup(), SetGroups(), and UpdateCOMs().

AVector* ARestraint::m_pCOMs [protected]

Definition at line 40 of file FreeEnergyRestrain.h.

Referenced by ADiheRestraint::ADiheRestraint(), ADistRestraint::ADistRestraint(), AnAngleRestraint::AnAngleRestraint(), APosRestraint::APosRestraint(), ARestraint(), AForcingDiheRestraint::Get_dU_dLambda(), AForcingAngleRestraint::Get_dU_dLambda(), AForcingDistRestraint::Get_dU_dLambda(), AForcingPosRestraint::Get_dU_dLambda(), AForcingPosRestraint::GetDistance(), ABoundPosRestraint::GetDistance(), AFixedPosRestraint::GetDistance(), ADiheRestraint::GetE(), AnAngleRestraint::GetE(), ADistRestraint::GetE(), APosRestraint::GetE(), ABoundDiheRestraint::GetEnergy(), ABoundAngleRestraint::GetEnergy(), ABoundDistRestraint::GetEnergy(), ABoundPosRestraint::GetEnergy(), ADiheRestraint::GetGrad(), AnAngleRestraint::GetGrad(), ADistRestraint::GetGrad(), APosRestraint::GetGrad(), ABoundDiheRestraint::GetGradient(), ABoundAngleRestraint::GetGradient(), ABoundDistRestraint::GetGradient(), ABoundPosRestraint::GetGradient(), ADiheRestraint::PrintInfo(), AnAngleRestraint::PrintInfo(), ADistRestraint::PrintInfo(), APosRestraint::PrintInfo(), UpdateCOMs(), and ~ARestraint().

AGroup* ARestraint::m_pGroups [protected]

Definition at line 39 of file FreeEnergyRestrain.h.

Referenced by ADiheRestraint::ADiheRestraint(), ADistRestraint::ADistRestraint(), AnAngleRestraint::AnAngleRestraint(), APosRestraint::APosRestraint(), ARestraint(), DistributeForce(), SetGroup(), SetGroups(), UpdateCOMs(), and ~ARestraint().


The documentation for this class was generated from the following files:
Generated on Tue Aug 14 01:17:17 2018 for NAMD by  doxygen 1.4.7