FreeEnergyParse.C File Reference

#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include "common.h"
#include "InfoStream.h"
#include "FreeEnergyEnums.h"
#include "FreeEnergyAssert.h"
#include "Vector.h"
#include "FreeEnergyVector.h"
#include "FreeEnergyGroup.h"
#include "FreeEnergyRestrain.h"
#include "FreeEnergyRMgr.h"
#include "FreeEnergyLambda.h"
#include "FreeEnergyLambdMgr.h"
#include "NamdTypes.h"
#include "GlobalMaster.h"
#include "GlobalMasterFreeEnergy.h"
#include "FreeEnergyParse.h"

Go to the source code of this file.

Functions
void	ProblemParsing (const char *Message, const char *Str, Bool_t Terminate)
void	CheckParentheses (const char *Str)
void	ReadInput (char *Str, ARestraintManager &RMgr, ALambdaManager &LMgr, GlobalMasterFreeEnergy &CFE, double dT)
int	ReadPmfBlock (char *Str, ALambdaControl &PmfBlock, double dT)
double	GetTime (double Val, TimeUnits_t Units)
int	ReadTimeUnits (char *Str, TimeUnits_t &Units, TimeUnits_t DefaultUnits)
int	ReadTaskType (char *Str, feptask_t &Task)
int	ReadNextPmfSpec (char *Str, pmf_t &PmfSpec)
int	ReadRestraints (char *Str, ARestraintManager &AllRestraints, GlobalMasterFreeEnergy &CFE)
ARestraint *	GetRestraint (char *Str, int &NumChars, GlobalMasterFreeEnergy &CFE)
int	ReadBound (char *Str, Bound_t &Bound)
int	ReadAValue (char *Str, double &Value, Bool_t ErrMsg)
int	ReadChar (char *Str, char Char, Bool_t ErrMsg)
int	ReadWord (const char *Str, const char *Word, Bool_t ErrMsg)
restr_t	ReadNextRestraintType (char *Str, int &NumChars)
int	AddAtoms (AGroup &Group, char *Str, GlobalMasterFreeEnergy &CFE)
void	AddAtomsInResidues (AGroup &Group, char *AtomNames, char *ResRange, GlobalMasterFreeEnergy &CFE)
void	AddResidues (AGroup &Group, char *ResRange, GlobalMasterFreeEnergy &CFE)
void	AddAtom (AGroup &Group, char *Atom, GlobalMasterFreeEnergy &CFE)
void	AddAtom (AGroup &Group, char *ResRange, char *AtomName, GlobalMasterFreeEnergy &CFE)
void	GetResRange (char *ResRange, int &ResNum1, int &ResNum2)
int	GetSegName (char *Str, char *SegName)
int	GetResNum (char *Str, int &ResNum)
int	GetAtomName (char *Str, char *AtomName)
item_t	ReadNextItem (char *Str, int &NumChars)
int	IsStartGroup (char *Str)
int	IsEndGroup (char *Str)
int	IsAtomName (char *Str)
int	IsAtomNameList (char *Str)
int	IsAtom (char *Str)
int	IsResidueRange (char *Str)
int	IsResidue (char *Str)
int	IsAResidue (char *Str)
int	ReadParentheses (const char *Str)
int	ReadAlpha (const char *Str)
int	ReadAlphaNum (const char *Str)
int	ReadDigits (const char *Str)
int	ReadWhite (const char *Str)
void	ToLower (char *Str)

---

Function Documentation

void AddAtom (  AGroup &  Group, char *  ResRange, char *  AtomName, GlobalMasterFreeEnergy &  CFE )

