ADistRestraint Class Reference

#include <FreeEnergyRestrain.h>

Inheritance diagram for ADistRestraint:

Public Member Functions
	ADistRestraint ()
void	PrintInfo ()
virtual double	GetDistTarget ()=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 RefDist, double LambdaKf=1.0)
AVector	GetGrad (int WhichGroup, double RefDist, 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 118 of file FreeEnergyRestrain.h.

Constructor & Destructor Documentation

ADistRestraint()

ADistRestraint::ADistRestraint

(

)

Definition at line 333 of file FreeEnergyRestrain.C.

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

                               {
//-----------------------------------------------------------------------
// each ADistRestraint restrains the distance between 2 groups of atoms
//-----------------------------------------------------------------------
  m_NumGroups = 2;
  m_pGroups = new AGroup[m_NumGroups];
  m_pCOMs = new AVector[m_NumGroups];
}

Member Function Documentation

GetDistTarget()

virtual double ADistRestraint::GetDistTarget ( )

pure virtual

Implemented in AForcingDistRestraint, ABoundDistRestraint, and AFixedDistRestraint.

Referenced by PrintInfo().

GetE()

double ADistRestraint::GetE ( double  RefDist, double  LambdaKf = 1.0  )

protected

Definition at line 370 of file FreeEnergyRestrain.C.

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

Referenced by AFixedDistRestraint::GetEnergy(), ABoundDistRestraint::GetEnergy(), and AForcingDistRestraint::GetEnergy().

                                                           {
//---------------------------------------------------------------------------
// calculate and return the Energy for this distance restraint.
//
//     E = (Kf/2) * (di-dref)**2
//
// where di is the distance between 2 centers-of-mass of restrained atoms,
// and dref is the reference distance.
//
// Note:  COM's are calculated before this routine is called.
//---------------------------------------------------------------------------
  double Dist, Diff;

  Dist = m_pCOMs[0].Dist(m_pCOMs[1]);
  Diff = Dist - RefDist;
  return( ((m_Kf*LambdaKf)/2.0) * (Diff*Diff) );
}

GetGrad()

AVector ADistRestraint::GetGrad ( int  WhichGroup, double  RefDist, double  LambdaKf = 1.0  )

protected

Definition at line 389 of file FreeEnergyRestrain.C.

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

Referenced by AFixedDistRestraint::GetGradient(), ABoundDistRestraint::GetGradient(), and AForcingDistRestraint::GetGradient().

                                                                 {
//---------------------------------------------------------------------------
// calculate and return the gradient for this distance restraint.
//
//     E = (Kf/2) * (di-dref)**2
//
// return:  grad(E)
//
// Notes: COM is calculated before this routine is called.
//        m_pCOMS[0 & 1] reference the COM's of each group of atoms
//---------------------------------------------------------------------------
  double  Dist;
  AVector Vec, A, B;

  ASSERT( (WhichGroup==0) || (WhichGroup==1) );
  if (WhichGroup == 0) {
    A = m_pCOMs[0];
    B = m_pCOMs[1];
  }
  else {
    A = m_pCOMs[1];
    B = m_pCOMs[0];
  }

  Dist = A.Dist(B);
  Vec.Set(A[0]-B[0], A[1]-B[1], A[2]-B[2]);
  Vec *= m_Kf * LambdaKf * (Dist - RefDist) / Dist;
  return(Vec);
}

PrintInfo()

void ADistRestraint::PrintInfo ( )

virtual

Implements ARestraint.

Definition at line 343 of file FreeEnergyRestrain.C.

References AVector::Dist(), endi(), GetDistTarget(), iout, and ARestraint::m_pCOMs.

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

  Distance = m_pCOMs[0].Dist(m_pCOMs[1]);
  sprintf(Str1, "%7.3f", Distance);
  Distance = GetDistTarget();
  sprintf(Str2, "%7.3f", Distance);

#if defined(_VERBOSE_PMF)
  iout << "Distance = ";
  iout << Str1;
  iout << "  Target = ";
  iout << Str2;
  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