ALambdaManager Class Reference

#include <FreeEnergyLambdMgr.h>

List of all members.

Public Member Functions

 ALambdaManager ()
 ~ALambdaManager ()
ALambdaControloperator[] (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 (  ) 

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.

00019                                {
00020 //------------------------------------------------------------------------
00021 // make room for some LambdaControl objects.
00022 //------------------------------------------------------------------------
00023   m_ActiveIndex = 0;
00024   m_NumObjects = 0;
00025   m_pPmfBlocks = new ALambdaControl[kLambdaNumToStart];
00026   m_MaxNum = kLambdaNumToStart;
00027 }

ALambdaManager::~ALambdaManager (  ) 

Definition at line 30 of file FreeEnergyLambdMgr.C.

00030                                 {
00031 //------------------------------------------------------------------------
00032 // return borrowed memory to the free store.
00033 //------------------------------------------------------------------------
00034   delete []m_pPmfBlocks;
00035 }


Member Function Documentation

void ALambdaManager::Accumulate ( double  dU_dLambda  ) 

Definition at line 56 of file FreeEnergyLambdMgr.C.

References ASSERT.

00056                                                  {
00057 //------------------------------------------------------------------------
00058 // add dU_dLambda to the active accumulator (in one of the lambda objects)
00059 //------------------------------------------------------------------------
00060   ASSERT((*this)[m_ActiveIndex].IsActive());
00061   (*this)[m_ActiveIndex].Accumulate(dU_dLambda);
00062 }

int ALambdaManager::Add ( ALambdaControl PmfBlock  ) 

Definition at line 273 of file FreeEnergyLambdMgr.C.

References kLambdaMultiplier.

Referenced by ReadInput().

00273                                                 {
00274 //------------------------------------------------------------------------
00275 // add an object to the list.  if there's not enough room, make room.
00276 // return an index to the added oject.
00277 //------------------------------------------------------------------------
00278   ALambdaControl*  pPmfBlocks;
00279 
00280   // if there's no room for another object
00281   if (m_NumObjects == m_MaxNum) {
00282     // create an array with more space
00283     m_MaxNum *= kLambdaMultiplier;
00284     pPmfBlocks = new ALambdaControl[m_MaxNum];
00285     // copy from the full array to the new one
00286     for (int i=0; i<m_NumObjects; i++) {
00287       pPmfBlocks[i] = m_pPmfBlocks[i];
00288     }
00289     // return the space used for the full array
00290     delete []m_pPmfBlocks;
00291     // point to the bigger array
00292     m_pPmfBlocks = pPmfBlocks;
00293   }
00294   // add the object to the array
00295   m_pPmfBlocks[m_NumObjects] = PmfBlock;
00296   m_NumObjects++;
00297   return(m_NumObjects-1);
00298 }

void ALambdaManager::Clear (  ) 

Definition at line 265 of file FreeEnergyLambdMgr.C.

00265                            {
00266 //------------------------------------------------------------------------
00267 // leave memory allocation alone.
00268 //------------------------------------------------------------------------
00269   m_NumObjects = 0;
00270 }

double ALambdaManager::GetAccumulation (  ) 

Definition at line 65 of file FreeEnergyLambdMgr.C.

References ASSERT.

Referenced by Print_dU_dLambda_Summary().

00065                                        {
00066 //------------------------------------------------------------------------
00067 // get the accumulation of dU_dLambda from active lambda object.
00068 //------------------------------------------------------------------------
00069   ASSERT((*this)[m_ActiveIndex].IsActive());
00070   return((*this)[m_ActiveIndex].GetAccumulation());
00071 }

double ALambdaManager::GetIntegration (  ) 

Definition at line 74 of file FreeEnergyLambdMgr.C.

References ASSERT.

Referenced by Print_MCTI_Integration().

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

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

Definition at line 233 of file FreeEnergyLambdMgr.C.

References ASSERT, kFalse, and kTrue.

00233                                                                      {
00234 //------------------------------------------------------------------------
00235 // get LambdaKf and LambdaRef from the active LambdaControl
00236 //
00237 // return(kTrue) if an active LambdaControl is found
00238 // return(kFalse) if all LambdaControls have expired
00239 //------------------------------------------------------------------------
00240   // don't continue if all LamdaControl's have expired
00241   if (m_ActiveIndex == m_NumObjects) {
00242     return(kFalse);
00243   }
00244 
00245   // if the m_ActiveIndex'th LambdaControl is no longer active
00246   if ( !(*this)[m_ActiveIndex].IsActive()) {
00247     // move on to the next one
00248     m_ActiveIndex++;
00249     // if there is no next object, return KFalse
00250     if (m_ActiveIndex == m_NumObjects) {
00251       return(kFalse);
00252     }
00253     // otherwise, make sure the next one's active
00254     else {
00255       ASSERT( (*this)[m_ActiveIndex].IsActive() );
00256     }
00257   }
00258   // return LambdaKf and LambdaRef from the active LambdaControl
00259   LambdaKf =  (*this)[m_ActiveIndex].GetLambdaKf();
00260   LambdaRef = (*this)[m_ActiveIndex].GetLambdaRef();
00261   return(kTrue);
00262 }

int ALambdaManager::GetNum_dU_dLambda (  ) 

Definition at line 38 of file FreeEnergyLambdMgr.C.

References ASSERT.

Referenced by Print_dU_dLambda_Summary().

00038                                        {
00039 //------------------------------------------------------------------------
00040 // get number times dU_dLambda accumulated from active lambda object.
00041 //------------------------------------------------------------------------
00042   ASSERT((*this)[m_ActiveIndex].IsActive());
00043   return((*this)[m_ActiveIndex].GetNum_dU_dLambda());
00044 }

int ALambdaManager::GetNumAccumStepsSoFar (  ) 

Definition at line 179 of file FreeEnergyLambdMgr.C.

References ASSERT.

Referenced by Print_MCTI_Integration().

00179                                           {
00180 //------------------------------------------------------------------------
00181 // return the total number of steps dU/dLambda has been accumulated
00182 //------------------------------------------------------------------------
00183   ASSERT((*this)[m_ActiveIndex].IsActive());
00184   return((*this)[m_ActiveIndex].GetNumAccumStepsSoFar());
00185 }

int ALambdaManager::GetNumObjects (  )  [inline]

Definition at line 33 of file FreeEnergyLambdMgr.h.

00033 {return(m_NumObjects);}

int ALambdaManager::GetNumStepsSoFar (  ) 

Definition at line 170 of file FreeEnergyLambdMgr.C.

References ASSERT.

00170                                      {
00171 //------------------------------------------------------------------------
00172 // return the number of steps taken in the active LambdaControl block
00173 //------------------------------------------------------------------------
00174   ASSERT((*this)[m_ActiveIndex].IsActive());
00175   return((*this)[m_ActiveIndex].GetNumStepsSoFar());
00176 }

int ALambdaManager::GetTotalNumSteps (  ) 

Definition at line 310 of file FreeEnergyLambdMgr.C.

00310                                      {
00311 //------------------------------------------------------------------------
00312 // calculate and return the total number of steps needed for all
00313 // pmf and mcti blocks
00314 //------------------------------------------------------------------------
00315   int  Total, i;
00316   
00317   Total = 0;
00318   for (i=0; i<m_NumObjects; i++) {
00319     Total += m_pPmfBlocks[i].GetNumSteps();
00320   }
00321   return(Total);
00322 }

void ALambdaManager::IncCurrStep (  )  [inline]

Definition at line 48 of file FreeEnergyLambdMgr.h.

References ALambdaControl::IncCurrStep().

00048 {m_Dummy.IncCurrStep();}

void ALambdaManager::Integrate_MCTI (  ) 

Definition at line 47 of file FreeEnergyLambdMgr.C.

References ASSERT.

00047                                     {
00048 //------------------------------------------------------------------------
00049 // integrate <dU/dLambda> for MCTI
00050 //------------------------------------------------------------------------
00051   ASSERT((*this)[m_ActiveIndex].IsActive());
00052   (*this)[m_ActiveIndex].Integrate_MCTI();
00053 }

Bool_t ALambdaManager::IsEndOf_MCTI (  ) 

Definition at line 142 of file FreeEnergyLambdMgr.C.

References ASSERT.

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

Bool_t ALambdaManager::IsEndOf_MCTI_Step (  ) 

Definition at line 132 of file FreeEnergyLambdMgr.C.

References ASSERT.

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

Bool_t ALambdaManager::IsFirstStep (  ) 

Definition at line 92 of file FreeEnergyLambdMgr.C.

References ASSERT.

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

Bool_t ALambdaManager::IsTimeToClearAccumulator (  ) 

Definition at line 122 of file FreeEnergyLambdMgr.C.

References ASSERT.

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

Bool_t ALambdaManager::IsTimeToPrint (  ) 

Definition at line 102 of file FreeEnergyLambdMgr.C.

References ASSERT.

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

Bool_t ALambdaManager::IsTimeToPrint_dU_dLambda (  ) 

Definition at line 112 of file FreeEnergyLambdMgr.C.

References ASSERT.

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

ALambdaControl & ALambdaManager::operator[] ( int  index  ) 

Definition at line 301 of file FreeEnergyLambdMgr.C.

References ASSERT.

00301                                                      {
00302 //------------------------------------------------------------------------
00303 // return an object from this group of objects.
00304 //------------------------------------------------------------------------
00305   ASSERT((Index>=0) && (Index<m_NumObjects));
00306   return(m_pPmfBlocks[Index]);
00307 }

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.

00198                                                                     {
00199 //------------------------------------------------------------------------
00200 // print sum of dU/dLambda's for current time-step and
00201 // the accumulation of the above.
00202 //------------------------------------------------------------------------
00203   char  Str[100];
00204 
00205 #if defined(_VERBOSE_PMF)
00206   iout << "FreeEnergy: ";
00207   iout << "For all forcing restraints, dU/dLambda  = ";
00208   iout << Sum_dU_dLambdas << std::endl << endi;
00209   iout << "FreeEnergy: ";
00210   iout << "For all forcing restraints, Free Energy = ";
00211   iout << GetAccumulation();
00212   iout << " for " << GetNum_dU_dLambda() << " steps" << std::endl << endi;
00213 #else
00214   sprintf(Str, "%10.2e", GetAccumulation());
00215   iout << Str << "  ";
00216   sprintf(Str, "%6d", GetNum_dU_dLambda());
00217   iout << Str << "  ";
00218 #endif
00219 }

void ALambdaManager::Print_MCTI_Integration (  ) 

Definition at line 222 of file FreeEnergyLambdMgr.C.

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

00222                                             {
00223 //------------------------------------------------------------------------
00224 // print the integral of: <dU/dLambda> * dLambda
00225 //------------------------------------------------------------------------
00226   iout << "FreeEnergy: ";
00227   iout << "For MCTI, Free Energy Integral = ";
00228   iout << GetIntegration();
00229   iout << " for " << GetNumAccumStepsSoFar() << " steps" << std::endl << endi;
00230 }

void ALambdaManager::PrintHeader ( double  dT  ) 

Definition at line 161 of file FreeEnergyLambdMgr.C.

References ASSERT.

00161                                           {
00162 //------------------------------------------------------------------------
00163 // print information about current time step
00164 //------------------------------------------------------------------------
00165   ASSERT((*this)[m_ActiveIndex].IsActive());
00166   (*this)[m_ActiveIndex].PrintHeader(dT);
00167 }

void ALambdaManager::PrintLambdaHeader ( double  dT  ) 

Definition at line 152 of file FreeEnergyLambdMgr.C.

References ASSERT.

00152                                                 {
00153 //------------------------------------------------------------------------
00154 // print header for a new lambda control object
00155 //------------------------------------------------------------------------
00156   ASSERT((*this)[m_ActiveIndex].IsActive());
00157   (*this)[m_ActiveIndex].PrintLambdaHeader(dT);
00158 }

void ALambdaManager::PrintSomeSpaces (  ) 

Definition at line 188 of file FreeEnergyLambdMgr.C.

References iout.

00188                                      {
00189 //------------------------------------------------------------------------
00190 // some stuff to make the output look nice
00191 //------------------------------------------------------------------------
00192 #if !defined(_VERBOSE_PMF)
00193   iout << "                    ";
00194 #endif
00195 }

void ALambdaManager::ZeroAccumulator (  ) 

Definition at line 83 of file FreeEnergyLambdMgr.C.

References ASSERT.

00083                                      {
00084 //------------------------------------------------------------------------
00085 // zero accumulation of dU_dLambda in the active lambda object.
00086 //------------------------------------------------------------------------
00087   ASSERT((*this)[m_ActiveIndex].IsActive());
00088   (*this)[m_ActiveIndex].ZeroAccumulator();
00089 }


The documentation for this class was generated from the following files:
Generated on Tue Sep 26 01:17:17 2017 for NAMD by  doxygen 1.4.7