Definition at line 1024 of file FreeEnergyParse.C. References AGroup::Add(), AtomID, GlobalMasterFreeEnergy::getAtomID(), GetResRange(), GetSegName(), ProblemParsing(), and GlobalMasterFreeEnergy::requestAtom(). Referenced by AddAtom(), AddAtoms(), and AddAtomsInResidues(). { //------------------------------------------------------------------- // Group contains a list of int's representing AtomID's. // ResRange should be "(segname, resnum) to (segname, resnum)" // or "(segname, resnum)" // AtomName is specified separately. // get the atomID, and add it to Group. //------------------------------------------------------------------- char SegName[21]; int ResNum, ResNum1, ResNum2, AtomID, RetVal; // convert "(segname, resnum1) to (segname, resnum2)" // -> SegName, ResNum1, ResNum2 GetSegName(ResRange, SegName); GetResRange(ResRange, ResNum1, ResNum2); // get atomID for each atom in the specified residue range // register it, add it to Group for (ResNum=ResNum1; ResNum<=ResNum2; ResNum++) { AtomID = CFE.getAtomID(SegName, ResNum, AtomName); if (AtomID < 0) { ProblemParsing("Invalid AtomID", ResRange); } RetVal = CFE.requestAtom(AtomID); if (RetVal < 0) { ProblemParsing("Unable to requestAtom", ResRange); } Group.Add(AtomID); } }

void AddAtom (  AGroup &  Group, char *  Atom, GlobalMasterFreeEnergy &  CFE )

Definition at line 1011 of file FreeEnergyParse.C. { //------------------------------------------------------------------- // Group contains a list of int's representing AtomID's. // Atom should be "(segname, resnum, atomname)" // get the atomID for Atom, and add it to Group. //------------------------------------------------------------------- char AtomName[21]; GetAtomName(Atom, AtomName); AddAtom(Group, Atom, AtomName, CFE); }

int AddAtoms (  AGroup &  Group, char *  Str, GlobalMasterFreeEnergy &  CFE )

Definition at line 875 of file FreeEnergyParse.C. References AddAtom(), AddAtomsInResidues(), AddResidues(), Bool_t, kAtom, kAtomName, kAtomNameList, kEndGroup, kResidue, kResidueRange, kStartGroup, ProblemParsing(), ReadNextItem(), and ReadWhite(). Referenced by GetRestraint(). { //---------------------------------------------------------------------------- // Str contains specifications for which atoms to add to Group. // The atoms may be: // a) a single atom, b) all atoms of a residue, c) a list of atoms // d) all atoms in a list of residues, e) all atoms in a range of residues, // e) one or more atomnames in a list of residues, or // f) one or more atomnames in a range of residues // Add the AtomID's for these specified atoms to Group. // return the number of characters in Str that were read. //---------------------------------------------------------------------------- int NumChars; int RetNumChars = 0; Bool_t GroupMode = kFalse; Bool_t AtomList = kFalse; Bool_t Finished = kFalse; char* SavePtr = 0; while (!Finished) { switch(ReadNextItem(Str, NumChars)) { case kStartGroup: GroupMode = kTrue; break; case kEndGroup: Finished = kTrue; break; case kAtom: AddAtom(Group, Str, CFE); if (!GroupMode) { Finished = kTrue; } break; case kAtomName: case kAtomNameList: AtomList = kTrue; SavePtr = Str; break; case kResidue: case kResidueRange: if (AtomList) { AddAtomsInResidues(Group, SavePtr, Str, CFE); } else { AddResidues(Group, Str, CFE); } if (!GroupMode) { Finished = kTrue; } break; default: Finished = kTrue; ProblemParsing("Can't Read Atoms", Str); break; } Str += NumChars; RetNumChars += NumChars; } RetNumChars += ReadWhite(Str); return(RetNumChars); }

void AddAtomsInResidues (  AGroup &  Group, char *  AtomNames, char *  ResRange, GlobalMasterFreeEnergy &  CFE )

Definition at line 937 of file FreeEnergyParse.C. References AddAtom(), AddResidues(), ReadAlphaNum(), and ReadWhite(). Referenced by AddAtoms(). { //------------------------------------------------------------------- // Group contains a list of int's representing AtomID's. // ResRange should be "(segname, resnum) to (segname, resnum)" // or "(segname, resnum)" // AtomNames should be "(atomname, atomname, ...):" or "atomname:" // get the atomID's for each atomname in ResRange, add them to Group. //------------------------------------------------------------------- int Count, ArrayIndex, i; char AtomNamesArray[21][30]; // skip to start of first atomname if (AtomNames[0] == '(') { AtomNames++; Count = ReadWhite(AtomNames); AtomNames += Count; } // put each atomname into the array, finish when ':' or ')' is found ArrayIndex = 0; while ( (AtomNames[0]!=':') && (AtomNames[0]!=')') ) { Count = ReadAlphaNum(AtomNames); strncpy(AtomNamesArray[ArrayIndex], AtomNames, Count); AtomNamesArray[ArrayIndex][Count] = '\0'; AtomNames += Count; Count = ReadWhite(AtomNames); AtomNames += Count; ArrayIndex++; } // now add each atomname of Res to Group. // if "all" is specified, add all atoms of Res to Group. for (i=0; i<ArrayIndex; i++) { if (strcmp(AtomNamesArray[i], "all") == 0) { AddResidues(Group, ResRange, CFE); } else { AddAtom(Group, ResRange, AtomNamesArray[i], CFE); } } }

void AddResidues (  AGroup &  Group, char *  ResRange, GlobalMasterFreeEnergy &  CFE )

Definition at line 979 of file FreeEnergyParse.C. References AGroup::Add(), AtomID, GlobalMasterFreeEnergy::getAtomID(), GlobalMasterFreeEnergy::getNumAtoms(), GetResRange(), GetSegName(), ProblemParsing(), and GlobalMasterFreeEnergy::requestAtom(). Referenced by AddAtoms(), and AddAtomsInResidues(). { //------------------------------------------------------------------- // Group contains a list of int's representing AtomID's. // ResRange should be "(segname, resnum) to (segname, resnum)" // or "(segname, resnum)" // get the atomID's for each atom of ResRange, and add them to Group. //------------------------------------------------------------------- char SegName[21]; int ResNum1, ResNum2, ResNum; int i, NumAtoms, AtomID, RetVal; // get start and stop residue numbers GetSegName(ResRange, SegName); GetResRange(ResRange, ResNum1, ResNum2); // for each residue of residue range for (ResNum=ResNum1; ResNum<=ResNum2; ResNum++) { // for each atom of residue NumAtoms = CFE.getNumAtoms(SegName, ResNum); if (NumAtoms < 1) { ProblemParsing("No Atoms in Residue", ResRange); } for (i=0; i<NumAtoms; i++) { // get atomID, register it, add it to Group AtomID = CFE.getAtomID(SegName, ResNum, i); if (AtomID < 0) { ProblemParsing("Invalid AtomID", ResRange); } RetVal = CFE.requestAtom(AtomID); if (RetVal < 0) { ProblemParsing("Unable to requestAtom", ResRange); } Group.Add(AtomID); } } }

void CheckParentheses (  const char *  Str  )

Definition at line 54 of file FreeEnergyParse.C. References ProblemParsing(). Referenced by ReadInput(). { //---------------------------------------------------------------------------- // check for balanced '(' ')' and '{' '}' //---------------------------------------------------------------------------- int ParenthesesCount = 0; int CurlyBracketCount = 0; for (unsigned int i=0; i<strlen(Str); i++) { if (Str[i] == '(') {ParenthesesCount++;} if (Str[i] == ')') {ParenthesesCount--;} if (Str[i] == '{') {CurlyBracketCount++;} if (Str[i] == '}') {CurlyBracketCount--;} if ((ParenthesesCount<0) || (CurlyBracketCount<0)) { ProblemParsing("Mismatched Parentheses", Str+i); } } }

int GetAtomName (  char *  Str, char *  AtomName )

Definition at line 1134 of file FreeEnergyParse.C. References GetResNum(), ProblemParsing(), ReadAlphaNum(), and ReadWhite(). Referenced by AddAtom(). { //------------------------------------------------------------------- // Str should be (segname, resnum, atomname) // put atomname into AtomName // return the number of characters from start-of-Str thru ')' //------------------------------------------------------------------- int Count, ResNum; char* FullString=Str; Str += GetResNum(Str, ResNum); Str += ReadWhite(Str); Count = ReadAlphaNum(Str); if (Count == 0) {ProblemParsing("Missing Atom Name", Str);} strncpy(AtomName, Str, Count); AtomName[Count] = '\0'; Str += Count; Str += ReadWhite(Str); if (Str[0] != ')') {ProblemParsing("Missing )", Str);} Str += 1; return(Str-FullString); }

int GetResNum (  char *  Str, int &  ResNum )

Definition at line 1114 of file FreeEnergyParse.C. References GetSegName(), ProblemParsing(), ReadDigits(), and ReadWhite(). Referenced by GetAtomName(), and GetResRange(). { //------------------------------------------------------------------- // Str should be (segname, resnum) or (segname, resnum, atomname) // convert resnum to an int and return it // return the number of characters from start-of-Str thru resnum //------------------------------------------------------------------- int Count; char SegName[21]; char* FullString=Str; Str += GetSegName(Str, SegName); Str += ReadWhite(Str); ResNum = (int) strtol(Str, NULL, 10); Count = ReadDigits(Str); if (Count == 0) {ProblemParsing("Missing Residue Number", Str);} Str += Count; return(Str-FullString); }

void GetResRange (  char *  ResRange, int &  ResNum1, int &  ResNum2 )

Definition at line 1053 of file FreeEnergyParse.C. References GetResNum(), GetSegName(), ProblemParsing(), ReadAlphaNum(), ReadParentheses(), and ReadWhite(). Referenced by AddAtom(), and AddResidues(). { //------------------------------------------------------------------- // ResRange should be "(segname, resnum1) to (segname, resnum2)" // return ResNum1 & ResNum2 // if "to" is missing, return resnum1 in both ResNum1 & ResNum2 //------------------------------------------------------------------- char SegName1[21], SegName2[21]; // get start residue number GetSegName(ResRange, SegName1); GetResNum(ResRange, ResNum1); // skip to where "to" should appear ResRange += ReadParentheses(ResRange); ResRange += ReadWhite(ResRange); // if "to" is found if (strncmp(ResRange, "to", 2) == 0) { //skip to next residue ResRange += ReadAlphaNum(ResRange); ResRange += ReadWhite(ResRange); // get final residue number GetSegName(ResRange, SegName2); GetResNum(ResRange, ResNum2); // do some checks if (strcmp(SegName1, SegName2)!=0) { ProblemParsing("SegNames Differ", ResRange); } if (ResNum2 < ResNum1) { ProblemParsing("Decreasing Residues", ResRange); } } // otherwise, ResNum2 = ResNum1 else { ResNum2 = ResNum1; } }

ARestraint* GetRestraint (  char *  Str, int &  NumChars, GlobalMasterFreeEnergy &  CFE )

Definition at line 410 of file FreeEnergyParse.C. References AddAtoms(), ASSERT, Bool_t, Bound_t, kAngle, kAngleBound, kAnglePMF, kDihe, kDiheBound, kDihePMF, kDist, kDistBound, kDistPMF, kPi, kPosi, kPosiBound, kPosiPMF, kUnknownRestr, ProblemParsing(), ReadAValue(), ReadBound(), ReadChar(), ReadNextRestraintType(), ReadWord(), restr_t, ARestraint::SetBound(), ARestraint::SetGroups(), ARestraint::SetIntervalAngle(), ARestraint::SetKf(), ARestraint::SetLowerAngle(), ARestraint::SetRefAngle(), ARestraint::SetRefDist(), ARestraint::SetRefPos(), ARestraint::SetStartAngle(), ARestraint::SetStartDist(), ARestraint::SetStartPos(), ARestraint::SetStopAngle(), ARestraint::SetStopDist(), ARestraint::SetStopPos(), and ARestraint::SetUpperAngle(). Referenced by ReadRestraints(). { //---------------------------------------------------------------------------- // read spec's for a restraint, from the input string. // allocate space for and initialize a restraint object with these specs. // note: memory is allocated here, and free'd elsewhere. // // return a pointer to this object. // return the number of characters to read past these specs. // return NumChars=0 for illegal restraint specs. //---------------------------------------------------------------------------- AGroup Group1, Group2, Group3, Group4; ARestraint* pRestraint = NULL; restr_t Restraint; Bound_t Bound; int Count; double Kf; double D, D0, D1; double A=0, A0=0, A1=0, A2=0; AVector Pos, Pos0, Pos1; char* FullStr; char* TempStr; const Bool_t kPrintErrMsg=kTrue; // kNoErrMsg=kFalse; // save pointer to full string FullStr = Str; NumChars = 0; // get restraint type Restraint = ReadNextRestraintType(Str, Count); if (Count == 0) { ProblemParsing("Can't Read Restraint Type", Str); return(pRestraint); } // skip past restraint type ASSERT(Restraint != kUnknownRestr); Str += Count; // read in appropriate number of atoms or groups-of-atoms for // this restraint type, put the atoms in Group1 thru Group4 switch (Restraint) { case kDihe: case kDiheBound: case kDihePMF: Str += AddAtoms(Group4, Str, CFE); case kAngle: case kAngleBound: case kAnglePMF: Str += AddAtoms(Group3, Str, CFE); case kDist: case kDistBound: case kDistPMF: Str += AddAtoms(Group2, Str, CFE); case kPosi: case kPosiBound: case kPosiPMF: Str += AddAtoms(Group1, Str, CFE); default: ; } // for dihedrals, allow keywords of "barr=", "gap=", OR "kf=" // for other restraints, just allow "kf=" TempStr = Str; switch(Restraint) { case kDihe: case kDiheBound: case kDihePMF: Str += ReadWord(Str, "barr"); Str += ReadWord(Str, "gap"); default: Str += ReadWord(Str, "kf"); // make sure the word "barr", "gap", or "kf" was read if (Str==TempStr) { ProblemParsing("Word Missing: barr, gap, or kf", Str); } Str += ReadChar(Str, '='); } // get the Kf value Str += ReadAValue(Str, Kf, kPrintErrMsg); // read the reference positions, distances or angles switch (Restraint) { case kPosi: Str += ReadWord(Str, "ref", kPrintErrMsg); Str += ReadChar(Str, '='); Str += ReadChar(Str, '('); Str += ReadAValue(Str, Pos[0], kPrintErrMsg); Str += ReadAValue(Str, Pos[1], kPrintErrMsg); Str += ReadAValue(Str, Pos[2], kPrintErrMsg); Str += ReadChar(Str, ')'); break; case kDist: Str += ReadWord(Str, "ref", kPrintErrMsg); Str += ReadChar(Str, '='); Str += ReadAValue(Str, D, kPrintErrMsg); break; case kAngle: Str += ReadWord(Str, "ref", kPrintErrMsg); Str += ReadChar(Str, '='); Str += ReadAValue(Str, A, kPrintErrMsg); break; case kDihe: Str += ReadWord(Str, "ref", kPrintErrMsg); Str += ReadChar(Str, '='); Str += ReadAValue(Str, A, kPrintErrMsg); break; case kPosiBound: if (ReadBound(Str, Bound) == 0) {ProblemParsing("Missing Bound", Str);} Str += ReadWord(Str, "low"); Str += ReadWord(Str, "hi"); Str += ReadChar(Str, '='); Str += ReadChar(Str, '('); Str += ReadAValue(Str, Pos[0], kPrintErrMsg); Str += ReadAValue(Str, Pos[1], kPrintErrMsg); Str += ReadAValue(Str, Pos[2], kPrintErrMsg); Str += ReadAValue(Str, D, kPrintErrMsg); Str += ReadChar(Str, ')'); break; case kDistBound: if (ReadBound(Str, Bound) == 0) {ProblemParsing("Missing Bound", Str);} Str += ReadWord(Str, "low"); Str += ReadWord(Str, "hi"); Str += ReadChar(Str, '='); Str += ReadAValue(Str, D, kPrintErrMsg); break; case kAngleBound: if (ReadBound(Str, Bound) == 0) {ProblemParsing("Missing Bound", Str);} Str += ReadWord(Str, "low"); Str += ReadWord(Str, "hi"); Str += ReadChar(Str, '='); Str += ReadAValue(Str, A, kPrintErrMsg); break; case kDiheBound: Str += ReadWord(Str, "low", kPrintErrMsg); Str += ReadChar(Str, '='); Str += ReadAValue(Str, A0, kPrintErrMsg); Str += ReadWord(Str, "hi", kPrintErrMsg); Str += ReadChar(Str, '='); Str += ReadAValue(Str, A1, kPrintErrMsg); Str += ReadWord(Str, "delta", kPrintErrMsg); Str += ReadChar(Str, '='); Str += ReadAValue(Str, A2, kPrintErrMsg); break; case kPosiPMF: Str += ReadWord(Str, "low", kPrintErrMsg); Str += ReadChar(Str, '='); Str += ReadChar(Str, '('); Str += ReadAValue(Str, Pos0[0], kPrintErrMsg); Str += ReadAValue(Str, Pos0[1], kPrintErrMsg); Str += ReadAValue(Str, Pos0[2], kPrintErrMsg); Str += ReadChar(Str, ')'); Str += ReadWord(Str, "hi", kPrintErrMsg); Str += ReadChar(Str, '='); Str += ReadChar(Str, '('); Str += ReadAValue(Str, Pos1[0], kPrintErrMsg); Str += ReadAValue(Str, Pos1[1], kPrintErrMsg); Str += ReadAValue(Str, Pos1[2], kPrintErrMsg); Str += ReadChar(Str, ')'); break; case kDistPMF: Str += ReadWord(Str, "low", kPrintErrMsg); Str += ReadChar(Str, '='); Str += ReadAValue(Str, D0, kPrintErrMsg); Str += ReadWord(Str, "hi", kPrintErrMsg); Str += ReadChar(Str, '='); Str += ReadAValue(Str, D1, kPrintErrMsg); break; case kAnglePMF: Str += ReadWord(Str, "low", kPrintErrMsg); Str += ReadChar(Str, '='); Str += ReadAValue(Str, A0, kPrintErrMsg); Str += ReadWord(Str, "hi", kPrintErrMsg); Str += ReadChar(Str, '='); Str += ReadAValue(Str, A1, kPrintErrMsg); break; case kDihePMF: Str += ReadWord(Str, "low", kPrintErrMsg); Str += ReadChar(Str, '='); Str += ReadAValue(Str, A0, kPrintErrMsg); Str += ReadWord(Str, "hi", kPrintErrMsg); Str += ReadChar(Str, '='); Str += ReadAValue(Str, A1, kPrintErrMsg); break; default: ; } // convert degrees to radians A *= (kPi/180); A0 *= (kPi/180); A1 *= (kPi/180); A2 *= (kPi/180); // initialize the restraint switch (Restraint) { case kPosi: pRestraint = new AFixedPosRestraint; pRestraint->SetKf(Kf); pRestraint->SetGroups(Group1); pRestraint->SetRefPos(Pos); break; case kDist: pRestraint = new AFixedDistRestraint; pRestraint->SetKf(Kf); pRestraint->SetGroups(Group2, Group1); pRestraint->SetRefDist(D); break; case kAngle: pRestraint = new AFixedAngleRestraint; pRestraint->SetKf(Kf); pRestraint->SetGroups(Group3, Group2, Group1); pRestraint->SetRefAngle(A); break; case kDihe: pRestraint = new AFixedDiheRestraint; pRestraint->SetKf(Kf); pRestraint->SetGroups(Group4, Group3, Group2, Group1); pRestraint->SetRefAngle(A); break; case kPosiBound: pRestraint = new ABoundPosRestraint; pRestraint->SetKf(Kf); pRestraint->SetGroups(Group1); pRestraint->SetRefPos(Pos); pRestraint->SetRefDist(D); pRestraint->SetBound(Bound); break; case kDistBound: pRestraint = new ABoundDistRestraint; pRestraint->SetKf(Kf); pRestraint->SetGroups(Group2, Group1); pRestraint->SetRefDist(D); pRestraint->SetBound(Bound); break; case kAngleBound: pRestraint = new ABoundAngleRestraint; pRestraint->SetKf(Kf); pRestraint->SetGroups(Group3, Group2, Group1); pRestraint->SetRefAngle(A); pRestraint->SetBound(Bound); break; case kDiheBound: pRestraint = new ABoundDiheRestraint; pRestraint->SetKf(Kf); pRestraint->SetGroups(Group4, Group3, Group2, Group1); pRestraint->SetLowerAngle(A0); pRestraint->SetUpperAngle(A1); pRestraint->SetIntervalAngle(A2); break; case kPosiPMF: pRestraint = new AForcingPosRestraint; pRestraint->SetKf(Kf); pRestraint->SetGroups(Group1); pRestraint->SetStartPos(Pos0); pRestraint->SetStopPos(Pos1); break; case kDistPMF: pRestraint = new AForcingDistRestraint; pRestraint->SetKf(Kf); pRestraint->SetGroups(Group2, Group1); pRestraint->SetStartDist(D0); pRestraint->SetStopDist(D1); break; case kAnglePMF: pRestraint = new AForcingAngleRestraint; pRestraint->SetKf(Kf); pRestraint->SetGroups(Group3, Group2, Group1); pRestraint->SetStartAngle(A0); pRestraint->SetStopAngle(A1); break; case kDihePMF: pRestraint = new AForcingDiheRestraint; pRestraint->SetKf(Kf); pRestraint->SetGroups(Group4, Group3, Group2, Group1); pRestraint->SetStartAngle(A0); pRestraint->SetStopAngle(A1); break; default: ; } // calc number of chars to read restraint specs NumChars = Str-FullStr; return(pRestraint); }

int GetSegName (  char *  Str, char *  SegName )

Definition at line 1093 of file FreeEnergyParse.C. References ProblemParsing(), ReadAlphaNum(), and ReadWhite(). Referenced by AddAtom(), AddResidues(), GetResNum(), and GetResRange(). { //------------------------------------------------------------------- // Str should be (segname, resnum) or (segname, resnum, atomname) // put segname into SegName // return the number of characters from start-of-Str thru segname //------------------------------------------------------------------- int Count; char* FullString=Str; if (Str[0] != '(') {ProblemParsing("Missing (", Str);} Str += 1; Str += ReadWhite(Str); Count = ReadAlphaNum(Str); if (Count == 0) {ProblemParsing("Missing Segment Name", Str);} strncpy(SegName, Str, Count); SegName[Count] = '\0'; Str += Count; return(Str-FullString); }

double GetTime (  double  Val, TimeUnits_t  Units )

Definition at line 261 of file FreeEnergyParse.C. References ASSERT, k_fs, k_ns, k_ps, and kFalse. Referenced by ReadPmfBlock(). { //---------------------------------------------------------------------------- // convert (Val Units) to fs, where Units is either fs, ps, or ns //---------------------------------------------------------------------------- switch (Units) { case k_fs: return(Val); case k_ps: return(Val*1000); case k_ns: return(Val*1000000); default: ASSERT(kFalse); return(Val); } }

int IsAResidue (  char *  Str  )

Definition at line 1366 of file FreeEnergyParse.C. References IsAtomNameList(), ReadAlphaNum(), ReadDigits(), and ReadWhite(). Referenced by IsResidue(), and IsResidueRange(). { //------------------------------------------------------------------------ // see if Str starts with "(segname, resnum)" // return: the number of characters, including white space. // 0, if Str does not start with "(segname, resnum)" //------------------------------------------------------------------------ int Count; char* FullString=Str; // if char following the parentheses is ':', this isn't a residue if (IsAtomNameList(Str)) { return(0); } // Str must contain the following in sequence to be a legit residue // <ws> = optional white-space // '(', <ws>, alphanumeric, <ws>, numeric, <ws>, ')' if (Str[0] == '(') { Str += 1; Str += ReadWhite(Str); Count = ReadAlphaNum(Str); if (Count) { Str += Count; Str += ReadWhite(Str); Count = ReadDigits(Str); if (Count) { Str += Count; Str += ReadWhite(Str); if (Str[0] == ')') { Str += 1; return(Str-FullString); } } } } return(0); }

int IsAtom (  char *  Str  )

Definition at line 1273 of file FreeEnergyParse.C. References IsAtomNameList(), ReadAlphaNum(), ReadDigits(), and ReadWhite(). Referenced by ReadNextItem(). { //------------------------------------------------------------------------ // see if Str starts with "(segname, resnum, atomname)" // return: the number of characters, including white space. // 0, if Str does not start with "(segname, resnum, atomname)" //------------------------------------------------------------------------ int Count; char* FullString=Str; // if char following the parentheses is ':', this isn't an atom if (IsAtomNameList(Str)) { return(0); } // Str must contain the following in sequence to be a legit atom // <ws> = optional white-space // '(', <ws>, alphanumeric, <ws>, numeric, <ws>, alphanumeric, <ws>, ')' if (Str[0] == '(') { Str += 1; Str += ReadWhite(Str); Count = ReadAlphaNum(Str); if (Count) { Str += Count; Str += ReadWhite(Str); Count = ReadDigits(Str); if (Count) { Str += Count; Str += ReadWhite(Str); Count = ReadAlphaNum(Str); if (Count) { Str += Count; Str += ReadWhite(Str); if (Str[0] == ')') { Str += 1; return(Str-FullString); } } } } } return(0); }

int IsAtomName (  char *  Str  )

Definition at line 1227 of file FreeEnergyParse.C. References ReadAlphaNum(), and ReadWhite(). Referenced by ReadNextItem(). { //------------------------------------------------------------------- // see if Str starts with "atomname:" // return: the number of characters, including white space. // 0, if Str does not start with "atomname:" //------------------------------------------------------------------- int Count; char* FullString=Str; Count = ReadAlphaNum(Str); if (Count) { Str += Count; Str += ReadWhite(Str); if (Str[0] == ':') { Str += 1; return(Str-FullString); } } return(0); }

int IsAtomNameList (  char *  Str  )

Definition at line 1249 of file FreeEnergyParse.C. References ReadParentheses(), and ReadWhite(). Referenced by IsAResidue(), IsAtom(), and ReadNextItem(). { //------------------------------------------------------------------------ // see if Str starts with "(atomname, atomname, ...):" // return: the number of characters, including white space. // 0, if Str does not start with "(atomname, atomname, ...):" //------------------------------------------------------------------------ int Count; char* FullString=Str; // Str will be considered an atom-name-list if it contains the following: // '(', anything, ')', ':' Count = ReadParentheses(Str); if (Count > 0) { Str += Count; Str += ReadWhite(Str); if (Str[0] == ':') { Str += 1; return(Str-FullString); } } return(0); }

int IsEndGroup (  char *  Str  )

Definition at line 1214 of file FreeEnergyParse.C. Referenced by ReadNextItem(). { //------------------------------------------------------------------- // see if Str starts with "}" // return: the number of characters, including white space. // 0, if Str does not start with "}" //------------------------------------------------------------------- if (Str[0] == '}') { return(1); } return(0); }

int IsResidue (  char *  Str  )

Definition at line 1346 of file FreeEnergyParse.C. References IsAResidue(), and IsResidueRange(). Referenced by ReadNextItem(). { //------------------------------------------------------------------------ // see if Str starts with "(segname, resnum)" // but not "(segname, resnum) to (segname, resnum)" //------------------------------------------------------------------------ int Count; Count = IsAResidue(Str); if (Count) { if (IsResidueRange(Str)) { return(0); } else { return(Count); } } return(0); }

int IsResidueRange (  char *  Str  )

Definition at line 1316 of file FreeEnergyParse.C. References IsAResidue(), and ReadWhite(). Referenced by IsResidue(), and ReadNextItem(). { //------------------------------------------------------------------------ // see if Str starts with "(segname, resnum) to (segname, resnum)" // return: the number of characters, including white space. // 0, if Str does not start with "(sn, rn) to (sn, rn)" //------------------------------------------------------------------------ int Count; char* FullString=Str; // Str must contain the following in sequence to be a legit res range // <ws> = optional white-space // residue, <ws>, "to", <ws>, residue Count = IsAResidue(Str); if (Count) { Str += Count; Str += ReadWhite(Str); if (strncmp(Str, "to", 2) == 0) { Str += 2; Str += ReadWhite(Str); Count = IsAResidue(Str); if (Count) { Str += Count; return(Str-FullString); } } } return(0); }

int IsStartGroup (  char *  Str  )

Definition at line 1194 of file FreeEnergyParse.C. References ReadWhite(). Referenced by ReadNextItem(). { //------------------------------------------------------------------- // see if Str starts with "group {" // return: the number of characters, including white space. // 0, if Str does not start with "group {" //------------------------------------------------------------------- char* FullString=Str; if (strncmp(Str, "group", 5) == 0) { Str += 5; Str += ReadWhite(Str); if (Str[0] == '{') { Str += 1; return(Str-FullString); } } return(0); }

void ProblemParsing (  const char *  Message, const char *  Str, Bool_t  Terminate )

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved. Definition at line 31 of file FreeEnergyParse.C. References iout, and NAMD_die(). Referenced by AddAtom(), AddAtoms(), AddResidues(), CheckParentheses(), GetAtomName(), GetResNum(), GetResRange(), GetRestraint(), GetSegName(), ReadAValue(), ReadChar(), ReadInput(), ReadPmfBlock(), and ReadWord(). { //---------------------------------------------------------------------------- // print this message if there's a problem parsing //---------------------------------------------------------------------------- iout << "FreeEnergy: " << std::endl << endi; iout << "FreeEnergy: "; iout << "Problem parsing input parameters" << std::endl << endi; iout << "FreeEnergy: "; if (Terminate) { iout << " Error: " << Message << std::endl << endi; } else { iout << " Warning: " << Message << std::endl << endi; } iout << "FreeEnergy: "; iout << " Read Until: " << Str << std::endl << endi; iout << "FreeEnergy: " << std::endl << endi; if (Terminate) { NAMD_die("FreeEnergy: Fatal Parsing Error"); } }

int ReadAlpha (  const char *  Str  )

Definition at line 1424 of file FreeEnergyParse.C. Referenced by ReadNextPmfSpec(), ReadTaskType(), ReadTimeUnits(), and ReadWord(). { //------------------------------------------------------------------- // determine the leading number of alphabetic characters in Str. //------------------------------------------------------------------- int i=0; while (1) { if (isalpha(Str[i]) || Str[i]=='\'' || Str[i]=='\"' || Str[i] == '*') { i++; } else { break; } } return(i); }

int ReadAlphaNum (  const char *  Str  )

Definition at line 1442 of file FreeEnergyParse.C. Referenced by AddAtomsInResidues(), GetAtomName(), GetResRange(), GetSegName(), IsAResidue(), IsAtom(), IsAtomName(), and ReadNextRestraintType(). { //------------------------------------------------------------------- // determine the leading number of alphanumeric characters in Str. //------------------------------------------------------------------- int i=0; while (1) { if (isalnum(Str[i]) || Str[i]=='\'' || Str[i]=='\"' || Str[i] == '*') { i++; } else { break; } } return(i); }

int ReadAValue (  char *  Str, double &  Value, Bool_t  ErrMsg )

Definition at line 712 of file FreeEnergyParse.C. References ProblemParsing(), and ReadWhite(). Referenced by GetRestraint(), and ReadPmfBlock(). { //---------------------------------------------------------------------------- // Str should start with a floating point number. convert it to a double. // also, return the number of chars to read past the value + white-space // return NumChars = 0 if Str does not start with a valid fp number. // Print an error message if ErrMsg is kTrue, and no value is read. //---------------------------------------------------------------------------- int NumChars; char* NewStr; // read f.p. number and trailing white-space Value = strtod(Str, &NewStr); if (NewStr != Str) { NewStr += ReadWhite(NewStr); } NumChars = NewStr - Str; // if no number was read, and ErrMsg is kTrue, print a message if ((NumChars==0) && (ErrMsg)) { ProblemParsing("Floating Point Number Expected", Str); } return(NumChars); }

int ReadBound (  char *  Str, Bound_t &  Bound )

Definition at line 687 of file FreeEnergyParse.C. References ReadWord(). Referenced by GetRestraint(). { //---------------------------------------------------------------------------- // Str should start with "low" or "hi". determine which it is and // count the number of characters to read past this word + white-space. // return NumChars=0 if Str does not start with "low" or "hi" //---------------------------------------------------------------------------- int Count; Bound = kUnknownBound; Count = ReadWord(Str, "low"); if (Count) { Bound=kLower; return(Count); } Count = ReadWord(Str, "hi"); if (Count) { Bound=kUpper; return(Count); } return(Count); // Count will be 0 if "low" or "hi" wasn't found }

int ReadChar (  char *  Str, char  Char,