ALambdaManager Class Reference

#include <FreeEnergyLambdMgr.h>

Public Member Functions
	ALambdaManager ()
	~ALambdaManager ()
ALambdaControl &	operator[] (int index)
void	Clear ()
int	Add (ALambdaControl &PmfBlock)
int	GetNumObjects ()
Bool_t	GetLambdas (double &LambdaKf, double &LambdaRef)
Bool_t	IsTimeToPrint ()
Bool_t	IsFirstStep ()
Bool_t	IsTimeToPrint_dU_dLambda ()
Bool_t	IsTimeToClearAccumulator ()
Bool_t	IsEndOf_MCTI_Step ()
Bool_t	IsEndOf_MCTI ()
int	GetNumStepsSoFar ()
int	GetNumAccumStepsSoFar ()
void	PrintHeader (double dT)
void	PrintLambdaHeader (double dT)
void	Print_dU_dLambda_Summary (double Sum_dU_dLambdas)
void	PrintSomeSpaces ()
void	Print_MCTI_Integration ()
void	IncCurrStep ()
int	GetTotalNumSteps ()
void	Integrate_MCTI ()
void	Accumulate (double dU_dLambda)
double	GetAccumulation ()
double	GetIntegration ()
void	ZeroAccumulator ()
int	GetNum_dU_dLambda ()

Detailed Description

Definition at line 18 of file FreeEnergyLambdMgr.h.

Constructor & Destructor Documentation

ALambdaManager()

ALambdaManager::ALambdaManager

(

)

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

Definition at line 19 of file FreeEnergyLambdMgr.C.

References kLambdaNumToStart.

                               {
//------------------------------------------------------------------------
// make room for some LambdaControl objects.
//------------------------------------------------------------------------
  m_ActiveIndex = 0;
  m_NumObjects = 0;
  m_pPmfBlocks = new ALambdaControl[kLambdaNumToStart];
  m_MaxNum = kLambdaNumToStart;
}

~ALambdaManager()

ALambdaManager::~ALambdaManager

(

)

Definition at line 30 of file FreeEnergyLambdMgr.C.

                                {
//------------------------------------------------------------------------
// return borrowed memory to the free store.
//------------------------------------------------------------------------
  delete []m_pPmfBlocks;
}

Member Function Documentation

Accumulate()

void ALambdaManager::Accumulate

(

double

dU_dLambda

)

Definition at line 56 of file FreeEnergyLambdMgr.C.

References ASSERT.

                                                 {
//------------------------------------------------------------------------
// add dU_dLambda to the active accumulator (in one of the lambda objects)
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  (*this)[m_ActiveIndex].Accumulate(dU_dLambda);
}

Add()

int ALambdaManager::Add

(

ALambdaControl &

PmfBlock

)

Definition at line 273 of file FreeEnergyLambdMgr.C.

References kLambdaMultiplier.

Referenced by ReadInput().

                                                {
//------------------------------------------------------------------------
// add an object to the list.  if there's not enough room, make room.
// return an index to the added oject.
//------------------------------------------------------------------------
  ALambdaControl*  pPmfBlocks;

  // if there's no room for another object
  if (m_NumObjects == m_MaxNum) {
    // create an array with more space
    m_MaxNum *= kLambdaMultiplier;
    pPmfBlocks = new ALambdaControl[m_MaxNum];
    // copy from the full array to the new one
    for (int i=0; i<m_NumObjects; i++) {
      pPmfBlocks[i] = m_pPmfBlocks[i];
    }
    // return the space used for the full array
    delete []m_pPmfBlocks;
    // point to the bigger array
    m_pPmfBlocks = pPmfBlocks;
  }
  // add the object to the array
  m_pPmfBlocks[m_NumObjects] = PmfBlock;
  m_NumObjects++;
  return(m_NumObjects-1);
}

Clear()

void ALambdaManager::Clear

(

)

Definition at line 265 of file FreeEnergyLambdMgr.C.

                           {
//------------------------------------------------------------------------
// leave memory allocation alone.
//------------------------------------------------------------------------
  m_NumObjects = 0;
}

GetAccumulation()

double ALambdaManager::GetAccumulation

(

)

Definition at line 65 of file FreeEnergyLambdMgr.C.

References ASSERT.

Referenced by Print_dU_dLambda_Summary().

                                       {
//------------------------------------------------------------------------
// get the accumulation of dU_dLambda from active lambda object.
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  return((*this)[m_ActiveIndex].GetAccumulation());
}

GetIntegration()

double ALambdaManager::GetIntegration

(

)

Definition at line 74 of file FreeEnergyLambdMgr.C.

References ASSERT.

Referenced by Print_MCTI_Integration().

                                      {
//------------------------------------------------------------------------
// get accumulation of <dU_dLambda> * dLambda from active lambda object.
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  return((*this)[m_ActiveIndex].GetIntegration());
}

GetLambdas()

Bool_t ALambdaManager::GetLambdas	(	double &	LambdaKf,
		double &	LambdaRef
	)

Definition at line 233 of file FreeEnergyLambdMgr.C.

