Skip to content

GitLab

Commit b5858a8e authored by Peter Eastman's avatar Peter Eastman
Browse files

Deleted lots of obsolete debugging code from the reference platform

parent c87cee06
Show whitespace changes
Inline Side-by-side
Showing with 2 additions and 1250 deletions
platforms/reference/src/SimTKReference/ReferenceAngleBondIxn.cpp
View file @ b5858a8e
...@@ -149,10 +149,6 @@ int ReferenceAngleBondIxn::calculateBondIxn( int* atomIndices, ...@@ -149,10 +149,6 @@ int ReferenceAngleBondIxn::calculateBondIxn( int* atomIndices,
static const int threeI = 3; static const int threeI = 3;
// debug flag
static const int debug = 0;
static const int LastAtomIndex = 3; static const int LastAtomIndex = 3;
RealOpenMM deltaR[2][ReferenceForce::LastDeltaRIndex]; RealOpenMM deltaR[2][ReferenceForce::LastDeltaRIndex];
...@@ -206,67 +202,5 @@ int ReferenceAngleBondIxn::calculateBondIxn( int* atomIndices, ...@@ -206,67 +202,5 @@ int ReferenceAngleBondIxn::calculateBondIxn( int* atomIndices,
updateEnergy( energy, energiesByBond, LastAtomIndex, atomIndices, energiesByAtom ); updateEnergy( energy, energiesByBond, LastAtomIndex, atomIndices, energiesByAtom );
// debug
if( debug ){
static bool printHeader = false;
std::stringstream message;
message << methodName;
message << std::endl;
if( !printHeader ){
printHeader = true;
message << std::endl;
message << methodName.c_str() << " a0 k [c q p s] r1 r2 angle dt rp p[] dot cosine angle dEdR*r F[]" << std::endl;
}
message << std::endl;
for( int ii = 0; ii < 3; ii++ ){
message << " Atm " << atomIndices[ii] << " [" << atomCoordinates[ii][0] << " " << atomCoordinates[ii][1] << " " << atomCoordinates[ii][2] << "] ";
}
message << std::endl << " Delta:";
for( int ii = 0; ii < 2; ii++ ){
message << " [";
for( int jj = 0; jj < ReferenceForce::LastDeltaRIndex; jj++ ){
message << deltaR[ii][jj] << " ";
}
message << "]";
}
message << std::endl;
message << " a0=" << parameters[0];
message << " k=" << parameters[1];
message << " rab2=" << deltaR[0][ReferenceForce::R2Index];
message << " rcb2=" << deltaR[1][ReferenceForce::R2Index];
message << std::endl << " ";
message << " rp=" << rp;
message << " p[";
SimTKOpenMMUtilities::formatRealStringStream( message, pVector );
message << "] dot=" << dot;
message << " cos=" << cosine;
message << std::endl << " ";
message << " dEdr=" << dEdR;
message << " trmA=" << termA;
message << " trmC=" << termC;
message << " E=" << energy << " F=compute force; f=cumulative force";
message << std::endl << " ";
for( int ii = 0; ii < 3; ii++ ){
message << " F" << (ii+1) << "[";
SimTKOpenMMUtilities::formatRealStringStream( message, deltaCrossP[ii], threeI );
message << "]";
}
message << std::endl << " ";
for( int ii = 0; ii < LastAtomIndex; ii++ ){
message << " f" << (ii+1) << "[";
SimTKOpenMMUtilities::formatRealStringStream( message, forces[atomIndices[ii]], threeI );
message << "]";
}
SimTKOpenMMLog::printMessage( message );
}
return ReferenceForce::DefaultReturn; return ReferenceForce::DefaultReturn;
} }
platforms/reference/src/SimTKReference/ReferenceBondForce.cpp
View file @ b5858a8e
...@@ -99,16 +99,6 @@ int ReferenceBondForce::calculateForce( int numberOfBonds, int** atomIndices, ...@@ -99,16 +99,6 @@ int ReferenceBondForce::calculateForce( int numberOfBonds, int** atomIndices,
for( int ii = 0; ii < numberOfBonds; ii++ ){ for( int ii = 0; ii < numberOfBonds; ii++ ){
// diagnostics
if( 0 ){
std::stringstream message;
message << methodName << " " << ii;
//message << " XAtm" << (unsigned int) atomIndices << " " << (unsigned int) atomIndices[0];
//message << " atm[" << atomIndices[ii][0] << " " << atomIndices[ii][1] << "]";
SimTKOpenMMLog::printMessage( message );
}
// calculate bond ixn // calculate bond ixn
referenceBondIxn.calculateBondIxn( atomIndices[ii], atomCoordinates, parameters[ii], referenceBondIxn.calculateBondIxn( atomIndices[ii], atomCoordinates, parameters[ii],
......
platforms/reference/src/SimTKReference/ReferenceBrownianDynamics.cpp
View file @ b5858a8e
...@@ -107,34 +107,6 @@ RealOpenMM ReferenceBrownianDynamics::getFriction( void ) const { ...@@ -107,34 +107,6 @@ RealOpenMM ReferenceBrownianDynamics::getFriction( void ) const {
return friction; return friction;
} }
/**---------------------------------------------------------------------------------------
Print parameters
@param message message
@return ReferenceDynamics::DefaultReturn
--------------------------------------------------------------------------------------- */
int ReferenceBrownianDynamics::printParameters( std::stringstream& message ) const {
// ---------------------------------------------------------------------------------------
static const char* methodName = "\nReferenceBrownianDynamics::printParameters";
// ---------------------------------------------------------------------------------------
// print parameters
ReferenceDynamics::printParameters( message );
message << " friction=" << getFriction();
message << " T=" << getTemperature();
return ReferenceDynamics::DefaultReturn;
}
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
Update -- driver routine for performing Brownian dynamics update of coordinates Update -- driver routine for performing Brownian dynamics update of coordinates
...@@ -161,8 +133,6 @@ int ReferenceBrownianDynamics::update( int numberOfAtoms, RealOpenMM** atomCoord ...@@ -161,8 +133,6 @@ int ReferenceBrownianDynamics::update( int numberOfAtoms, RealOpenMM** atomCoord
static const RealOpenMM zero = 0.0; static const RealOpenMM zero = 0.0;
static const RealOpenMM one = 1.0; static const RealOpenMM one = 1.0;
static int debug = 0;
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// get work arrays // get work arrays
...@@ -224,138 +194,3 @@ int ReferenceBrownianDynamics::update( int numberOfAtoms, RealOpenMM** atomCoord ...@@ -224,138 +194,3 @@ int ReferenceBrownianDynamics::update( int numberOfAtoms, RealOpenMM** atomCoord
return ReferenceDynamics::DefaultReturn; return ReferenceDynamics::DefaultReturn;
} }
/**---------------------------------------------------------------------------------------
Write state
@param numberOfAtoms number of atoms
@param atomCoordinates atom coordinates
@param velocities velocities
@param forces forces
@param masses atom masses
@param state 0 if initial state; otherwise nonzero
@param baseFileName base file name
@return ReferenceDynamics::DefaultReturn
--------------------------------------------------------------------------------------- */
int ReferenceBrownianDynamics::writeState( int numberOfAtoms, RealOpenMM** atomCoordinates,
RealOpenMM** velocities,
RealOpenMM** forces, RealOpenMM* masses,
int state, const std::string& baseFileName ) const {
// ---------------------------------------------------------------------------------------
static const char* methodName = "\nReferenceBrownianDynamics::writeState";
static const RealOpenMM zero = 0.0;
static const RealOpenMM one = 1.0;
static const int threeI = 3;
// ---------------------------------------------------------------------------------------
std::stringstream stateFileName;
stateFileName << baseFileName;
stateFileName << "_Step" << getTimeStep();
// stateFileName << "_State" << state;
stateFileName << ".txt";
// ---------------------------------------------------------------------------------------
// open file -- return if unsuccessful
FILE* stateFile = NULL;
#ifdef _MSC_VER
fopen_s( &stateFile, stateFileName.str().c_str(), "w" );
#else
stateFile = fopen( stateFileName.str().c_str(), "w" );
#endif
// ---------------------------------------------------------------------------------------
// diagnostics
if( stateFile != NULL ){
std::stringstream message;
message << methodName;
message << " Opened file=<" << stateFileName.str() << ">.\n";
SimTKOpenMMLog::printMessage( message );
} else {
std::stringstream message;
message << methodName;
message << " could not open file=<" << stateFileName.str() << "> -- abort output.\n";
SimTKOpenMMLog::printMessage( message );
return ReferenceDynamics::ErrorReturn;
}
// ---------------------------------------------------------------------------------------
StringVector scalarNameI;
IntVector scalarI;
StringVector scalarNameR;
RealOpenMMVector scalarR;
StringVector scalarNameR1;
RealOpenMMPtrVector scalarR1;
StringVector scalarNameR2;
RealOpenMMPtrPtrVector scalarR2;
scalarI.push_back( getNumberOfAtoms() );
scalarNameI.push_back( "Atoms" );
scalarI.push_back( getTimeStep() );
scalarNameI.push_back( "Timestep" );
if( state == 0 || state == -1 ){
scalarR.push_back( getDeltaT() );
scalarNameR.push_back( "delta_t" );
scalarR.push_back( getTemperature() );
scalarNameR.push_back( "T" );
scalarR.push_back( getFriction() );
scalarNameR.push_back( "Friction" );
scalarR1.push_back( masses );
scalarNameR1.push_back( "mass" );
scalarR2.push_back( atomCoordinates );
scalarNameR2.push_back( "coord" );
scalarR2.push_back( velocities );
scalarNameR2.push_back( "velocities" );
scalarR2.push_back( forces );
scalarNameR2.push_back( "forces" );
if( state == -1 ){
RealOpenMM** xPrime = get2DArrayAtIndex( xPrime2D );
scalarR2.push_back( xPrime );
scalarNameR2.push_back( "xPrime" );
}
} else {
scalarR2.push_back( atomCoordinates );
scalarNameR2.push_back( "coord" );
scalarR2.push_back( velocities );
scalarNameR2.push_back( "velocities" );
}
writeStateToFile( stateFile, scalarNameI, scalarI, scalarNameR, scalarR, getNumberOfAtoms(), scalarNameR1, scalarR1, threeI, scalarNameR2, scalarR2 );
(void) fclose( stateFile );
return ReferenceDynamics::DefaultReturn;
}
platforms/reference/src/SimTKReference/ReferenceBrownianDynamics.h
View file @ b5858a8e
...@@ -71,18 +71,6 @@ class ReferenceBrownianDynamics : public ReferenceDynamics { ...@@ -71,18 +71,6 @@ class ReferenceBrownianDynamics : public ReferenceDynamics {
RealOpenMM getFriction( void ) const; RealOpenMM getFriction( void ) const;
/**---------------------------------------------------------------------------------------
Print parameters
@param message message
@return ReferenceDynamics::DefaultReturn
--------------------------------------------------------------------------------------- */
int printParameters( std::stringstream& message ) const;
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
Update Update
...@@ -100,26 +88,6 @@ class ReferenceBrownianDynamics : public ReferenceDynamics { ...@@ -100,26 +88,6 @@ class ReferenceBrownianDynamics : public ReferenceDynamics {
int update( int numberOfAtoms, RealOpenMM** atomCoordinates, int update( int numberOfAtoms, RealOpenMM** atomCoordinates,
RealOpenMM** velocities, RealOpenMM** forces, RealOpenMM* masses ); RealOpenMM** velocities, RealOpenMM** forces, RealOpenMM* masses );
/**---------------------------------------------------------------------------------------
Write state
@param numberOfAtoms number of atoms
@param atomCoordinates atom coordinates
@param velocities velocities
@param forces forces
@param masses atom masses
@param state 0 if initial state; otherwise nonzero
@param baseFileName base file name
@return ReferenceDynamics::DefaultReturn
--------------------------------------------------------------------------------------- */
int writeState( int numberOfAtoms, RealOpenMM** atomCoordinates,
RealOpenMM** velocities, RealOpenMM** forces, RealOpenMM* masses,
int state, const std::string& baseFileName ) const;
}; };
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
......
platforms/reference/src/SimTKReference/ReferenceCCMAAlgorithm.cpp
View file @ b5858a8e
...@@ -363,8 +363,6 @@ int ReferenceCCMAAlgorithm::apply( int numberOfAtoms, RealOpenMM** atomCoordinat ...@@ -363,8 +363,6 @@ int ReferenceCCMAAlgorithm::apply( int numberOfAtoms, RealOpenMM** atomCoordinat
static const RealOpenMM epsilon6 = (RealOpenMM) 1.0e-06; static const RealOpenMM epsilon6 = (RealOpenMM) 1.0e-06;
static int debug = 0;
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// temp arrays // temp arrays
...@@ -465,26 +463,6 @@ int ReferenceCCMAAlgorithm::apply( int numberOfAtoms, RealOpenMM** atomCoordinat ...@@ -465,26 +463,6 @@ int ReferenceCCMAAlgorithm::apply( int numberOfAtoms, RealOpenMM** atomCoordinat
} }
} }
// diagnostics
if( debug || numberConverged < _numberOfConstraints ){
std::stringstream message;
message << methodName;
message << " iterations=" << iterations << " no. converged=" << numberConverged << " out of " << _numberOfConstraints;
if( numberConverged == _numberOfConstraints ){
message << " SUCCESS";
} else {
message << " FAILED";
}
message << "\n";
int errors = reportCCMA( numberOfAtoms, atomCoordinatesP, message );
if( !errors ){
message << "*** no errors recorded in explicit check ***";
}
message << "\n";
SimTKOpenMMLog::printMessage( message );
}
return (numberConverged == _numberOfConstraints ? ReferenceDynamics::DefaultReturn : ReferenceDynamics::ErrorReturn); return (numberConverged == _numberOfConstraints ? ReferenceDynamics::DefaultReturn : ReferenceDynamics::ErrorReturn);
} }
......
platforms/reference/src/SimTKReference/ReferenceConstraint.cpp
View file @ b5858a8e
...@@ -217,32 +217,3 @@ int ReferenceShakeConstraint::getLightAtomIndex( void ){ ...@@ -217,32 +217,3 @@ int ReferenceShakeConstraint::getLightAtomIndex( void ){
return _atomIndices[1]; return _atomIndices[1];
} }
/**---------------------------------------------------------------------------------------
Print state
@param message message
@return ReferenceDynamics::DefaultReturn
--------------------------------------------------------------------------------------- */
int ReferenceShakeConstraint::printState( std::stringstream& message ){
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nReferenceShakeConstraint::printState";
// ---------------------------------------------------------------------------------------
// print state
message << " atoms[" << _atomIndices[0] << " " << _atomIndices[1] << "]";
message << " d=" << _constraintDistance;
message << " massI[" << _inverseMasses[0] << " " << _inverseMasses[1] << "]";
return ReferenceDynamics::DefaultReturn;
}
platforms/reference/src/SimTKReference/ReferenceConstraint.h
View file @ b5858a8e
...@@ -135,19 +135,6 @@ class ReferenceShakeConstraint : public ReferenceConstraint { ...@@ -135,19 +135,6 @@ class ReferenceShakeConstraint : public ReferenceConstraint {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
int getLightAtomIndex( void ); int getLightAtomIndex( void );
/**---------------------------------------------------------------------------------------
Print state
@param message message
@return ReferenceDynamics::DefaultReturn
--------------------------------------------------------------------------------------- */
int printState( std::stringstream& message );
}; };
typedef std::vector<ReferenceShakeConstraint*> ShakeVector; typedef std::vector<ReferenceShakeConstraint*> ShakeVector;
......
platforms/reference/src/SimTKReference/ReferenceDynamics.cpp
View file @ b5858a8e
...@@ -474,8 +474,6 @@ int ReferenceDynamics::update( int numberOfAtoms, RealOpenMM** atomCoordinates, ...@@ -474,8 +474,6 @@ int ReferenceDynamics::update( int numberOfAtoms, RealOpenMM** atomCoordinates,
static const RealOpenMM zero = 0.0; static const RealOpenMM zero = 0.0;
static const RealOpenMM one = 1.0; static const RealOpenMM one = 1.0;
static int debug = 0;
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
return ReferenceDynamics::DefaultReturn; return ReferenceDynamics::DefaultReturn;
...@@ -500,8 +498,6 @@ int ReferenceDynamics::removeTotalLinearMomentum( int numberOfAtoms, RealOpenMM* ...@@ -500,8 +498,6 @@ int ReferenceDynamics::removeTotalLinearMomentum( int numberOfAtoms, RealOpenMM*
static const char* methodName = "\nReferenceDynamics::removeTotalLinearMomentum"; static const char* methodName = "\nReferenceDynamics::removeTotalLinearMomentum";
static const int debug = 1;
static const RealOpenMM zero = 0.0; static const RealOpenMM zero = 0.0;
static const RealOpenMM one = 1.0; static const RealOpenMM one = 1.0;
...@@ -514,340 +510,20 @@ int ReferenceDynamics::removeTotalLinearMomentum( int numberOfAtoms, RealOpenMM* ...@@ -514,340 +510,20 @@ int ReferenceDynamics::removeTotalLinearMomentum( int numberOfAtoms, RealOpenMM*
linearMomentum[0] += masses[ii]*velocities[ii][0]; linearMomentum[0] += masses[ii]*velocities[ii][0];
linearMomentum[1] += masses[ii]*velocities[ii][1]; linearMomentum[1] += masses[ii]*velocities[ii][1];
linearMomentum[2] += masses[ii]*velocities[ii][2]; linearMomentum[2] += masses[ii]*velocities[ii][2];
/*
if( debug ){
std::stringstream message;
message << ii << " TotalM=" << totalMass << " m=" << masses[ii] << " linearMomentum [";
SimTKOpenMMUtilities::formatRealStringStream( message, linearMomentum, 3, one );
message << "] [";
SimTKOpenMMUtilities::formatRealStringStream( message, velocities[ii], 3, one );
message << "]\n";
SimTKOpenMMLog::printMessage( message );
}
*/
} }
if( totalMass > zero ){ if( totalMass > zero ){
RealOpenMM totalMassI = one/totalMass; RealOpenMM totalMassI = one/totalMass;
/*
if( debug ){
std::stringstream message;
message << " Pre scale linearMomentum [";
SimTKOpenMMUtilities::formatRealStringStream( message, linearMomentum, 3, one );
message << "]\n";
SimTKOpenMMLog::printMessage( message );
}
*/
linearMomentum[0] *= totalMassI; linearMomentum[0] *= totalMassI;
linearMomentum[1] *= totalMassI; linearMomentum[1] *= totalMassI;
linearMomentum[2] *= totalMassI; linearMomentum[2] *= totalMassI;
/*
if( debug ){
std::stringstream message;
message << " Pre sub linearMomentum [";
SimTKOpenMMUtilities::formatRealStringStream( message, linearMomentum, 3, one );
message << "]\n";
SimTKOpenMMLog::printMessage( message );
}
*/
for( int ii = 0; ii < numberOfAtoms; ii++ ){ for( int ii = 0; ii < numberOfAtoms; ii++ ){
velocities[ii][0] -= linearMomentum[0]; velocities[ii][0] -= linearMomentum[0];
velocities[ii][1] -= linearMomentum[1]; velocities[ii][1] -= linearMomentum[1];
velocities[ii][2] -= linearMomentum[2]; velocities[ii][2] -= linearMomentum[2];
} }
// debug
if( debug ){
RealOpenMM tempV[3];
std::stringstream message;
int maxPrint = 5;
message << methodName;
message << " TotalM=" << totalMass << " linearMomentum: [";
SimTKOpenMMUtilities::formatRealStringStream( message, linearMomentum, 3, one );
message << "]\nSample v:\n";
for( int ii = 0; ii < maxPrint; ii++ ){
tempV[0] = velocities[ii][0] + linearMomentum[0];
tempV[1] = velocities[ii][1] + linearMomentum[1];
tempV[2] = velocities[ii][2] + linearMomentum[2];
message << "OldV[ ";
SimTKOpenMMUtilities::formatRealStringStream( message, tempV, 3, one );
message << "] NewV[ ";
SimTKOpenMMUtilities::formatRealStringStream( message, velocities[ii], 3, one );
message << "]" << std::endl;
}
SimTKOpenMMLog::printMessage( message );
}
}
return ReferenceDynamics::DefaultReturn;
}
/**---------------------------------------------------------------------------------------
Print parameters
@param message message
@return ReferenceDynamics::DefaultReturn
--------------------------------------------------------------------------------------- */
int ReferenceDynamics::printParameters( std::stringstream& message ) const {
// ---------------------------------------------------------------------------------------
static const char* methodName = "\nReferenceDynamics::printParameters";
// ---------------------------------------------------------------------------------------
message << "atoms=" << getNumberOfAtoms() << " ";
message << "delta_t=" << getDeltaT() << " ";
message << "temperature=" << getTemperature() << " ";
message << "step=" << getTimeStep() << " ";
message << "seed=" << SimTKOpenMMUtilities::getRandomNumberSeed() << " ";
message << std::endl;
return ReferenceDynamics::DefaultReturn;
}
/**---------------------------------------------------------------------------------------
Write state
@param numberOfAtoms number of atoms
@param atomCoordinates atom coordinates
@param velocities velocities
@param forces forces
@param masses atom masses
@param state 0 if initial state; otherwise nonzero
@param baseFileName base file name
@return ReferenceDynamics::DefaultReturn
--------------------------------------------------------------------------------------- */
int ReferenceDynamics::writeState( int numberOfAtoms, RealOpenMM** atomCoordinates,
RealOpenMM** velocities,
RealOpenMM** forces, RealOpenMM* masses,
int state, const std::string& baseFileName ) const {
// ---------------------------------------------------------------------------------------
static const char* methodName = "\nReferenceStochasticDynamics::writeState";
static const RealOpenMM zero = 0.0;
static const RealOpenMM one = 1.0;
static const int threeI = 3;
// ---------------------------------------------------------------------------------------
std::stringstream stateFileName;
stateFileName << baseFileName;
stateFileName << "_Step" << getTimeStep();
// stateFileName << "_State" << state;
stateFileName << ".txt";
// ---------------------------------------------------------------------------------------
// open file -- return if unsuccessful
FILE* stateFile = NULL;
#ifdef _MSC_VER
fopen_s( &stateFile, stateFileName.str().c_str(), "w" );
#else
stateFile = fopen( stateFileName.str().c_str(), "w" );
#endif
// ---------------------------------------------------------------------------------------
// diagnostics
if( stateFile != NULL ){
std::stringstream message;
message << methodName;
message << " Opened file=<" << stateFileName.str() << ">.\n";
SimTKOpenMMLog::printMessage( message );
} else {
std::stringstream message;
message << methodName;
message << " could not open file=<" << stateFileName.str() << "> -- abort output.\n";
SimTKOpenMMLog::printMessage( message );
return ReferenceDynamics::ErrorReturn;
}
// ---------------------------------------------------------------------------------------
StringVector scalarNameI;
IntVector scalarI;
StringVector scalarNameR;
RealOpenMMVector scalarR;
StringVector scalarNameR1;
RealOpenMMPtrVector scalarR1;
StringVector scalarNameR2;
RealOpenMMPtrPtrVector scalarR2;
scalarI.push_back( getNumberOfAtoms() );
scalarNameI.push_back( "Atoms" );
scalarI.push_back( getTimeStep() );
scalarNameI.push_back( "Timestep" );
scalarR.push_back( getDeltaT() );
scalarNameR.push_back( "delta_t" );
scalarR.push_back( static_cast<RealOpenMM>(SimTKOpenMMUtilities::getRandomNumberSeed()) );
scalarNameR.push_back( "seed" );
scalarR.push_back( getTemperature() );
scalarNameR.push_back( "T" );
if( masses ){
scalarR1.push_back( masses );
scalarNameR1.push_back( "mass" );
}
if( atomCoordinates ){
scalarR2.push_back( atomCoordinates );
scalarNameR2.push_back( "coord" );
}
if( velocities ){
scalarR2.push_back( velocities );
scalarNameR2.push_back( "velocities" );
}
if( forces ){
scalarR2.push_back( forces );
scalarNameR2.push_back( "forces" );
}
writeStateToFile( stateFile, scalarNameI, scalarI, scalarNameR, scalarR, getNumberOfAtoms(), scalarNameR1, scalarR1, threeI, scalarNameR2, scalarR2 );
(void) fclose( stateFile );
return ReferenceDynamics::DefaultReturn;
}
/**---------------------------------------------------------------------------------------
Write state
@param stateFile file to write to
@param scalarNameI vector of scalar names for ints
@param scalarI vector of scalar ints
@param scalarNameR vector of scalar names for real
@param scalarR vector of scalar reals
@param dimension1 size of first dimension for 1D & 2D real arrays
@param scalarNameR1 vector of names for 1D real arrays
@param scalarR1 vector of 1D real arrays
@param dimension2 size of second dimension for 2D real arrays
@param scalarNameR2 vector of names for 2D real arrays
@param scalarR2 vector of 2D real arrays
@return ReferenceDynamics::DefaultReturn
--------------------------------------------------------------------------------------- */
int ReferenceDynamics::writeStateToFile( FILE* stateFile,
StringVector& scalarNameI, IntVector& scalarI,
StringVector& scalarNameR, RealOpenMMVector& scalarR,
int dimension1, StringVector& scalarNameR1,
RealOpenMMPtrVector& scalarR1,
int dimension2, StringVector& scalarNameR2,
RealOpenMMPtrPtrVector& scalarR2 ) const {
// ---------------------------------------------------------------------------------------
static const char* methodName = "\nReferenceDynamics::writeState";
// ---------------------------------------------------------------------------------------
// validate vector sizes
std::stringstream message;
message << methodName << std::endl;
int errors = 0;
if( scalarNameI.size() != scalarI.size() ){
message << " int name size=" << scalarNameI.size() << " != " << " int vector size=" << scalarI.size() << std::endl;
errors++;
}
if( scalarNameR.size() != scalarR.size() ){
message << " real name size=" << scalarNameR.size() << " != " << " real vector size=" << scalarR.size() << std::endl;
errors++;
}
if( scalarNameR1.size() != scalarR1.size() ){
message << " real* name size=" << scalarNameR1.size() << " != " << " real* vector size=" << scalarR1.size() << std::endl;
errors++;
}
if( scalarNameR2.size() != scalarR2.size() ){
message << " real** name size=" << scalarNameR2.size() << " != " << " real** vector size=" << scalarR2.size() << std::endl;
errors++;
}
if( errors ){
SimTKOpenMMLog::printError( message );
return ReferenceDynamics::ErrorReturn;
}
// ---------------------------------------------------------------------------------------
// array header
(void) fprintf( stateFile, "# " );
for( unsigned int ii = 0; ii < scalarNameR1.size(); ii++ ){
(void) fprintf( stateFile, " %s", scalarNameR1[ii].c_str() );
}
for( unsigned int ii = 0; ii < scalarNameR2.size(); ii++ ){
(void) fprintf( stateFile, " %s", scalarNameR2[ii].c_str() );
}
(void) fprintf( stateFile, "\n" );
// int scalars
for( unsigned int ii = 0; ii < scalarI.size(); ii++ ){
(void) fprintf( stateFile, "%6d # %s\n", scalarI[ii], scalarNameI[ii].c_str() );
}
// real scalars
for( unsigned int ii = 0; ii < scalarR.size(); ii++ ){
(void) fprintf( stateFile, "%14.6e # %s\n", scalarR[ii], scalarNameR[ii].c_str() );
}
// arrays
int maxPerLine = 3;
for( unsigned int ii = 0; ii < (unsigned int) dimension1; ii++ ){
(void) fprintf( stateFile, "%5d ", ii );
for( RealOpenMMPtrVectorI jj = scalarR1.begin(); jj != scalarR1.end(); jj++ ){
(void) fprintf( stateFile, "%14.6e ", (*jj)[ii] );
}
int r2Count = 0;
for( RealOpenMMPtrPtrVectorI jj = scalarR2.begin(); jj != scalarR2.end(); jj++ ){
RealOpenMM** array = *jj;
for( int kk = 0; kk < dimension2; kk++ ){
(void) fprintf( stateFile, "%14.6e ", array[ii][kk] );
}
(void) fprintf( stateFile, " " );
r2Count++;
if( r2Count == maxPerLine && ( (r2Count % (int) (scalarR2.size()-1)) > 2) ){
(void) fprintf( stateFile, "\n " );
r2Count = 0;
}
}
(void) fprintf( stateFile, "\n" );
} }
return ReferenceDynamics::DefaultReturn; return ReferenceDynamics::DefaultReturn;
......
platforms/reference/src/SimTKReference/ReferenceDynamics.h
View file @ b5858a8e
...@@ -238,18 +238,6 @@ class OPENMM_EXPORT ReferenceDynamics { ...@@ -238,18 +238,6 @@ class OPENMM_EXPORT ReferenceDynamics {
int removeTotalLinearMomentum( int numberOfAtoms, RealOpenMM* masses, RealOpenMM** velocities ) const; int removeTotalLinearMomentum( int numberOfAtoms, RealOpenMM* masses, RealOpenMM** velocities ) const;
/**---------------------------------------------------------------------------------------
Print parameters
@param message message
@return ReferenceDynamics::DefaultReturn
--------------------------------------------------------------------------------------- */
int printParameters( std::stringstream& message ) const;
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
Update Update
...@@ -288,52 +276,6 @@ class OPENMM_EXPORT ReferenceDynamics { ...@@ -288,52 +276,6 @@ class OPENMM_EXPORT ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
int setReferenceConstraintAlgorithm( ReferenceConstraintAlgorithm* referenceConstraint ); int setReferenceConstraintAlgorithm( ReferenceConstraintAlgorithm* referenceConstraint );
/**---------------------------------------------------------------------------------------
Write state
@param numberOfAtoms number of atoms
@param atomCoordinates atom coordinates
@param velocities velocities
@param forces forces
@param masses atom masses
@param state 0 if initial state; otherwise nonzero
@param baseFileName base file name
@return ReferenceDynamics::DefaultReturn
--------------------------------------------------------------------------------------- */
int writeState( int numberOfAtoms, RealOpenMM** atomCoordinates,
RealOpenMM** velocities, RealOpenMM** forces, RealOpenMM* masses,
int state, const std::string& baseFileName ) const;
/**---------------------------------------------------------------------------------------
Write state
@param stateFile file to write to
@param scalarNameI vector of scalar names for ints
@param scalarI vector of scalar ints
@param scalarNameR vector of scalar names for real
@param scalarR vector of scalar reals
@param dimension1 size of first dimension for 1D & 2D real arrays
@param scalarNameR1 vector of names for 1D real arrays
@param scalarR1 vector of 1D real arrays
@param dimension2 size of second dimension for 2D real arrays
@param scalarNameR2 vector of names for 2D real arrays
@param scalarR2 vector of 2D real arrays
@return ReferenceDynamics::DefaultReturn
--------------------------------------------------------------------------------------- */
int writeStateToFile( FILE* stateFile, StringVector& scalarNameI, IntVector& scalarI,
StringVector& scalarNameR, RealOpenMMVector& scalarR,
int dimension1, StringVector& scalarNameR1, RealOpenMMPtrVector& scalarR1,
int dimension2, StringVector& scalarNameR2, RealOpenMMPtrPtrVector& scalarR2 ) const;
}; };
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
......
platforms/reference/src/SimTKReference/ReferenceForce.cpp
View file @ b5858a8e
...@@ -171,109 +171,3 @@ int ReferenceForce::getDeltaROnly( const RealOpenMM* atomCoordinatesI, ...@@ -171,109 +171,3 @@ int ReferenceForce::getDeltaROnly( const RealOpenMM* atomCoordinatesI,
return ReferenceForce::DefaultReturn; return ReferenceForce::DefaultReturn;
} }
/**---------------------------------------------------------------------------------------
Write coordinates, energies and forces (Simbios)
@param numberOfAtoms number of atoms
@param atomsPerBond atoms/bond
@param atomCoordinates atomic coordinates
@param forces forces
@param energies energies (optional)
@param resultsFileName output file name
@param lengthConversion length conversion (optional defaults to 1)
@param energyConversion energy conversion (optional defaults to 1)
@param forceConversion force conversion (optional defaults to 1)
@return ReferenceForce::DefaultReturn unless
file cannot be opened
in which case return ReferenceForce::ErrorReturn
--------------------------------------------------------------------------------------- */
int ReferenceForce::writeForces( int numberOfAtoms, int atomsPerBond,
RealOpenMM** atomCoordinates, RealOpenMM** forces,
RealOpenMM* energies, const std::string& resultsFileName,
RealOpenMM lengthConversion = 1.0,
RealOpenMM forceConversion = 1.0,
RealOpenMM energyConversion = 1.0 ){
// ---------------------------------------------------------------------------------------
static const char* methodName = "\nReferenceForce::writeBornEnergyForces";
static const RealOpenMM zero = 0.0;
// ---------------------------------------------------------------------------------------
// open file -- return if unsuccessful
FILE* resultsFile = NULL;
#ifdef _MSC_VER
fopen_s( &resultsFile, resultsFileName.c_str(), "w" );
#else
resultsFile = fopen( resultsFileName.c_str(), "w" );
#endif
// ---------------------------------------------------------------------------------------
// diagnostics
std::stringstream message;
message << methodName;
if( resultsFile != NULL ){
std::stringstream message;
message << methodName;
message << " Opened file=<" << resultsFileName << ">.";
SimTKOpenMMLog::printMessage( message );
} else {
std::stringstream message;
message << methodName;
message << " could not open file=<" << resultsFileName << "> -- abort output.";
SimTKOpenMMLog::printMessage( message );
return ReferenceForce::ErrorReturn;
}
// total energy and normalize by number of atoms/bond
RealOpenMM totalEnergy = zero;
if( energies ){
for( int ii = 1; ii < numberOfAtoms; ii++ ){
totalEnergy += energies[ii];
}
if( atomsPerBond > 0 ){
totalEnergy /= (RealOpenMM) atomsPerBond;
}
}
// header
(void) fprintf( resultsFile, "# %d atoms E=%.7e format: coords(3) forces(3) energies\n",
numberOfAtoms, totalEnergy );
// output
if( forces != NULL && atomCoordinates != NULL ){
for( int ii = 0; ii < numberOfAtoms; ii++ ){
(void) fprintf( resultsFile, "%5d %15.7e %15.7e %15.7e %15.7e %15.7e %15.7e", ii,
lengthConversion*atomCoordinates[ii][0],
lengthConversion*atomCoordinates[ii][1],
lengthConversion*atomCoordinates[ii][2],
forceConversion*forces[ii][0],
forceConversion*forces[ii][1],
forceConversion*forces[ii][2]
);
if( energies != NULL ){
(void) fprintf( resultsFile, " %15.7e", energyConversion*energies[ii] );
}
(void) fprintf( resultsFile, "\n" );
}
}
(void) fclose( resultsFile );
return ReferenceForce::DefaultReturn;
}
platforms/reference/src/SimTKReference/ReferenceForce.h
View file @ b5858a8e
...@@ -118,33 +118,6 @@ class OPENMM_EXPORT ReferenceForce { ...@@ -118,33 +118,6 @@ class OPENMM_EXPORT ReferenceForce {
static int getDeltaROnly( const RealOpenMM* atomCoordinatesI, const RealOpenMM* atomCoordinatesJ, static int getDeltaROnly( const RealOpenMM* atomCoordinatesI, const RealOpenMM* atomCoordinatesJ,
RealOpenMM* deltaR ); RealOpenMM* deltaR );
/**---------------------------------------------------------------------------------------
Write coordinates, energies and forces (Simbios)
@param numberOfAtoms number of atoms
@param atomsPerBond atoms/bond (used to normalize total energy)
@param atomCoordinates atomic coordinates
@param forces forces
@param energies energies (optional)
@param resultsFileName output file name
@param lengthConversion length conversion (optional defaults to 1)
@param forceConversion force conversion (optional defaults to 1)
@param energyConversion energy conversion (optional defaults to 1)
@return ReferenceForce::DefaultReturn unless
file cannot be opened
in which case return ReferenceForce::ErrorReturn
--------------------------------------------------------------------------------------- */
static int writeForces( int numberOfAtoms, int atomsPerBond, RealOpenMM** atomCoordinates,
RealOpenMM** forces, RealOpenMM* energies,
const std::string& resultsFileName,
RealOpenMM lengthConversion, RealOpenMM forceConversion,
RealOpenMM energyConversion );
}; };
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
......
platforms/reference/src/SimTKReference/ReferenceLJCoulomb14.cpp
View file @ b5858a8e
...@@ -110,10 +110,6 @@ int ReferenceLJCoulomb14::calculateBondIxn( int* atomIndices, RealOpenMM** atomC ...@@ -110,10 +110,6 @@ int ReferenceLJCoulomb14::calculateBondIxn( int* atomIndices, RealOpenMM** atomC
static const int numberOfParameters = 3; static const int numberOfParameters = 3;
// debug flag
static const int debug = 0;
static const int LastAtomIndex = 2; static const int LastAtomIndex = 2;
RealOpenMM deltaR[2][ReferenceForce::LastDeltaRIndex]; RealOpenMM deltaR[2][ReferenceForce::LastDeltaRIndex];
...@@ -151,58 +147,5 @@ int ReferenceLJCoulomb14::calculateBondIxn( int* atomIndices, RealOpenMM** atomC ...@@ -151,58 +147,5 @@ int ReferenceLJCoulomb14::calculateBondIxn( int* atomIndices, RealOpenMM** atomC
updateEnergy( energy, energiesByBond, LastAtomIndex, atomIndices, energiesByAtom ); updateEnergy( energy, energiesByBond, LastAtomIndex, atomIndices, energiesByAtom );
// debug
if( debug ){
static bool printHeader = false;
std::stringstream message;
message << methodName;
message << std::endl;
if( !printHeader ){
printHeader = true;
message << std::endl;
message << methodName.c_str() << " a0 k [c q p s] r1 r2 angle dt rp p[] dot cosine angle dEdR*r F[]" << std::endl;
}
message << std::endl;
for( int ii = 0; ii < LastAtomIndex; ii++ ){
message << " Atm " << atomIndices[ii] << " [" << atomCoordinates[atomIndices[ii]][0] << " " << atomCoordinates[atomIndices[ii]][1] << "] ";
}
message << std::endl << " Delta:";
for( int ii = 0; ii < (LastAtomIndex - 1); ii++ ){
message << " [";
for( int jj = 0; jj < ReferenceForce::LastDeltaRIndex; jj++ ){
message << deltaR[ii][jj] << " ";
}
message << "]";
}
message << std::endl;
message << " p1=" << parameters[0];
message << " p2=" << parameters[1];
message << " p3=" << parameters[2];
message << std::endl << " ";
message << " dEdR=" << dEdR;
message << " E=" << energy << " force factors: ";
message << "F=compute force; f=cumulative force";
message << std::endl << " ";
for( int ii = 0; ii < LastAtomIndex; ii++ ){
message << " F" << (ii+1) << "[";
SimTKOpenMMUtilities::formatRealStringStream( message, deltaR[0], threeI, dEdR );
message << "]";
}
message << std::endl << " ";
for( int ii = 0; ii < LastAtomIndex; ii++ ){
message << " f" << (ii+1) << "[";
SimTKOpenMMUtilities::formatRealStringStream( message, forces[atomIndices[ii]], threeI );
message << "]";
}
SimTKOpenMMLog::printMessage( message );
}
return ReferenceForce::DefaultReturn; return ReferenceForce::DefaultReturn;
} }
platforms/reference/src/SimTKReference/ReferenceLJCoulombIxn.cpp
View file @ b5858a8e
...@@ -555,10 +555,6 @@ int ReferenceLJCoulombIxn::calculateOneIxn( int ii, int jj, RealOpenMM** atomCoo ...@@ -555,10 +555,6 @@ int ReferenceLJCoulombIxn::calculateOneIxn( int ii, int jj, RealOpenMM** atomCoo
static const int threeI = 3; static const int threeI = 3;
// debug flag
static const int debug = -1;
static const int LastAtomIndex = 2; static const int LastAtomIndex = 2;
RealOpenMM deltaR[2][ReferenceForce::LastDeltaRIndex]; RealOpenMM deltaR[2][ReferenceForce::LastDeltaRIndex];
...@@ -611,58 +607,6 @@ int ReferenceLJCoulombIxn::calculateOneIxn( int ii, int jj, RealOpenMM** atomCoo ...@@ -611,58 +607,6 @@ int ReferenceLJCoulombIxn::calculateOneIxn( int ii, int jj, RealOpenMM** atomCoo
} }
} }
// debug
if( debug == ii ){
static bool printHeader = false;
std::stringstream message;
message << methodName;
message << std::endl;
int pairArray[2] = { ii, jj };
if( !printHeader ){
printHeader = true;
message << std::endl;
message << methodName.c_str() << " a0 k [c q p s] r1 r2 angle dt rp p[] dot cosine angle dEdR*r F[]" << std::endl;
}
message << std::endl;
for( int kk = 0; kk < 2; kk++ ){
message << " Atm " << pairArray[kk] << " [" << atomCoordinates[pairArray[kk]][0] << " " << atomCoordinates[pairArray[kk]][1] << " " << atomCoordinates[pairArray[kk]][2] << "] ";
}
message << std::endl << " Delta:";
for( int kk = 0; kk < (LastAtomIndex - 1); kk++ ){
message << " [";
for( int jj = 0; jj < ReferenceForce::LastDeltaRIndex; jj++ ){
message << deltaR[kk][jj] << " ";
}
message << "]";
}
message << std::endl;
for( int kk = 0; kk < 2; kk++ ){
message << " p" << pairArray[kk] << " [";
message << atomParameters[pairArray[kk]][0] << " " << atomParameters[pairArray[kk]][1] << " " << atomParameters[pairArray[kk]][2];
message << "]";
}
message << std::endl;
message << " dEdR=" << dEdR;
message << " E=" << energy << " force factors: ";
message << "F=compute force; f=cumulative force";
message << std::endl << " ";
message << " f" << ii << "[";
SimTKOpenMMUtilities::formatRealStringStream( message, deltaR[0], threeI, dEdR );
message << "]";
for( int kk = 0; kk < 2; kk++ ){
message << " F" << pairArray[kk] << " [";
SimTKOpenMMUtilities::formatRealStringStream( message, forces[pairArray[kk]], threeI );
message << "]";
}
SimTKOpenMMLog::printMessage( message );
}
return ReferenceForce::DefaultReturn; return ReferenceForce::DefaultReturn;
} }
platforms/reference/src/SimTKReference/ReferenceProperDihedralBond.cpp
View file @ b5858a8e
...@@ -105,10 +105,6 @@ int ReferenceProperDihedralBond::calculateBondIxn( int* atomIndices, ...@@ -105,10 +105,6 @@ int ReferenceProperDihedralBond::calculateBondIxn( int* atomIndices,
static const int threeI = 3; static const int threeI = 3;
// debug flag
static const int debug = 0;
static const int LastAtomIndex = 4; static const int LastAtomIndex = 4;
RealOpenMM deltaR[3][ReferenceForce::LastDeltaRIndex]; RealOpenMM deltaR[3][ReferenceForce::LastDeltaRIndex];
...@@ -191,82 +187,5 @@ int ReferenceProperDihedralBond::calculateBondIxn( int* atomIndices, ...@@ -191,82 +187,5 @@ int ReferenceProperDihedralBond::calculateBondIxn( int* atomIndices,
updateEnergy( energy, energiesByBond, LastAtomIndex, atomIndices, energiesByAtom ); updateEnergy( energy, energiesByBond, LastAtomIndex, atomIndices, energiesByAtom );
// debug
if( debug ){
static bool printHeader = false;
std::stringstream message;
message << methodName;
message << std::endl;
if( !printHeader ){
printHeader = true;
message << std::endl;
message << methodName.c_str() << " a0 k [c q p s] r1 r2 angle dt rp p[] dot cosine angle dEdR*r F[]" << std::endl;
}
message << std::endl;
for( int ii = 0; ii < 4; ii++ ){
message << " Atm " << atomIndices[ii] << " [" << atomCoordinates[atomIndices[ii]][0] << " " << atomCoordinates[atomIndices[ii]][1] << " " << atomCoordinates[atomIndices[ii]][2] << "] ";
}
message << std::endl << " Delta:";
for( int ii = 0; ii < (LastAtomIndex - 1); ii++ ){
message << " [";
for( int jj = 0; jj < ReferenceForce::LastDeltaRIndex; jj++ ){
message << deltaR[ii][jj] << " ";
}
message << "]";
}
message << std::endl;
message << std::endl << " Cross:";
for( int ii = 0; ii < 2; ii++ ){
message << " [";
for( int jj = 0; jj < 3; jj++ ){
message << crossProduct[ii][jj] << " ";
}
message << "]";
}
message << std::endl;
message << " k=" << parameters[0];
message << " a=" << parameters[1];
message << " m=" << parameters[2];
message << " ang=" << dihedralAngle;
message << " dotD=" << dotDihedral;
message << " sign=" << signOfAngle;
message << std::endl << " ";
message << " deltaAngle=" << deltaAngle;
message << " dEdAngle=" << dEdAngle;
message << " E=" << energy << " force factors: [";
for( int ii = 0; ii < 4; ii++ ){
message << forceFactors[ii] << " ";
}
message << "] F=compute force; f=cumulative force";
message << std::endl << " ";
for( int ii = 0; ii < LastAtomIndex; ii++ ){
message << " F" << (ii+1) << "[";
SimTKOpenMMUtilities::formatRealStringStream( message, internalF[ii], threeI );
message << "]";
}
message << std::endl << " ";
for( int ii = 0; ii < LastAtomIndex; ii++ ){
message << " f" << (ii+1) << "[";
SimTKOpenMMUtilities::formatRealStringStream( message, forces[atomIndices[ii]], threeI );
message << "]";
}
SimTKOpenMMLog::printMessage( message );
}
if( debug ){
std::stringstream message;
message << methodName << " DONE";
message << std::endl;
SimTKOpenMMLog::printMessage( message );
}
return ReferenceForce::DefaultReturn; return ReferenceForce::DefaultReturn;
} }
platforms/reference/src/SimTKReference/ReferenceRbDihedralBond.cpp
View file @ b5858a8e
...@@ -107,10 +107,6 @@ int ReferenceRbDihedralBond::calculateBondIxn( int* atomIndices, ...@@ -107,10 +107,6 @@ int ReferenceRbDihedralBond::calculateBondIxn( int* atomIndices,
static const int numberOfParameters = 6; static const int numberOfParameters = 6;
// debug flag
static int debug = 0;
static const int LastAtomIndex = 4; static const int LastAtomIndex = 4;
RealOpenMM deltaR[3][ReferenceForce::LastDeltaRIndex]; RealOpenMM deltaR[3][ReferenceForce::LastDeltaRIndex];
...@@ -206,85 +202,5 @@ int ReferenceRbDihedralBond::calculateBondIxn( int* atomIndices, ...@@ -206,85 +202,5 @@ int ReferenceRbDihedralBond::calculateBondIxn( int* atomIndices,
updateEnergy( energy, energiesByBond, LastAtomIndex, atomIndices, energiesByAtom ); updateEnergy( energy, energiesByBond, LastAtomIndex, atomIndices, energiesByAtom );
// debug
if( debug ){
static bool printHeader = false;
std::stringstream message;
message << methodName;
message << std::endl;
if( !printHeader ){
printHeader = true;
message << std::endl;
message << methodName.c_str() << " a0 k [c q p s] r1 r2 angle dt rp p[] dot cosine angle dEdR*r F[]" << std::endl;
}
message << std::endl;
for( int ii = 0; ii < 4; ii++ ){
message << " Atm " << atomIndices[ii] << " [" << atomCoordinates[atomIndices[ii]][0] << " ";
message << atomCoordinates[atomIndices[ii]][1] << " " << atomCoordinates[atomIndices[ii]][2] << "] ";
}
message << std::endl << " Delta:";
for( int ii = 0; ii < (LastAtomIndex - 1); ii++ ){
message << " [";
for( int jj = 0; jj < ReferenceForce::LastDeltaRIndex; jj++ ){
message << deltaR[ii][jj] << " ";
}
message << "]";
}
message << std::endl;
message << std::endl << " Cross:";
for( int ii = 0; ii < 2; ii++ ){
message << " [";
for( int jj = 0; jj < 3; jj++ ){
message << crossProduct[ii][jj] << " ";
}
message << "]";
}
message << std::endl;
message << std::endl << numberOfParameters << " Parameters: [";
for( int ii = 0; ii < numberOfParameters; ii++ ){
message << parameters[ii] << " ";
}
message << " ]" << std::endl;
message << " ang=" << dihederalAngle;
message << " dotD=" << cosPhi;
message << " sign=" << signOfAngle;
message << std::endl << " ";
message << " dEdAngle=" << dEdAngle;
message << " E=" << energy << " force factors: [";
for( int ii = 0; ii < 4; ii++ ){
message << forceFactors[ii] << " ";
}
message << "] F=compute force; f=cumulative force";
message << std::endl << " ";
for( int ii = 0; ii < LastAtomIndex; ii++ ){
message << " F" << (ii+1) << "[";
SimTKOpenMMUtilities::formatRealStringStream( message, internalF[ii], threeI );
message << "]";
}
message << std::endl << " ";
for( int ii = 0; ii < LastAtomIndex; ii++ ){
message << " f" << (ii+1) << "[";
SimTKOpenMMUtilities::formatRealStringStream( message, forces[atomIndices[ii]], threeI );
message << "]";
}
SimTKOpenMMLog::printMessage( message );
}
if( debug ){
std::stringstream message;
message << methodName << " DONE";
message << std::endl;
SimTKOpenMMLog::printMessage( message );
}
return ReferenceForce::DefaultReturn; return ReferenceForce::DefaultReturn;
} }
platforms/reference/src/SimTKReference/ReferenceShakeAlgorithm.cpp
View file @ b5858a8e
...@@ -235,8 +235,6 @@ int ReferenceShakeAlgorithm::apply( int numberOfAtoms, RealOpenMM** atomCoordina ...@@ -235,8 +235,6 @@ int ReferenceShakeAlgorithm::apply( int numberOfAtoms, RealOpenMM** atomCoordina
static const RealOpenMM epsilon6 = (RealOpenMM) 1.0e-06; static const RealOpenMM epsilon6 = (RealOpenMM) 1.0e-06;
static int debug = 0;
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
int numberOfConstraints = getNumberOfConstraints(); int numberOfConstraints = getNumberOfConstraints();
...@@ -313,22 +311,6 @@ int ReferenceShakeAlgorithm::apply( int numberOfAtoms, RealOpenMM** atomCoordina ...@@ -313,22 +311,6 @@ int ReferenceShakeAlgorithm::apply( int numberOfAtoms, RealOpenMM** atomCoordina
atomCoordinatesP[atomJ][jj] -= inverseMasses[atomJ]*dr; atomCoordinatesP[atomJ][jj] -= inverseMasses[atomJ]*dr;
} }
} }
/*
if( ii < -3 ){
std::stringstream message;
message << iterations << " C0 it=" << ii << " [" << atomI << " " << atomJ << "]";
message << " rp2=" << rp2 << " tol=" << d_ij2[ii];
message << " diff=" << diff << " acor=" << acor;
message << " m2=" << reducedMasses[ii];
message << " rm[" << inverseMasses[atomI] << " " << inverseMasses[atomJ];
message << " [" << atomCoordinatesP[atomI][0] << " " << atomCoordinatesP[atomI][1] << " " << atomCoordinatesP[atomI][2] << "] ";
message << " [" << atomCoordinatesP[atomJ][0] << " " << atomCoordinatesP[atomJ][1] << " " << atomCoordinatesP[atomJ][2] << "] ";
message << " rrpr=" << rrpr << " rijx=" << r_ij[ii][0];
message << " \n";
SimTKOpenMMLog::printMessage( message );
} */
} else { } else {
numberConverged++; numberConverged++;
} }
...@@ -338,26 +320,6 @@ if( ii < -3 ){ ...@@ -338,26 +320,6 @@ if( ii < -3 ){
} }
} }
// diagnostics
if( debug || !done ){
std::stringstream message;
message << methodName;
message << " iterations=" << iterations << " no. converged=" << numberConverged << " out of " << _numberOfConstraints;
if( done ){
message << " SUCCESS";
} else {
message << " FAILED";
}
message << "\n";
int errors = reportShake( numberOfAtoms, atomCoordinatesP, message );
if( !errors ){
message << "*** no errors recorded in explicit check ***";
}
message << "\n";
SimTKOpenMMLog::printMessage( message );
}
return (done ? ReferenceDynamics::DefaultReturn : ReferenceDynamics::ErrorReturn); return (done ? ReferenceDynamics::DefaultReturn : ReferenceDynamics::ErrorReturn);
} }
......
platforms/reference/src/SimTKReference/ReferenceShakeAlgorithm.h
View file @ b5858a8e
...@@ -120,18 +120,6 @@ class ReferenceShakeAlgorithm : public ReferenceConstraintAlgorithm { ...@@ -120,18 +120,6 @@ class ReferenceShakeAlgorithm : public ReferenceConstraintAlgorithm {
void setTolerance( RealOpenMM tolerance ); void setTolerance( RealOpenMM tolerance );
/**---------------------------------------------------------------------------------------
Print parameters
@param message message
@return ReferenceShakeAlgorithm::DefaultReturn
--------------------------------------------------------------------------------------- */
int printParameters( std::stringstream& message ) const;
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
Apply Shake algorithm Apply Shake algorithm
......
platforms/reference/src/SimTKReference/ReferenceStochasticDynamics.cpp
View file @ b5858a8e
...@@ -57,7 +57,7 @@ ReferenceStochasticDynamics::ReferenceStochasticDynamics( int numberOfAtoms, ...@@ -57,7 +57,7 @@ ReferenceStochasticDynamics::ReferenceStochasticDynamics( int numberOfAtoms,
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// insure tau is not zero -- if it is print warning message // ensure tau is not zero -- if it is print warning message
if( _tau == zero ){ if( _tau == zero ){
...@@ -110,34 +110,6 @@ RealOpenMM ReferenceStochasticDynamics::getTau( void ) const { ...@@ -110,34 +110,6 @@ RealOpenMM ReferenceStochasticDynamics::getTau( void ) const {
return _tau; return _tau;
} }
/**---------------------------------------------------------------------------------------
Print parameters
@param message message
@return ReferenceDynamics::DefaultReturn
--------------------------------------------------------------------------------------- */
int ReferenceStochasticDynamics::printParameters( std::stringstream& message ) const {
// ---------------------------------------------------------------------------------------
//static const char* methodName = "\nReferenceStochasticDynamics::printParameters";
// ---------------------------------------------------------------------------------------
// print parameters
ReferenceDynamics::printParameters( message );
message << " tau=" << getTau();
message << " T=" << getTemperature();
return ReferenceDynamics::DefaultReturn;
}
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
First SD update; based on code in update.c do_update_sd() Gromacs 3.1.4 First SD update; based on code in update.c do_update_sd() Gromacs 3.1.4
......
platforms/reference/src/SimTKReference/ReferenceStochasticDynamics.h
View file @ b5858a8e
...@@ -71,18 +71,6 @@ class ReferenceStochasticDynamics : public ReferenceDynamics { ...@@ -71,18 +71,6 @@ class ReferenceStochasticDynamics : public ReferenceDynamics {
RealOpenMM getTau( void ) const; RealOpenMM getTau( void ) const;
/**---------------------------------------------------------------------------------------
Print parameters
@param message message
@return ReferenceDynamics::DefaultReturn
--------------------------------------------------------------------------------------- */
int printParameters( std::stringstream& message ) const;
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
Update Update
......
platforms/reference/src/SimTKReference/ReferenceVariableStochasticDynamics.cpp
View file @ b5858a8e
...@@ -58,7 +58,7 @@ ReferenceVariableStochasticDynamics::ReferenceVariableStochasticDynamics( int nu ...@@ -58,7 +58,7 @@ ReferenceVariableStochasticDynamics::ReferenceVariableStochasticDynamics( int nu
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// insure tau is not zero -- if it is print warning message // ensure tau is not zero -- if it is print warning message
if( _tau == zero ){ if( _tau == zero ){
...@@ -133,34 +133,6 @@ RealOpenMM ReferenceVariableStochasticDynamics::getTau( void ) const { ...@@ -133,34 +133,6 @@ RealOpenMM ReferenceVariableStochasticDynamics::getTau( void ) const {
return _tau; return _tau;
} }
/**---------------------------------------------------------------------------------------
Print parameters
@param message message
@return ReferenceDynamics::DefaultReturn
--------------------------------------------------------------------------------------- */
int ReferenceVariableStochasticDynamics::printParameters( std::stringstream& message ) const {
// ---------------------------------------------------------------------------------------
//static const char* methodName = "\nReferenceVariableStochasticDynamics::printParameters";
// ---------------------------------------------------------------------------------------
// print parameters
ReferenceDynamics::printParameters( message );
message << " tau=" << getTau();
message << " T=" << getTemperature();
return ReferenceDynamics::DefaultReturn;
}
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
First SD update; based on code in update.c do_update_sd() Gromacs 3.1.4 First SD update; based on code in update.c do_update_sd() Gromacs 3.1.4
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment