ARestraintManager Class Reference

#include <FreeEnergyRMgr.h>

Public Member Functions
	ARestraintManager ()
	~ARestraintManager ()
ARestraint *	operator[] (int Index)
void	Add (ARestraint *pRestraint)
int	GetNumRestraints ()
void	UpdateCOMs (GlobalMasterFreeEnergy &CFE)
void	AddForces (GlobalMasterFreeEnergy &CFE)
void	PrintEnergyInfo ()
void	PrintRestraintInfo ()
void	Print_dU_dLambda_Info ()
double	Sum_dU_dLambdas ()
Bool_t	ThereIsAForcingRestraint ()
void	PrintPreInfo (int Index)
void	SetLambdaKf (double LambdaKf)
void	SetLambdaRef (double LambdaRef)
void	SetLambdas (double LambdaKf, double LambdaRef)

Detailed Description

Definition at line 23 of file FreeEnergyRMgr.h.

Constructor & Destructor Documentation

ARestraintManager()

ARestraintManager::ARestraintManager

(

)

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

Definition at line 27 of file FreeEnergyRMgr.C.

References kNumToStart.

                                     {
//------------------------------------------------------------------------
// allocate space for restraint POINTERS
//------------------------------------------------------------------------
  m_ppRestraints = new pRestr[kNumToStart];
  m_NumRestraints = 0;
  m_MaxNum = kNumToStart;
}

~ARestraintManager()

ARestraintManager::~ARestraintManager

(

)

Definition at line 37 of file FreeEnergyRMgr.C.

                                      {
//------------------------------------------------------------------------
// when the RestraintManager goes out of scope,
// free the space that was allocated for each restraint
// (see: ARestraint* GetRestraint(char*, int&)
// then, free the space that was allocated for the pointers
//------------------------------------------------------------------------
  for (int i=0; i<m_NumRestraints; i++) {
    delete m_ppRestraints[i];
  }
  delete []m_ppRestraints;
}

Member Function Documentation

Add()

void ARestraintManager::Add

(

ARestraint *

pRestraint

)

Definition at line 60 of file FreeEnergyRMgr.C.

References kMultiplier.

Referenced by ReadRestraints().

                                                  {
//------------------------------------------------------------------------
// add a pointer to the list.  if there's not enough room, make room.
//------------------------------------------------------------------------
  ARestraint**  ppRestraints;

  // if there's no room for a new pointer
  if (m_NumRestraints == m_MaxNum) {
    // create an array with more space
    m_MaxNum *= kMultiplier;
    ppRestraints = new pRestr[m_MaxNum];
    // fast copy from the full array to the new one (memcpy(dest, src, bytes))
    memcpy(ppRestraints, m_ppRestraints, sizeof(ARestraint*)*m_NumRestraints);
    // return the space used for the full array
    delete []m_ppRestraints;
    // point to the bigger array
    m_ppRestraints = ppRestraints;
  }

  // add the int to the int array
  m_ppRestraints[m_NumRestraints] = pRestraint;
  m_NumRestraints++;
}

AddForces()

void ARestraintManager::AddForces

(

GlobalMasterFreeEnergy &

CFE

)

Definition at line 98 of file FreeEnergyRMgr.C.

References ARestraint::DistributeForce(), ARestraint::GetGradient(), and ARestraint::GetNumGroups().

                                                             {
//---------------------------------------------------------------------------
// for each restraint, apply restraining force to each COM (center-of-mass).
//---------------------------------------------------------------------------
  int      i, j, NumCOMs;
  AVector  Force;

  // for each restraint
  for (i=0; i<m_NumRestraints; i++) {
    // for each center-of-mass
    NumCOMs = m_ppRestraints[i]->GetNumGroups();
    for (j=0; j<NumCOMs; j++) {
      Force = m_ppRestraints[i]->GetGradient(j);
      // apply restraining force in opposite direction from gradient
      Force *= -1.0;
      m_ppRestraints[i]->DistributeForce(j, Force, CFE);
    }
  }
}

GetNumRestraints()

int ARestraintManager::GetNumRestraints ( )

inline

Definition at line 35 of file FreeEnergyRMgr.h.

{return(m_NumRestraints);}

operator[]()

ARestraint * ARestraintManager::operator[]

(

int

Index

)

Definition at line 51 of file FreeEnergyRMgr.C.

References ASSERT.

                                                    {
//------------------------------------------------------------------------
// get a pointer
//------------------------------------------------------------------------
  ASSERT( (Index>=0) && (Index<m_NumRestraints) );
  return(m_ppRestraints[Index]);
}

Print_dU_dLambda_Info()

void ARestraintManager::Print_dU_dLambda_Info

(

)

Definition at line 175 of file FreeEnergyRMgr.C.

References endi(), ARestraint::Get_dU_dLambda(), iout, and PrintPreInfo().

                                              {
//---------------------------------------------------------------------------
// if restraint is a forcing restraint, print dU/dLambda.
//---------------------------------------------------------------------------
#if defined(_VERBOSE_PMF)
  for (int i=0; i<m_NumRestraints; i++) {
    if (m_ppRestraints[i]->IsForcing()) {
      PrintPreInfo(i);
      iout << "dU/dLambda = ";
      iout << m_ppRestraints[i]->Get_dU_dLambda() << std::endl << endi;
    }
  }
#endif
}

PrintEnergyInfo()

void ARestraintManager::PrintEnergyInfo

(

)

Definition at line 145 of file FreeEnergyRMgr.C.

References endi(), ARestraint::GetEnergy(), iout, and PrintPreInfo().

                                        {
//---------------------------------------------------------------------------
// for a restraint, print restraint type and Energy.
//---------------------------------------------------------------------------
#if defined(_VERBOSE_PMF)
  for (int i=0; i<m_NumRestraints; i++) {
    PrintPreInfo(i);
    iout << "Energy = ";
    iout << m_ppRestraints[i]->GetEnergy() << std::endl << endi;
  }
#endif
}

PrintPreInfo()

void ARestraintManager::PrintPreInfo

(

int

Index

)

Definition at line 191 of file FreeEnergyRMgr.C.

References ARestraint::GetStr(), and iout.

Referenced by Print_dU_dLambda_Info(), PrintEnergyInfo(), and PrintRestraintInfo().

                                              {
//---------------------------------------------------------------------------
// print "Restraint xxx:  Type of Restraint:  "
//---------------------------------------------------------------------------
  char  Str[100];
  char  NumStr[20];

  sprintf(NumStr, "%3d", Index+1);
  iout << "FreeEnergy: " << "Restraint " << NumStr << ":  ";
  m_ppRestraints[Index]->GetStr(Str);
  iout << Str << ":  ";
}

PrintRestraintInfo()

void ARestraintManager::PrintRestraintInfo

(

)

Definition at line 159 of file FreeEnergyRMgr.C.

References endi(), iout, ARestraint::PrintInfo(), and PrintPreInfo().

                                           {
//---------------------------------------------------------------------------
// for a restraint, print its position, distance, angle, or dihedral angle.
//---------------------------------------------------------------------------
  for (int i=0; i<m_NumRestraints; i++) {
#if defined(_VERBOSE_PMF)
    PrintPreInfo(i);
#endif
    m_ppRestraints[i]->PrintInfo();
  }
#if !defined(_VERBOSE_PMF)
  iout << std::endl << endi;
#endif
}

SetLambdaKf()

void ARestraintManager::SetLambdaKf ( double  LambdaKf )

inline

Definition at line 44 of file FreeEnergyRMgr.h.

References ARestraint::SetLambdaKf().

{m_Dummy.SetLambdaKf(LambdaKf);}

SetLambdaRef()

void ARestraintManager::SetLambdaRef ( double  LambdaRef )

inline

Definition at line 45 of file FreeEnergyRMgr.h.

References ARestraint::SetLambdaRef().

{m_Dummy.SetLambdaRef(LambdaRef);}

SetLambdas()

void ARestraintManager::SetLambdas ( double  LambdaKf, double  LambdaRef  )

inline

Definition at line 46 of file FreeEnergyRMgr.h.

References ARestraint::SetLambdaKf(), and ARestraint::SetLambdaRef().

  {
     m_Dummy.SetLambdaKf(LambdaKf);
     m_Dummy.SetLambdaRef(LambdaRef);
  }

Sum_dU_dLambdas()

double ARestraintManager::Sum_dU_dLambdas

(

)

Definition at line 119 of file FreeEnergyRMgr.C.

References ARestraint::Get_dU_dLambda().

                                          {
//---------------------------------------------------------------------------
// sum up dU/dLambda from each forcing restraint
//---------------------------------------------------------------------------
  double Sum=0;

  for (int i=0; i<m_NumRestraints; i++) {
    Sum += m_ppRestraints[i]->Get_dU_dLambda();
  }
  return(Sum);
}

ThereIsAForcingRestraint()

Bool_t ARestraintManager::ThereIsAForcingRestraint

(

)

Definition at line 132 of file FreeEnergyRMgr.C.

References kFalse, and kTrue.

                                                   {
//---------------------------------------------------------------------------
// return kTrue if there's at least one forcing restraint
//---------------------------------------------------------------------------
  for (int i=0; i<m_NumRestraints; i++) {
    if (m_ppRestraints[i]->IsForcing()) {
      return(kTrue);
    }
  }
  return(kFalse);
}

UpdateCOMs()

void ARestraintManager::UpdateCOMs

(

GlobalMasterFreeEnergy &

CFE

)

Definition at line 85 of file FreeEnergyRMgr.C.

References ARestraint::UpdateCOMs().

                                                              {
//------------------------------------------------------------------------
// update the centers-of-mass in each restraint in the list
// note:  m_ppRestraints points to a list of restraint pointers
//        m_ppRestraints[i] references one of the pointers
//        m_ppRestraints[i]-> accesses a restraint function
//------------------------------------------------------------------------
  for (int i=0; i<m_NumRestraints; i++) {
    m_ppRestraints[i]->UpdateCOMs(CFE);
  }
}

---

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

• FreeEnergyRMgr.h
• FreeEnergyRMgr.C