References ASSERT, kFalse, and kTrue.

                                                                     {
//------------------------------------------------------------------------
// get LambdaKf and LambdaRef from the active LambdaControl
//
// return(kTrue) if an active LambdaControl is found
// return(kFalse) if all LambdaControls have expired
//------------------------------------------------------------------------
  // don't continue if all LamdaControl's have expired
  if (m_ActiveIndex == m_NumObjects) {
    return(kFalse);
  }

  // if the m_ActiveIndex'th LambdaControl is no longer active
  if ( !(*this)[m_ActiveIndex].IsActive()) {
    // move on to the next one
    m_ActiveIndex++;
    // if there is no next object, return KFalse
    if (m_ActiveIndex == m_NumObjects) {
      return(kFalse);
    }
    // otherwise, make sure the next one's active
    else {
      ASSERT( (*this)[m_ActiveIndex].IsActive() );
    }
  }
  // return LambdaKf and LambdaRef from the active LambdaControl
  LambdaKf =  (*this)[m_ActiveIndex].GetLambdaKf();
  LambdaRef = (*this)[m_ActiveIndex].GetLambdaRef();
  return(kTrue);
}

GetNum_dU_dLambda()

int ALambdaManager::GetNum_dU_dLambda

(

)

Definition at line 38 of file FreeEnergyLambdMgr.C.

References ASSERT.

Referenced by Print_dU_dLambda_Summary().

                                       {
//------------------------------------------------------------------------
// get number times dU_dLambda accumulated from active lambda object.
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  return((*this)[m_ActiveIndex].GetNum_dU_dLambda());
}

GetNumAccumStepsSoFar()

int ALambdaManager::GetNumAccumStepsSoFar

(

)

Definition at line 179 of file FreeEnergyLambdMgr.C.

References ASSERT.

Referenced by Print_MCTI_Integration().

                                          {
//------------------------------------------------------------------------
// return the total number of steps dU/dLambda has been accumulated
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  return((*this)[m_ActiveIndex].GetNumAccumStepsSoFar());
}

GetNumObjects()

int ALambdaManager::GetNumObjects ( )

inline

Definition at line 33 of file FreeEnergyLambdMgr.h.

{return(m_NumObjects);}

GetNumStepsSoFar()

int ALambdaManager::GetNumStepsSoFar

(

)

Definition at line 170 of file FreeEnergyLambdMgr.C.

References ASSERT.

                                     {
//------------------------------------------------------------------------
// return the number of steps taken in the active LambdaControl block
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  return((*this)[m_ActiveIndex].GetNumStepsSoFar());
}

GetTotalNumSteps()

int ALambdaManager::GetTotalNumSteps

(

)

Definition at line 310 of file FreeEnergyLambdMgr.C.

References ALambdaControl::GetNumSteps().

                                     {
//------------------------------------------------------------------------
// calculate and return the total number of steps needed for all
// pmf and mcti blocks
//------------------------------------------------------------------------
  int  Total, i;
  
  Total = 0;
  for (i=0; i<m_NumObjects; i++) {
    Total += m_pPmfBlocks[i].GetNumSteps();
  }
  return(Total);
}

IncCurrStep()

void ALambdaManager::IncCurrStep ( )

inline

Definition at line 48 of file FreeEnergyLambdMgr.h.

References ALambdaControl::IncCurrStep().

{m_Dummy.IncCurrStep();}

Integrate_MCTI()

void ALambdaManager::Integrate_MCTI

(

)

Definition at line 47 of file FreeEnergyLambdMgr.C.

References ASSERT.

                                    {
//------------------------------------------------------------------------
// integrate <dU/dLambda> for MCTI
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  (*this)[m_ActiveIndex].Integrate_MCTI();
}

IsEndOf_MCTI()

Bool_t ALambdaManager::IsEndOf_MCTI

(

)

Definition at line 142 of file FreeEnergyLambdMgr.C.

References ASSERT.

                                    {
//------------------------------------------------------------------------
// ASSUMING that the m_ActiveIndex'th LambdaControl is active,
// decide if this is the last time step of an MCTI block
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  return((*this)[m_ActiveIndex].IsEndOf_MCTI());
}

IsEndOf_MCTI_Step()

Bool_t ALambdaManager::IsEndOf_MCTI_Step

(

)

Definition at line 132 of file FreeEnergyLambdMgr.C.

References ASSERT.

                                         {
//------------------------------------------------------------------------
// ASSUMING that the m_ActiveIndex'th LambdaControl is active,
// decide if this is the last time step of an MCTI step
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  return((*this)[m_ActiveIndex].IsEndOf_MCTI_Step());
}

IsFirstStep()

Bool_t ALambdaManager::IsFirstStep

(

)

Definition at line 92 of file FreeEnergyLambdMgr.C.

References ASSERT.

                                   {
//------------------------------------------------------------------------
// ASSUMING that the m_ActiveIndex'th LambdaControl is active,
// decide if it's time to print restraint information
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  return((*this)[m_ActiveIndex].IsFirstStep());
}

IsTimeToClearAccumulator()

