AnAngleRestraint Class Reference

#include <FreeEnergyRestrain.h>

Inheritance diagram for AnAngleRestraint:

Public Member Functions
	AnAngleRestraint ()
void	PrintInfo ()
virtual double	GetAngleTarget ()=0
Public Member Functions inherited from ARestraint
	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 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	GetE (double RefAngle, double LambdaKf=1.0)
AVector	GetGrad (int WhichGroup, double RefAngle, double LambdaKf=1.0)
Protected Member Functions inherited from ARestraint
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)

Additional Inherited Members
Protected Attributes inherited from ARestraint
double	m_Kf
int	m_NumGroups
AGroup *	m_pGroups
AVector *	m_pCOMs
Static Protected Attributes inherited from ARestraint
static double	m_LambdaKf = 1.0
static double	m_LambdaRef = 0.0

Detailed Description

Definition at line 132 of file FreeEnergyRestrain.h.

Constructor & Destructor Documentation

AnAngleRestraint()

AnAngleRestraint::AnAngleRestraint

(

)

Definition at line 421 of file FreeEnergyRestrain.C.

References ARestraint::m_NumGroups, ARestraint::m_pCOMs, and ARestraint::m_pGroups.

                                   {
//-----------------------------------------------------------------------
// each AnAngleRestraint restrains the angle between 3 groups of atoms
//-----------------------------------------------------------------------
  m_NumGroups = 3;
  m_pGroups = new AGroup[m_NumGroups];
  m_pCOMs = new AVector[m_NumGroups];
}

Member Function Documentation

GetAngleTarget()

virtual double AnAngleRestraint::GetAngleTarget ( )

pure virtual

Implemented in AForcingAngleRestraint, ABoundAngleRestraint, and AFixedAngleRestraint.

Referenced by PrintInfo().

GetE()

double AnAngleRestraint::GetE ( double  RefAngle, double  LambdaKf = 1.0  )

protected

Definition at line 460 of file FreeEnergyRestrain.C.

References ARestraint::GetAngle(), ARestraint::m_Kf, and ARestraint::m_pCOMs.

Referenced by AFixedAngleRestraint::GetEnergy(), ABoundAngleRestraint::GetEnergy(), and AForcingAngleRestraint::GetEnergy().

                                                              {
//---------------------------------------------------------------------------
// calculate and return the Energy for this angle restraint.
//
//     E = (Kf/2) * (Theta-ThetaRef)**2
//
// where Theta is the angle between 3 centers-of-mass of restrained atoms,
// m_pCOMs[0] -- m_pCOMs[1] -- m_pCOMs[2].
// ThetaRef is the reference angle.
//
// Note:  COM's are calculated before this routine is called.
//---------------------------------------------------------------------------
  double Angle, Diff;

  Angle = GetAngle(m_pCOMs[0], m_pCOMs[1], m_pCOMs[2]);
  Diff = Angle - RefAngle;
  return( ((m_Kf*LambdaKf)/2.0) * (Diff*Diff) );
}

GetGrad()

AVector AnAngleRestraint::GetGrad ( int  WhichGroup, double  RefAngle, double  LambdaKf = 1.0  )

protected

Definition at line 480 of file FreeEnergyRestrain.C.

References ASSERT, AVector::Dist(), kAlmostOne, ARestraint::m_Kf, and ARestraint::m_pCOMs.

Referenced by AFixedAngleRestraint::GetGradient(), ABoundAngleRestraint::GetGradient(), and AForcingAngleRestraint::GetGradient().

                                                                    {
//---------------------------------------------------------------------------
// calculate and return the gradient for this angle restraint.
//
//     E = (Kf/2) * (Theta-ThetaRef)**2
//
// return:  grad(E)
//
// Notes: COM's are calculated before this routine is called.
//---------------------------------------------------------------------------
  AVector A, B, C;
  double  Angle;
  double  a, b, c;
  double  u;
  double  Const1, Const2, Const3, Const4, Const5;
  AVector Vec1, Vec2;

  ASSERT( (WhichGroup==0) || (WhichGroup==1) || (WhichGroup==2) );
  A = m_pCOMs[0];
  B = m_pCOMs[1];
  C = m_pCOMs[2];

  a = B.Dist(C);
  b = A.Dist(C);
  c = A.Dist(B);

  u = (a*a + c*c - b*b) / (2.0*a*c);

  // protect against acos(<-1.0), acos(>1.0), sqrt(<0), and divide by 0
  if (u < -1.0)       {u = -1.0;}
  if (u > kAlmostOne) {u = kAlmostOne;}
  Angle = acos(u);

  Const1 = -1.0 / sqrt(1.0 - u*u);
  Const2 = m_Kf * LambdaKf * (Angle-RefAngle) * Const1;

  Const3 = -a/(2.0*c*c) + 1.0/(a+a) + (b*b)/(2.0*a*c*c);
  Const4 = -c/(2.0*a*a) + 1.0/(c+c) + (b*b)/(2.0*c*a*a);
  Const5 = -b/(a*c);

  if (WhichGroup == 0) {
    Vec1 = (A-C) * (Const5/b);
    Vec2 = (A-B) * (Const3/c);
  }
  else if (WhichGroup == 1) {
    Vec1 = (B-A) * (Const3/c);
    Vec2 = (B-C) * (Const4/a);
  }
  else {
    Vec1 = (C-A) * (Const5/b);
    Vec2 = (C-B) * (Const4/a);
  }
  return( (Vec1+Vec2)*Const2);
}

PrintInfo()

void AnAngleRestraint::PrintInfo ( )

virtual

Implements ARestraint.

Definition at line 431 of file FreeEnergyRestrain.C.

References endi(), ARestraint::GetAngle(), GetAngleTarget(), iout, kPi, and ARestraint::m_pCOMs.

                                 {
//--------------------------------------------------------------------
// print the angle for this angle restraint
//--------------------------------------------------------------------
  double  Angle;
  char    Str1[20], Str2[20];

  Angle = GetAngle(m_pCOMs[0], m_pCOMs[1], m_pCOMs[2]) * (180/kPi);
  sprintf(Str1, "%8.3f", Angle);
  Angle = GetAngleTarget() * (180/kPi);
  sprintf(Str2, "%8.3f", Angle);

#if defined(_VERBOSE_PMF)
  iout << "Angle = ";
  iout << Str1;
  iout << " degrees";
  iout << "  Target = ";
  iout << Str2;
  iout << " degrees";
  iout << std::endl << endi;
#else
  iout << Str1;
  iout << "  ";
  iout << Str2;
  iout << " | ";
#endif
}

---

The documentation for this class was generated from the following files:

• FreeEnergyRestrain.h
• FreeEnergyRestrain.C