Bool_t ALambdaManager::IsTimeToClearAccumulator

(

)

Definition at line 122 of file FreeEnergyLambdMgr.C.

References ASSERT.

                                                {
//------------------------------------------------------------------------
// ASSUMING that the m_ActiveIndex'th LambdaControl is active,
// decide if it's time to start accumulating dU/dLambda from zero
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  return((*this)[m_ActiveIndex].IsTimeToClearAccumulator());
}

IsTimeToPrint()

Bool_t ALambdaManager::IsTimeToPrint

(

)

Definition at line 102 of file FreeEnergyLambdMgr.C.

References ASSERT.

                                     {
//------------------------------------------------------------------------
// ASSUMING that the m_ActiveIndex'th LambdaControl is active,
// decide if it's time to print restraint information
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  return((*this)[m_ActiveIndex].IsTimeToPrint());
}

IsTimeToPrint_dU_dLambda()

Bool_t ALambdaManager::IsTimeToPrint_dU_dLambda

(

)

Definition at line 112 of file FreeEnergyLambdMgr.C.

References ASSERT.

                                                {
//------------------------------------------------------------------------
// ASSUMING that the m_ActiveIndex'th LambdaControl is active,
// decide if it's time to print du/dLambda information
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  return((*this)[m_ActiveIndex].IsTimeToPrint_dU_dLambda());
}

operator[]()

ALambdaControl & ALambdaManager::operator[]

(

int

index

)

Definition at line 301 of file FreeEnergyLambdMgr.C.

References ASSERT.

                                                     {
//------------------------------------------------------------------------
// return an object from this group of objects.
//------------------------------------------------------------------------
  ASSERT((Index>=0) && (Index<m_NumObjects));
  return(m_pPmfBlocks[Index]);
}

Print_dU_dLambda_Summary()

void ALambdaManager::Print_dU_dLambda_Summary

(

double

Sum_dU_dLambdas

)

Definition at line 198 of file FreeEnergyLambdMgr.C.

References endi(), GetAccumulation(), GetNum_dU_dLambda(), and iout.

                                                                    {
//------------------------------------------------------------------------
// print sum of dU/dLambda's for current time-step and
// the accumulation of the above.
//------------------------------------------------------------------------
  char  Str[100];

#if defined(_VERBOSE_PMF)
  iout << "FreeEnergy: ";
  iout << "For all forcing restraints, dU/dLambda  = ";
  iout << Sum_dU_dLambdas << std::endl << endi;
  iout << "FreeEnergy: ";
  iout << "For all forcing restraints, Free Energy = ";
  iout << GetAccumulation();
  iout << " for " << GetNum_dU_dLambda() << " steps" << std::endl << endi;
#else
  sprintf(Str, "%10.2e", GetAccumulation());
  iout << Str << "  ";
  sprintf(Str, "%6d", GetNum_dU_dLambda());
  iout << Str << "  ";
#endif
}

Print_MCTI_Integration()

void ALambdaManager::Print_MCTI_Integration

(

)

Definition at line 222 of file FreeEnergyLambdMgr.C.

References endi(), GetIntegration(), GetNumAccumStepsSoFar(), and iout.

                                            {
//------------------------------------------------------------------------
// print the integral of: <dU/dLambda> * dLambda
//------------------------------------------------------------------------
  iout << "FreeEnergy: ";
  iout << "For MCTI, Free Energy Integral = ";
  iout << GetIntegration();
  iout << " for " << GetNumAccumStepsSoFar() << " steps" << std::endl << endi;
}

PrintHeader()

void ALambdaManager::PrintHeader

(

double

dT

)

Definition at line 161 of file FreeEnergyLambdMgr.C.

References ASSERT.

                                          {
//------------------------------------------------------------------------
// print information about current time step
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  (*this)[m_ActiveIndex].PrintHeader(dT);
}

PrintLambdaHeader()

void ALambdaManager::PrintLambdaHeader

(

double

dT

)

Definition at line 152 of file FreeEnergyLambdMgr.C.

References ASSERT.

                                                {
//------------------------------------------------------------------------
// print header for a new lambda control object
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  (*this)[m_ActiveIndex].PrintLambdaHeader(dT);
}

PrintSomeSpaces()

void ALambdaManager::PrintSomeSpaces

(

)

Definition at line 188 of file FreeEnergyLambdMgr.C.

References iout.

                                     {
//------------------------------------------------------------------------
// some stuff to make the output look nice
//------------------------------------------------------------------------
#if !defined(_VERBOSE_PMF)
  iout << "                    ";
#endif
}

ZeroAccumulator()

void ALambdaManager::ZeroAccumulator

(

)

Definition at line 83 of file FreeEnergyLambdMgr.C.

References ASSERT.

                                     {
//------------------------------------------------------------------------
// zero accumulation of dU_dLambda in the active lambda object.
//------------------------------------------------------------------------
  ASSERT((*this)[m_ActiveIndex].IsActive());
  (*this)[m_ActiveIndex].ZeroAccumulator();
}

---

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

• FreeEnergyLambdMgr.h
• FreeEnergyLambdMgr.C