Skip to content

GitLab

Commit adb4ec5a authored by Mark Friedrichs's avatar Mark Friedrichs
Browse files

Mods

parent 0e675a19
Show whitespace changes
Inline Side-by-side
Showing with 938 additions and 881 deletions
platforms/brook/src/BrookBonded.cpp
View file @ adb4ec5a
...@@ -1805,13 +1805,13 @@ void BrookBonded::computeForces( BrookStreamImpl& positionStream, BrookStreamImp ...@@ -1805,13 +1805,13 @@ void BrookBonded::computeForces( BrookStreamImpl& positionStream, BrookStreamImp
static const std::string methodName = "BrookBonded::computeForces"; static const std::string methodName = "BrookBonded::computeForces";
static const int PrintOn = 0;
static const int I_Stream = 0; static const int I_Stream = 0;
static const int J_Stream = 1; static const int J_Stream = 1;
static const int K_Stream = 2; static const int K_Stream = 2;
static const int L_Stream = 3; static const int L_Stream = 3;
static const int PrintOn = 0;
static const int MaxErrorMessages = 2; static const int MaxErrorMessages = 2;
static int ErrorMessages = 0; static int ErrorMessages = 0;
......
platforms/brook/src/BrookCalcKineticEnergyKernel.cpp
View file @ adb4ec5a
...@@ -141,34 +141,48 @@ double BrookCalcKineticEnergyKernel::execute( OpenMMContextImpl& context ){ ...@@ -141,34 +141,48 @@ double BrookCalcKineticEnergyKernel::execute( OpenMMContextImpl& context ){
void* dataV = _openMMBrookInterface.getParticleVelocities()->getData( 1 ); void* dataV = _openMMBrookInterface.getParticleVelocities()->getData( 1 );
float* velocity = (float*) dataV; float* velocity = (float*) dataV;
double energy = 0.0;
int index = 0;
/* if( 0 && _numberOfParticles ){
printf( "BrookCalcKineticEnergyKernel:\n" ); printf( "BrookCalcKineticEnergyKernel:\n" );
float com[3] = { 0.0, 0.0, 0.0 }; float com[3] = { 0.0, 0.0, 0.0 };
for ( int ii = 0; ii < _numberOfParticles; ii++, index += 3 ){ float localEnergy = 0.0f;
com[0] += velocity[index]; int localIndex = 0;
com[1] += velocity[index+1]; float massSum = 0.0f;
com[2] += velocity[index+2]; for ( int ii = 0; ii < _numberOfParticles; ii++, localIndex += 3 ){
printf( " %d %.3f [%12.5e %12.5e %12.5e]\n", ii, _masses[ii], velocity[index], velocity[index+1], velocity[index+2] );
com[0] += _masses[ii]*velocity[localIndex];
com[1] += _masses[ii]*velocity[localIndex+1];
com[2] += _masses[ii]*velocity[localIndex+2];
localEnergy += _masses[ii]*(velocity[localIndex]*velocity[localIndex] + velocity[localIndex + 1]*velocity[localIndex + 1] + velocity[localIndex + 2]*velocity[localIndex + 2]);
massSum += _masses[ii];
printf( " %d %.3f [%12.5e %12.5e %12.5e]\n", ii, _masses[ii], velocity[localIndex], velocity[localIndex+1], velocity[localIndex+2] );
} }
printf( "Com [%12.5e %12.5e %12.5e]\n", com[0], com[1], com[2] ); float inverseTotalMass = 1.0f/massSum;
index = 0; com[0] *= inverseTotalMass;
com[1] *= inverseTotalMass;
com[2] *= inverseTotalMass;
printf( "KE raw=%.5e Com [%12.5e %12.5e %12.5e]\n", 0.5f*localEnergy, com[0], com[1], com[2] );
float newcom[3] = { 0.0, 0.0, 0.0 }; float newcom[3] = { 0.0, 0.0, 0.0 };
for ( int ii = 0; ii < _numberOfParticles; ii++, index += 3 ){ localIndex = 0;
velocity[index] -= com[0]; for ( int ii = 0; ii < _numberOfParticles; ii++, localIndex += 3 ){
velocity[index+1] -= com[1]; velocity[localIndex] -= com[0];
velocity[index+2] -= com[2]; velocity[localIndex+1] -= com[1];
newcom[0] += velocity[index]; velocity[localIndex+2] -= com[2];
newcom[1] += velocity[index+1]; newcom[0] += velocity[localIndex];
newcom[2] += velocity[index+2]; newcom[1] += velocity[localIndex+1];
newcom[2] += velocity[localIndex+2];
printf( " %d %.3f [%12.5e %12.5e %12.5e]\n", ii, _masses[ii], velocity[localIndex], velocity[localIndex+1], velocity[localIndex+2] );
} }
printf( "NewCom [%12.5e %12.5e %12.5e]\n", newcom[0], newcom[1], newcom[2] ); printf( "NewCom [%12.5e %12.5e %12.5e]\n", newcom[0], newcom[1], newcom[2] );
index = 0;
*/
}
int index = 0;
double energy = 0.0;
for( int ii = 0; ii < _numberOfParticles; ii++, index += 3 ){ for( int ii = 0; ii < _numberOfParticles; ii++, index += 3 ){
energy += _masses[ii]*(velocity[index]*velocity[index] + velocity[index + 1]*velocity[index + 1] + velocity[index + 2]*velocity[index + 2]); energy += _masses[ii]*(velocity[index]*velocity[index] + velocity[index + 1]*velocity[index + 1] + velocity[index + 2]*velocity[index + 2]);
} }
......
platforms/brook/src/BrookIntegrateVerletStepKernel.cpp
View file @ adb4ec5a
...@@ -168,7 +168,7 @@ void BrookIntegrateVerletStepKernel::initialize( const System& system, const Ve ...@@ -168,7 +168,7 @@ void BrookIntegrateVerletStepKernel::initialize( const System& system, const Ve
BrookOpenMMFloat tolerance = static_cast<BrookOpenMMFloat>( integrator.getConstraintTolerance() ); BrookOpenMMFloat tolerance = static_cast<BrookOpenMMFloat>( integrator.getConstraintTolerance() );
_brookShakeAlgorithm->setShakeTolerance( tolerance ); _brookShakeAlgorithm->setShakeTolerance( tolerance );
_brookShakeAlgorithm->setMaxIterations( 30 ); _brookShakeAlgorithm->setMaxIterations( 40 );
if( printOn && log ){ if( printOn && log ){
(void) fprintf( log, "%s done w/ setup: particles=%d const=%d\n", methodName.c_str(), numberOfParticles, numberOfConstraints ); (void) fprintf( log, "%s done w/ setup: particles=%d const=%d\n", methodName.c_str(), numberOfParticles, numberOfConstraints );
......
platforms/brook/src/BrookLangevinDynamics.cpp
View file @ adb4ec5a
...@@ -299,8 +299,22 @@ int BrookLangevinDynamics::_updateDerivedParameters( void ){ ...@@ -299,8 +299,22 @@ int BrookLangevinDynamics::_updateDerivedParameters( void ){
_derivedParameters[Sd1pc1] = tau*( one - _derivedParameters[EM] ); _derivedParameters[Sd1pc1] = tau*( one - _derivedParameters[EM] );
_derivedParameters[Sd1pc2] = tau*( _derivedParameters[EPH] - _derivedParameters[EMH] ); _derivedParameters[Sd1pc2] = tau*( _derivedParameters[EPH] - _derivedParameters[EMH] );
if( fabsf( _derivedParameters[Sd1pc2] ) < 1.0e-06 ){
_derivedParameters[Sd1pc2] = tau*_derivedParameters[GDT];
}
_derivedParameters[Sd1pc3] = _derivedParameters[D]/(tau*_derivedParameters[C] ); _derivedParameters[Sd1pc3] = _derivedParameters[D]/(tau*_derivedParameters[C] );
// if tau was greater than 20000, then _derivedParameters[Sd1pc2] was zero
// using tau*_derivedParameters[GDT] as approximation to tau*( _derivedParameters[EPH] - _derivedParameters[EMH] ) for values in this
// range
if( fabsf( _derivedParameters[Sd1pc2] ) > 1.0e-10 ){
_derivedParameters[Sd2pc1] = one/_derivedParameters[Sd1pc2]; _derivedParameters[Sd2pc1] = one/_derivedParameters[Sd1pc2];
} else {
std::stringstream message;
message << methodName << " Sd1pc2=" << _derivedParameters[Sd1pc2] << " is too small (Sd2pc1 is 1/Sd1pc2)";
throw OpenMMException( message.str() );
}
_derivedParameters[Sd2pc2] = tau*_derivedParameters[D]/( _derivedParameters[EM] - one ); _derivedParameters[Sd2pc2] = tau*_derivedParameters[D]/( _derivedParameters[EM] - one );
return DefaultReturnValue; return DefaultReturnValue;
...@@ -340,7 +354,7 @@ int BrookLangevinDynamics::updateParameters( double temperature, double friction ...@@ -340,7 +354,7 @@ int BrookLangevinDynamics::updateParameters( double temperature, double friction
if( showUpdate && getLog() && (showUpdate++ < maxShowUpdate) ){ if( showUpdate && getLog() && (showUpdate++ < maxShowUpdate) ){
std::string contents = getContentsString( ); std::string contents = getContentsString( );
(void) fprintf( getLog(), "%s contents\n%s", methodName, contents.c_str() ); (void) fprintf( getLog(), "%s contents\n%s", methodName.c_str(), contents.c_str() );
(void) fflush( getLog() ); (void) fflush( getLog() );
} }
...@@ -349,836 +363,863 @@ int BrookLangevinDynamics::updateParameters( double temperature, double friction ...@@ -349,836 +363,863 @@ int BrookLangevinDynamics::updateParameters( double temperature, double friction
}; };
/** /**
* Update
* *
* @param positions particle positions * Get array of derived parameters indexed by 'DerivedParameters' enums
* @param velocities particle velocities
* @param forces particle forces
* @param brookShakeAlgorithm BrookShakeAlgorithm reference
* @param brookRandomNumberGenerator BrookRandomNumberGenerator reference
* *
* @return DefaultReturnValue * @return array
* *
*/ */
int BrookLangevinDynamics::update( BrookStreamImpl& positionStream, BrookStreamImpl& velocityStream, const BrookOpenMMFloat* BrookLangevinDynamics::getDerivedParameters( void ) const {
BrookStreamImpl& forceStream,
BrookShakeAlgorithm& brookShakeAlgorithm,
BrookRandomNumberGenerator& brookRandomNumberGenerator ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
static const std::string methodName = "\nBrookLangevinDynamics::update"; // static const std::string methodName = "\nBrookLangevinDynamics::getDerivedParameters";
static const int PrintOn = 0;
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
const BrookOpenMMFloat* derivedParameters = getDerivedParameters(); return _derivedParameters;
}
if( (1 || PrintOn) && getLog() ){ /**
* Get Particle stream size
*
* @return Particle stream size
*
*/
static int showAux = 1; int BrookLangevinDynamics::getLangevinDynamicsParticleStreamSize( void ) const {
return _sdParticleStreamSize;
}
if( PrintOn ){ /**
(void) fprintf( getLog(), "%s shake=%d\n", methodName, brookShakeAlgorithm.getNumberOfConstraints() ); * Get particle stream width
(void) fflush( getLog() ); *
} * @return particle stream width
*
*/
// show update int BrookLangevinDynamics::getLangevinDynamicsParticleStreamWidth( void ) const {
return _sdParticleStreamWidth;
}
if( showAux ){ /**
showAux = 0; * Get particle stream height
*
* @return particle stream height
*/
std::string contents = brookRandomNumberGenerator.getContentsString( ); int BrookLangevinDynamics::getLangevinDynamicsParticleStreamHeight( void ) const {
(void) fprintf( getLog(), "%s RNG contents\n%s", methodName, contents.c_str() ); return _sdParticleStreamHeight;
// brookRandomNumberGenerator.getRandomNumberStream( brookRandomNumberGenerator.getRvStreamIndex() )->printToFile( getLog() ); }
contents = brookShakeAlgorithm.getContentsString( ); /**
(void) fprintf( getLog(), "%s Shake contents\n%s", methodName, contents.c_str() ); * Get SDPC1 stream
*
* @return SDPC1 stream
*
*/
(void) fflush( getLog() ); BrookFloatStreamInternal* BrookLangevinDynamics::getSDPC1Stream( void ) const {
} return _sdStreams[SDPC1Stream];
} }
// first integration step /**
* Get SDPC2 stream
*
* @return SDPC2 stream
*
*/
kupdate_sd1_fix1( BrookFloatStreamInternal* BrookLangevinDynamics::getSDPC2Stream( void ) const {
(float) getLangevinDynamicsParticleStreamWidth(), return _sdStreams[SDPC2Stream];
(float) brookRandomNumberGenerator.getRandomNumberStreamWidth(), }
(float) brookRandomNumberGenerator.getRvStreamOffset(),
derivedParameters[EM],
derivedParameters[Sd1pc1],
derivedParameters[Sd1pc2],
derivedParameters[Sd1pc3],
getSDPC1Stream()->getBrookStream(),
brookRandomNumberGenerator.getRandomNumberStream( brookRandomNumberGenerator.getRvStreamIndex() )->getBrookStream(),
getSD2XStream()->getBrookStream(),
positionStream.getBrookStream(),
forceStream.getBrookStream(),
velocityStream.getBrookStream(),
getInverseMassStream()->getBrookStream(),
getSD1VStream()->getBrookStream(),
getVPrimeStream()->getBrookStream(),
getXPrimeStream()->getBrookStream()
);
// diagnostics /**
* Get SD2X stream
*
* @return SD2X stream
*
*/
if( PrintOn ){ BrookFloatStreamInternal* BrookLangevinDynamics::getSD2XStream( void ) const {
(void) fprintf( getLog(), "\n%s Post kupdate_sd1_fix1: particleStrW=%3d rngStrW=%3d rngOff=%5d " return _sdStreams[SD2XStream];
"EM=%12.5e Sd1pc[]=[%12.5e %12.5e %12.5e]", methodName, }
getLangevinDynamicsParticleStreamWidth(),
brookRandomNumberGenerator.getRandomNumberStreamWidth(),
brookRandomNumberGenerator.getRvStreamOffset(),
derivedParameters[EM], derivedParameters[Sd1pc1], derivedParameters[Sd1pc2], derivedParameters[Sd1pc3] );
(void) fprintf( getLog(), "\nSDPC1Stream\n" ); /**
getSDPC1Stream()->printToFile( getLog() ); * Get SD1V stream
*
* @return SD1V stream
*
*/
(void) fprintf( getLog(), "\nSD2XStream\n" ); BrookFloatStreamInternal* BrookLangevinDynamics::getSD1VStream( void ) const {
getSD2XStream()->printToFile( getLog() ); return _sdStreams[SD1VStream];
}
(void) fprintf( getLog(), "\nInverseMassStream\n" ); /**
getInverseMassStream()->printToFile( getLog() ); * Get VPrime stream
*
* @return Vprime stream
*
*/
//StreamImpl& positionStreamImpl = positionStream.getImpl(); BrookFloatStreamInternal* BrookLangevinDynamics::getVPrimeStream( void ) const {
//const BrookStreamImpl brookPositions = dynamic_cast<BrookStreamImpl&> (positionStreamImpl); return _sdStreams[VPrimeStream];
BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl(); }
(void) fprintf( getLog(), "\nPositionStream\n" );
brookStreamInternalPos->printToFile( getLog() );
(void) fprintf( getLog(), "\nForceStream\n" ); /**
BrookStreamInternal* brookStreamInternalF = forceStream.getBrookStreamImpl(); * Get XPrime stream
brookStreamInternalF->printToFile( getLog() ); *
* @return Xprime stream
*
*/
BrookStreamInternal* brookStreamInternalV = velocityStream.getBrookStreamImpl(); BrookFloatStreamInternal* BrookLangevinDynamics::getXPrimeStream( void ) const {
(void) fprintf( getLog(), "\nVelocityStream\n" ); return _sdStreams[XPrimeStream];
brookStreamInternalV->printToFile( getLog() ); }
(void) fprintf( getLog(), "\nSD1VStream\n" ); /**
getSD1VStream()->printToFile( getLog() ); * Get InverseMass stream
*
* @return inverse mass stream
*
*/
(void) fprintf( getLog(), "\nVPrimeStream\n" ); BrookFloatStreamInternal* BrookLangevinDynamics::getInverseMassStream( void ) const {
getVPrimeStream()->printToFile( getLog() ); return _sdStreams[InverseMassStream];
}
(void) fprintf( getLog(), "\nXPrimeStream\n" ); /**
getXPrimeStream()->printToFile( getLog() ); * Initialize stream dimensions
*
* @param numberOfParticles number of particles
* @param platform platform
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
*/
(void) fprintf( getLog(), "\nRvStreamIndex=%d\n", brookRandomNumberGenerator.getRvStreamIndex() ); int BrookLangevinDynamics::_initializeStreamSizes( int numberOfParticles, const Platform& platform ){
// brookRandomNumberGenerator.getRandomNumberStream( brookRandomNumberGenerator.getRvStreamIndex() )->printToFile( getLog() );
}
// advance random number cursor // ---------------------------------------------------------------------------------------
brookRandomNumberGenerator.advanceGVCursor( 2*getNumberOfParticles() ); //static const std::string methodName = "BrookLangevinDynamics::_initializeStreamSizes";
// first Shake step // ---------------------------------------------------------------------------------------
if( brookShakeAlgorithm.getNumberOfConstraints() > 0 ){ _sdParticleStreamSize = getParticleStreamSize( platform );
_sdParticleStreamWidth = getParticleStreamWidth( platform );
_sdParticleStreamHeight = getParticleStreamHeight( platform );
kshakeh_fix1( return DefaultReturnValue;
(float) brookShakeAlgorithm.getMaxIterations(), }
(float) getLangevinDynamicsParticleStreamWidth(),
brookShakeAlgorithm.getShakeTolerance(),
brookShakeAlgorithm.getShakeParticleIndicesStream()->getBrookStream(),
positionStream.getBrookStream(),
getXPrimeStream()->getBrookStream(),
brookShakeAlgorithm.getShakeParticleParameterStream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons0Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons1Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons2Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons3Stream()->getBrookStream() );
// first Shake gather /**
* Initialize stream dimensions
*
* @param numberOfParticles number of particles
* @param platform platform
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
*/
kshakeh_update1_fix1( //std::string BrookLangevinDynamics::_getDerivedParametersString( BrookLangevinDynamics::DerivedParameters derivedParametersIndex ) const {
(float) getLangevinDynamicsParticleStreamWidth(), std::string BrookLangevinDynamics::_getDerivedParametersString( int derivedParametersIndex ) const {
brookShakeAlgorithm.getShakeInverseMapStream()->getBrookStream(),
positionStream.getBrookStream(),
getXPrimeStream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons0Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons1Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons2Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons3Stream()->getBrookStream(),
getXPrimeStream()->getBrookStream() );
if( ( 0 || PrintOn) && getLog() ){ // ---------------------------------------------------------------------------------------
(void) fprintf( getLog(), "\n%s Post kshakeh_update2_fix1: particleStrW=%3d", //static const std::string methodName = "BrookLangevinDynamics::_getDerivedParametersString";
methodName, getLangevinDynamicsParticleStreamWidth() );
(void) fprintf( getLog(), "\nShakeInverseMapStream\n" ); // ---------------------------------------------------------------------------------------
brookShakeAlgorithm.getShakeInverseMapStream()->printToFile( getLog() );
BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl(); std::string returnString;
(void) fprintf( getLog(), "\nPositionStream\n" );
brookStreamInternalPos->printToFile( getLog() );
(void) fprintf( getLog(), "\nXPrimeStream\n" ); switch( derivedParametersIndex ){
getXPrimeStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons0\n" );
brookShakeAlgorithm.getShakeXCons0Stream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons1\n" ); case GDT:
brookShakeAlgorithm.getShakeXCons1Stream()->printToFile( getLog() ); returnString = "GDT";
break;
(void) fprintf( getLog(), "\nShakeXCons2\n" ); case EPH:
brookShakeAlgorithm.getShakeXCons2Stream()->printToFile( getLog() ); returnString = "EPH";
break;
(void) fprintf( getLog(), "\nShakeXCons3\n" ); case EMH:
brookShakeAlgorithm.getShakeXCons3Stream()->printToFile( getLog() ); returnString = "EMH";
break;
} case EP:
returnString = "EP";
break;
case EM:
returnString = "EM";
break;
} case B:
returnString = "B";
break;
// second integration step case C:
returnString = "C";
break;
kupdate_sd2_fix1( case D:
(float) getLangevinDynamicsParticleStreamWidth(), returnString = "D";
(float) brookRandomNumberGenerator.getRandomNumberStreamWidth(), break;
(float) brookRandomNumberGenerator.getRvStreamOffset(),
derivedParameters[Sd2pc1],
derivedParameters[Sd2pc2],
getSDPC2Stream()->getBrookStream(),
brookRandomNumberGenerator.getRandomNumberStream( brookRandomNumberGenerator.getRvStreamIndex() )->getBrookStream(),
getSD1VStream()->getBrookStream(),
positionStream.getBrookStream(),
getXPrimeStream()->getBrookStream(),
getVPrimeStream()->getBrookStream(),
getSD2XStream()->getBrookStream(),
velocityStream.getBrookStream(),
getXPrimeStream()->getBrookStream()
);
// diagnostics case V:
returnString = "V";
break;
if( PrintOn ){ case X:
(void) fprintf( getLog(), "\n%s Post kupdate_sd2_fix1: particleStrW=%3d rngStrW=%3d rngOff=%5d " returnString = "X";
"Sd2pc[]=[%12.5e %12.5e]", methodName, break;
getLangevinDynamicsParticleStreamWidth(),
brookRandomNumberGenerator.getRandomNumberStreamWidth(),
brookRandomNumberGenerator.getRvStreamOffset(),
derivedParameters[Sd2pc1], derivedParameters[Sd2pc2] );
(void) fprintf( getLog(), "\nSDPC2Stream\n" ); case Yv:
getSDPC2Stream()->printToFile( getLog() ); returnString = "Yv";
break;
(void) fprintf( getLog(), "\nSD2XStream\n" ); case Yx:
getSD1VStream()->printToFile( getLog() ); returnString = "Yx";
break;
BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl(); case Sd1pc1:
(void) fprintf( getLog(), "\nPositionStream\n" ); returnString = "Sd1pc1";
brookStreamInternalPos->printToFile( getLog() ); break;
(void) fprintf( getLog(), "\nVPrimeStream\n" ); case Sd1pc2:
getVPrimeStream()->printToFile( getLog() ); returnString = "Sd1pc2";
break;
(void) fprintf( getLog(), "\nXPrimeStream\n" ); case Sd1pc3:
getXPrimeStream()->printToFile( getLog() ); returnString = "Sd1pc3";
break;
(void) fprintf( getLog(), "\ngetSD2XStream\n" ); case Sd2pc1:
getSD2XStream()->printToFile( getLog() ); returnString = "Sd2pc1";
break;
BrookStreamInternal* brookStreamInternalVel = velocityStream.getBrookStreamImpl(); case Sd2pc2:
(void) fprintf( getLog(), "\nVelocityStream\n" ); returnString = "Sd2pc2";
brookStreamInternalVel->printToFile( getLog() ); break;
(void) fprintf( getLog(), "\nRvStreamIndex=%d\n", brookRandomNumberGenerator.getRvStreamIndex() ); default:
// brookRandomNumberGenerator.getRandomNumberStream( brookRandomNumberGenerator.getRvStreamIndex() )->printToFile( getLog() ); returnString = "Unknown";
break;
} }
// advance random number cursor return returnString;
}
brookRandomNumberGenerator.advanceGVCursor( 2*getNumberOfParticles() ); /**
* Initialize streams
*
* @param platform platform
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
*/
// second Shake step int BrookLangevinDynamics::_initializeStreams( const Platform& platform ){
if( brookShakeAlgorithm.getNumberOfConstraints() > 0 ){ // ---------------------------------------------------------------------------------------
kshakeh_fix1( //static const std::string methodName = "BrookLangevinDynamics::_initializeStreams";
(float) brookShakeAlgorithm.getMaxIterations(),
(float) getLangevinDynamicsParticleStreamWidth(),
brookShakeAlgorithm.getShakeTolerance(),
brookShakeAlgorithm.getShakeParticleIndicesStream()->getBrookStream(),
positionStream.getBrookStream(),
getXPrimeStream()->getBrookStream(),
brookShakeAlgorithm.getShakeParticleParameterStream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons0Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons1Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons2Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons3Stream()->getBrookStream() );
// second Shake gather BrookOpenMMFloat dangleValue = (BrookOpenMMFloat) 0.0;
kshakeh_update2_fix1( // ---------------------------------------------------------------------------------------
(float) getLangevinDynamicsParticleStreamWidth(),
brookShakeAlgorithm.getShakeInverseMapStream()->getBrookStream(),
positionStream.getBrookStream(),
getXPrimeStream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons0Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons1Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons2Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons3Stream()->getBrookStream(),
positionStream.getBrookStream() );
// diagnostics int sdParticleStreamSize = getLangevinDynamicsParticleStreamSize();
int sdParticleStreamWidth = getLangevinDynamicsParticleStreamWidth();
if( PrintOn ){ _sdStreams[SDPC1Stream] = new BrookFloatStreamInternal( BrookCommon::SDPC1Stream,
(void) fprintf( getLog(), "\n%s Post kshakeh_update2_fix1: particleStrW=%3d rngStrW=%3d rngOff=%5d " sdParticleStreamSize, sdParticleStreamWidth,
"Sd2pc[]=[%12.5e %12.5e]", methodName, BrookStreamInternal::Float2, dangleValue );
getLangevinDynamicsParticleStreamWidth(),
brookRandomNumberGenerator.getRandomNumberStreamWidth(),
brookRandomNumberGenerator.getRvStreamOffset(),
derivedParameters[Sd2pc1], derivedParameters[Sd2pc2] );
BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl(); _sdStreams[SDPC2Stream] = new BrookFloatStreamInternal( BrookCommon::SDPC2Stream,
(void) fprintf( getLog(), "\nPositionStream\n" ); sdParticleStreamSize, sdParticleStreamWidth,
brookStreamInternalPos->printToFile( getLog() ); BrookStreamInternal::Float2, dangleValue );
brookStreamInternalPos = velocityStream.getBrookStreamImpl(); _sdStreams[SD2XStream] = new BrookFloatStreamInternal( BrookCommon::SD2XStream,
(void) fprintf( getLog(), "\nVelocityStream\n" ); sdParticleStreamSize, sdParticleStreamWidth,
brookStreamInternalPos->printToFile( getLog() ); BrookStreamInternal::Float3, dangleValue );
(void) fprintf( getLog(), "\nXPrimeStream\n" ); _sdStreams[SD1VStream] = new BrookFloatStreamInternal( BrookCommon::SD1VStream,
getXPrimeStream()->printToFile( getLog() ); sdParticleStreamSize, sdParticleStreamWidth,
BrookStreamInternal::Float3, dangleValue );
_sdStreams[VPrimeStream] = new BrookFloatStreamInternal( BrookCommon::VPrimeStream,
sdParticleStreamSize, sdParticleStreamWidth,
BrookStreamInternal::Float3, dangleValue );
// brookRandomNumberGenerator.getRandomNumberStream( brookRandomNumberGenerator.getRvStreamIndex() )->printToFile( getLog() ); _sdStreams[XPrimeStream] = new BrookFloatStreamInternal( BrookCommon::XPrimeStream,
} sdParticleStreamSize, sdParticleStreamWidth,
BrookStreamInternal::Float3, dangleValue );
} else { _sdStreams[InverseMassStream] = new BrookFloatStreamInternal( BrookCommon::InverseMassStream,
//kadd3( getXPrimeStream()->getBrookStream(), positionStream.getBrookStream() ); sdParticleStreamSize, sdParticleStreamWidth,
ksetStr3( getXPrimeStream()->getBrookStream(), positionStream.getBrookStream() ); BrookStreamInternal::Float, dangleValue );
}
return DefaultReturnValue; return DefaultReturnValue;
}
};
/** /**
* Update sd streams -- called after parameters change
* *
* Get array of derived parameters indexed by 'DerivedParameters' enums * @return ErrorReturnValue if error, else DefaultReturnValue
*
* @return array
* *
*/ */
const BrookOpenMMFloat* BrookLangevinDynamics::getDerivedParameters( void ) const { int BrookLangevinDynamics::_updateSdStreams( void ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// static const std::string methodName = "\nBrookLangevinDynamics::getDerivedParameters"; static const std::string methodName = "BrookLangevinDynamics::_updateSdStreams";
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
return _derivedParameters; int sdParticleStreamSize = getLangevinDynamicsParticleStreamSize();
}
/** BrookOpenMMFloat* sdpc[2];
* Get Particle stream size for( int ii = 0; ii < 2; ii++ ){
* sdpc[ii] = new BrookOpenMMFloat[2*sdParticleStreamSize];
* @return Particle stream size memset( sdpc[ii], 0, 2*sdParticleStreamSize*sizeof( BrookOpenMMFloat ) );
* }
*/ BrookOpenMMFloat* inverseMass = new BrookOpenMMFloat[sdParticleStreamSize];
memset( inverseMass, 0, sdParticleStreamSize*sizeof( BrookOpenMMFloat ) );
int BrookLangevinDynamics::getLangevinDynamicsParticleStreamSize( void ) const { const BrookOpenMMFloat* derivedParameters = getDerivedParameters( );
return _sdParticleStreamSize; int numberOfParticles = getNumberOfParticles();
} int index = 0;
for( int ii = 0; ii < numberOfParticles; ii++, index += 2 ){
/** sdpc[0][index] = _inverseSqrtMasses[ii]*( static_cast<BrookOpenMMFloat> (derivedParameters[Yv]) );
* Get particle stream width sdpc[0][index+1] = _inverseSqrtMasses[ii]*( static_cast<BrookOpenMMFloat> (derivedParameters[V]) );
*
* @return particle stream width
*
*/
int BrookLangevinDynamics::getLangevinDynamicsParticleStreamWidth( void ) const { sdpc[1][index] = _inverseSqrtMasses[ii]*( static_cast<BrookOpenMMFloat> (derivedParameters[Yx]) );
return _sdParticleStreamWidth; sdpc[1][index+1] = _inverseSqrtMasses[ii]*( static_cast<BrookOpenMMFloat> (derivedParameters[X]) );
}
/** inverseMass[ii] = _inverseSqrtMasses[ii]*_inverseSqrtMasses[ii];
* Get particle stream height
*
* @return particle stream height
*/
int BrookLangevinDynamics::getLangevinDynamicsParticleStreamHeight( void ) const { }
return _sdParticleStreamHeight;
}
/** _sdStreams[SDPC1Stream]->loadFromArray( sdpc[0] );
* Get SDPC1 stream _sdStreams[SDPC2Stream]->loadFromArray( sdpc[1] );
* _sdStreams[InverseMassStream]->loadFromArray( inverseMass );
* @return SDPC1 stream
*
*/
BrookFloatStreamInternal* BrookLangevinDynamics::getSDPC1Stream( void ) const { for( int ii = 0; ii < 2; ii++ ){
return _sdStreams[SDPC1Stream]; delete[] sdpc[ii];
} }
delete[] inverseMass;
/** // initialize SD2X
* Get SDPC2 stream
*
* @return SDPC2 stream
*
*/
BrookFloatStreamInternal* BrookLangevinDynamics::getSDPC2Stream( void ) const { BrookOpenMMFloat* sd2x = new BrookOpenMMFloat[3*sdParticleStreamSize];
return _sdStreams[SDPC2Stream]; //SimTKOpenMMUtilities::setRandomNumberSeed( (uint32_t) getRandomNumberSeed() );
}
/** memset( sd2x, 0, 3*sdParticleStreamSize*sizeof( BrookOpenMMFloat ) );
* Get SD2X stream
*
* @return SD2X stream
*
*/
BrookFloatStreamInternal* BrookLangevinDynamics::getSD2XStream( void ) const { index = 0;
return _sdStreams[SD2XStream]; for( int ii = 0; ii < numberOfParticles; ii++, index += 3 ){
} sd2x[index] = _inverseSqrtMasses[ii]*derivedParameters[X]*( static_cast<BrookOpenMMFloat> (SimTKOpenMMUtilities::getNormallyDistributedRandomNumber()) );
sd2x[index+1] = _inverseSqrtMasses[ii]*derivedParameters[X]*( static_cast<BrookOpenMMFloat> (SimTKOpenMMUtilities::getNormallyDistributedRandomNumber()) );
sd2x[index+2] = _inverseSqrtMasses[ii]*derivedParameters[X]*( static_cast<BrookOpenMMFloat> (SimTKOpenMMUtilities::getNormallyDistributedRandomNumber()) );
}
/** _sdStreams[SD2XStream]->loadFromArray( sd2x );
* Get SD1V stream
*
* @return SD1V stream
*
*/
BrookFloatStreamInternal* BrookLangevinDynamics::getSD1VStream( void ) const { delete[] sd2x;
return _sdStreams[SD1VStream];
}
/** return DefaultReturnValue;
* Get VPrime stream
*
* @return Vprime stream
*
*/
BrookFloatStreamInternal* BrookLangevinDynamics::getVPrimeStream( void ) const {
return _sdStreams[VPrimeStream];
} }
/** /**
* Get XPrime stream * Set masses
* *
* @return Xprime stream * @param masses particle masses
* *
*/ */
BrookFloatStreamInternal* BrookLangevinDynamics::getXPrimeStream( void ) const { int BrookLangevinDynamics::_setInverseSqrtMasses( const std::vector<double>& masses ){
return _sdStreams[XPrimeStream];
}
/** // ---------------------------------------------------------------------------------------
* Get InverseMass stream
*
* @return inverse mass stream
*
*/
BrookFloatStreamInternal* BrookLangevinDynamics::getInverseMassStream( void ) const { //static const std::string methodName = "BrookLangevinDynamics::_setInverseSqrtMasses";
return _sdStreams[InverseMassStream];
BrookOpenMMFloat zero = (BrookOpenMMFloat) 0.0;
BrookOpenMMFloat one = (BrookOpenMMFloat) 1.0;
// ---------------------------------------------------------------------------------------
// setup inverse sqrt masses
_inverseSqrtMasses = new BrookOpenMMFloat[masses.size()];
int index = 0;
for( std::vector<double>::const_iterator ii = masses.begin(); ii != masses.end(); ii++, index++ ){
if( *ii != 0.0 ){
BrookOpenMMFloat value = static_cast<BrookOpenMMFloat>(*ii);
_inverseSqrtMasses[index] = ( SQRT( one/value ) );
} else {
_inverseSqrtMasses[index] = zero;
}
}
return DefaultReturnValue;
} }
/** /*
* Initialize stream dimensions * Setup of LangevinDynamics parameters
* *
* @param numberOfParticles number of particles * @param masses masses
* @param platform platform * @param platform Brook platform
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @return nonzero value if error
* *
*/ * */
int BrookLangevinDynamics::_initializeStreamSizes( int numberOfParticles, const Platform& platform ){ int BrookLangevinDynamics::setup( const std::vector<double>& masses, const Platform& platform ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
//static const std::string methodName = "BrookLangevinDynamics::_initializeStreamSizes"; static const std::string methodName = "BrookLangevinDynamics::setup";
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
_sdParticleStreamSize = getParticleStreamSize( platform ); const BrookPlatform brookPlatform = dynamic_cast<const BrookPlatform&> (platform);
_sdParticleStreamWidth = getParticleStreamWidth( platform ); setLog( brookPlatform.getLog() );
_sdParticleStreamHeight = getParticleStreamHeight( platform );
int numberOfParticles = (int) masses.size();
setNumberOfParticles( numberOfParticles );
// set stream sizes and then create streams
_initializeStreamSizes( numberOfParticles, platform );
_initializeStreams( platform );
_setInverseSqrtMasses( masses );
return DefaultReturnValue; return DefaultReturnValue;
} }
/** /*
* Initialize stream dimensions * Get contents of object
* *
* @param numberOfParticles number of particles * @param level level of dump
* @param platform platform
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @return string containing contents
* *
*/ * */
//std::string BrookLangevinDynamics::_getDerivedParametersString( BrookLangevinDynamics::DerivedParameters derivedParametersIndex ) const {
std::string BrookLangevinDynamics::_getDerivedParametersString( int derivedParametersIndex ) const {
// ---------------------------------------------------------------------------------------
//static const std::string methodName = "BrookLangevinDynamics::_getDerivedParametersString"; std::string BrookLangevinDynamics::getContentsString( int level ) const {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
std::string returnString; static const std::string methodName = "BrookLangevinDynamics::getContentsString";
switch( derivedParametersIndex ){
case GDT:
returnString = "GDT";
break;
case EPH:
returnString = "EPH";
break;
case EMH: static const unsigned int MAX_LINE_CHARS = 256;
returnString = "EMH"; char value[MAX_LINE_CHARS];
break; static const char* Set = "Set";
static const char* NotSet = "Not set";
case EP: // ---------------------------------------------------------------------------------------
returnString = "EP";
break;
case EM: std::stringstream message;
returnString = "EM"; std::string tab = " ";
break;
case B: #ifdef WIN32
returnString = "B"; #define LOCAL_SPRINTF(a,b,c) sprintf_s( (a), MAX_LINE_CHARS, (b), (c) );
break; #else
#define LOCAL_SPRINTF(a,b,c) sprintf( (a), (b), (c) );
#endif
case C: (void) LOCAL_SPRINTF( value, "%d", getNumberOfParticles() );
returnString = "C"; message << _getLine( tab, "Number of particles:", value );
break;
case D: (void) LOCAL_SPRINTF( value, "%d", getParticleStreamWidth() );
returnString = "D"; message << _getLine( tab, "Particle stream width:", value );
break;
case V: (void) LOCAL_SPRINTF( value, "%d", getParticleStreamHeight() );
returnString = "V"; message << _getLine( tab, "Particle stream height:", value );
break;
case X: (void) LOCAL_SPRINTF( value, "%d", getParticleStreamSize() );
returnString = "X"; message << _getLine( tab, "Particle stream size:", value );
break;
case Yv: (void) LOCAL_SPRINTF( value, "%.5f", getTau() );
returnString = "Yv"; message << _getLine( tab, "Tau:", value );
break;
case Yx: (void) LOCAL_SPRINTF( value, "%.5f", getTemperature() );
returnString = "Yx"; message << _getLine( tab, "Temperature:", value );
break;
case Sd1pc1: (void) LOCAL_SPRINTF( value, "%.5f", getStepSize() );
returnString = "Sd1pc1"; message << _getLine( tab, "Step size:", value );
break;
case Sd1pc2: const BrookOpenMMFloat* derivedParameters = getDerivedParameters();
returnString = "Sd1pc2"; for( int ii = 0; ii < MaxDerivedParameters; ii++ ){
break; (void) LOCAL_SPRINTF( value, "%.5e", derivedParameters[ii] );
message << _getLine( tab, _getDerivedParametersString( ii ), value );
}
case Sd1pc3: (void) LOCAL_SPRINTF( value, "%.5f", getTemperature() );
returnString = "Sd1pc3"; message << _getLine( tab, "Temperature:", value );
break;
case Sd2pc1: message << _getLine( tab, "Log:", (getLog() ? Set : NotSet) );
returnString = "Sd2pc1";
break;
case Sd2pc2: message << _getLine( tab, "SDPC1:", (getSDPC1Stream() ? Set : NotSet) );
returnString = "Sd2pc2"; message << _getLine( tab, "SDPC2:", (getSDPC2Stream() ? Set : NotSet) );
break; message << _getLine( tab, "SD2X:", (getSD2XStream() ? Set : NotSet) );
message << _getLine( tab, "SD1V:", (getSD1VStream() ? Set : NotSet) );
default: for( int ii = 0; ii < LastStreamIndex; ii++ ){
returnString = "Unknown"; message << std::endl;
break; if( _sdStreams[ii] ){
message << _sdStreams[ii]->getContentsString( );
}
} }
return returnString; #undef LOCAL_SPRINTF
}
return message.str();
}
/** /**
* Initialize streams * Update
* *
* @param platform platform * @param positions particle positions
* @param velocities particle velocities
* @param forces particle forces
* @param brookShakeAlgorithm BrookShakeAlgorithm reference
* @param brookRandomNumberGenerator BrookRandomNumberGenerator reference
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @return DefaultReturnValue
* *
*/ */
int BrookLangevinDynamics::_initializeStreams( const Platform& platform ){ int BrookLangevinDynamics::update( BrookStreamImpl& positionStream, BrookStreamImpl& velocityStream,
BrookStreamImpl& forceStream,
BrookShakeAlgorithm& brookShakeAlgorithm,
BrookRandomNumberGenerator& brookRandomNumberGenerator ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
//static const std::string methodName = "BrookLangevinDynamics::_initializeStreams"; static const std::string methodName = "\nBrookLangevinDynamics::update";
static const int PrintOn = 0;
BrookOpenMMFloat dangleValue = (BrookOpenMMFloat) 0.0;
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
int sdParticleStreamSize = getLangevinDynamicsParticleStreamSize(); const BrookOpenMMFloat* derivedParameters = getDerivedParameters();
int sdParticleStreamWidth = getLangevinDynamicsParticleStreamWidth();
_sdStreams[SDPC1Stream] = new BrookFloatStreamInternal( BrookCommon::SDPC1Stream, if( (0 || PrintOn) && getLog() ){
sdParticleStreamSize, sdParticleStreamWidth,
BrookStreamInternal::Float2, dangleValue );
_sdStreams[SDPC2Stream] = new BrookFloatStreamInternal( BrookCommon::SDPC2Stream, static int showAux = 1;
sdParticleStreamSize, sdParticleStreamWidth,
BrookStreamInternal::Float2, dangleValue );
_sdStreams[SD2XStream] = new BrookFloatStreamInternal( BrookCommon::SD2XStream, if( PrintOn ){
sdParticleStreamSize, sdParticleStreamWidth, (void) fprintf( getLog(), "%s shake=%d\n", methodName.c_str(), brookShakeAlgorithm.getNumberOfConstraints() );
BrookStreamInternal::Float3, dangleValue ); (void) fflush( getLog() );
}
_sdStreams[SD1VStream] = new BrookFloatStreamInternal( BrookCommon::SD1VStream, // show update
sdParticleStreamSize, sdParticleStreamWidth,
BrookStreamInternal::Float3, dangleValue );
_sdStreams[VPrimeStream] = new BrookFloatStreamInternal( BrookCommon::VPrimeStream, if( showAux ){
sdParticleStreamSize, sdParticleStreamWidth, showAux = 0;
BrookStreamInternal::Float3, dangleValue );
_sdStreams[XPrimeStream] = new BrookFloatStreamInternal( BrookCommon::XPrimeStream, std::string contents = brookRandomNumberGenerator.getContentsString( );
sdParticleStreamSize, sdParticleStreamWidth, (void) fprintf( getLog(), "%s RNG contents\n%s", methodName.c_str(), contents.c_str() );
BrookStreamInternal::Float3, dangleValue ); // brookRandomNumberGenerator.getRandomNumberStream( brookRandomNumberGenerator.getRvStreamIndex() )->printToFile( getLog() );
_sdStreams[InverseMassStream] = new BrookFloatStreamInternal( BrookCommon::InverseMassStream, contents = brookShakeAlgorithm.getContentsString( );
sdParticleStreamSize, sdParticleStreamWidth, (void) fprintf( getLog(), "%s Shake contents\n%s", methodName.c_str(), contents.c_str() );
BrookStreamInternal::Float, dangleValue );
return DefaultReturnValue; (void) fflush( getLog() );
} }
}
/** // first integration step
* Update sd streams -- called after parameters change
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
*/
int BrookLangevinDynamics::_updateSdStreams( void ){ kupdate_sd1_fix1(
(float) getLangevinDynamicsParticleStreamWidth(),
(float) brookRandomNumberGenerator.getRandomNumberStreamWidth(),
(float) brookRandomNumberGenerator.getRvStreamOffset(),
derivedParameters[EM],
derivedParameters[Sd1pc1],
derivedParameters[Sd1pc2],
derivedParameters[Sd1pc3],
getSDPC1Stream()->getBrookStream(),
brookRandomNumberGenerator.getRandomNumberStream( brookRandomNumberGenerator.getRvStreamIndex() )->getBrookStream(),
getSD2XStream()->getBrookStream(),
positionStream.getBrookStream(),
forceStream.getBrookStream(),
velocityStream.getBrookStream(),
getInverseMassStream()->getBrookStream(),
getSD1VStream()->getBrookStream(),
getVPrimeStream()->getBrookStream(),
getXPrimeStream()->getBrookStream()
);
// --------------------------------------------------------------------------------------- // diagnostics
static const std::string methodName = "BrookLangevinDynamics::_updateSdStreams"; if( PrintOn ){
(void) fprintf( getLog(), "\n%s Post kupdate_sd1_fix1: particleStrW=%3d rngStrW=%3d rngOff=%5d "
"EM=%12.5e Sd1pc[]=[%12.5e %12.5e %12.5e]", methodName.c_str(),
getLangevinDynamicsParticleStreamWidth(),
brookRandomNumberGenerator.getRandomNumberStreamWidth(),
brookRandomNumberGenerator.getRvStreamOffset(),
derivedParameters[EM], derivedParameters[Sd1pc1], derivedParameters[Sd1pc2], derivedParameters[Sd1pc3] );
// --------------------------------------------------------------------------------------- (void) fprintf( getLog(), "\nSDPC1Stream\n" );
getSDPC1Stream()->printToFile( getLog() );
int sdParticleStreamSize = getLangevinDynamicsParticleStreamSize(); (void) fprintf( getLog(), "\nSD2XStream\n" );
getSD2XStream()->printToFile( getLog() );
BrookOpenMMFloat* sdpc[2]; (void) fprintf( getLog(), "\nInverseMassStream\n" );
for( int ii = 0; ii < 2; ii++ ){ getInverseMassStream()->printToFile( getLog() );
sdpc[ii] = new BrookOpenMMFloat[2*sdParticleStreamSize];
memset( sdpc[ii], 0, 2*sdParticleStreamSize*sizeof( BrookOpenMMFloat ) );
}
BrookOpenMMFloat* inverseMass = new BrookOpenMMFloat[sdParticleStreamSize];
memset( inverseMass, 0, sdParticleStreamSize*sizeof( BrookOpenMMFloat ) );
const BrookOpenMMFloat* derivedParameters = getDerivedParameters( ); //StreamImpl& positionStreamImpl = positionStream.getImpl();
int numberOfParticles = getNumberOfParticles(); //const BrookStreamImpl brookPositions = dynamic_cast<BrookStreamImpl&> (positionStreamImpl);
int index = 0; BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
for( int ii = 0; ii < numberOfParticles; ii++, index += 2 ){ (void) fprintf( getLog(), "\nPositionStream\n" );
brookStreamInternalPos->printToFile( getLog() );
sdpc[0][index] = _inverseSqrtMasses[ii]*( static_cast<BrookOpenMMFloat> (derivedParameters[Yv]) ); (void) fprintf( getLog(), "\nForceStream\n" );
sdpc[0][index+1] = _inverseSqrtMasses[ii]*( static_cast<BrookOpenMMFloat> (derivedParameters[V]) ); BrookStreamInternal* brookStreamInternalF = forceStream.getBrookStreamImpl();
brookStreamInternalF->printToFile( getLog() );
sdpc[1][index] = _inverseSqrtMasses[ii]*( static_cast<BrookOpenMMFloat> (derivedParameters[Yx]) ); BrookStreamInternal* brookStreamInternalV = velocityStream.getBrookStreamImpl();
sdpc[1][index+1] = _inverseSqrtMasses[ii]*( static_cast<BrookOpenMMFloat> (derivedParameters[X]) ); (void) fprintf( getLog(), "\nVelocityStream\n" );
brookStreamInternalV->printToFile( getLog() );
inverseMass[ii] = _inverseSqrtMasses[ii]*_inverseSqrtMasses[ii]; (void) fprintf( getLog(), "\nSD1VStream\n" );
getSD1VStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nVPrimeStream\n" );
getVPrimeStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nXPrimeStream\n" );
getXPrimeStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nRvStreamIndex=%d\n", brookRandomNumberGenerator.getRvStreamIndex() );
// brookRandomNumberGenerator.getRandomNumberStream( brookRandomNumberGenerator.getRvStreamIndex() )->printToFile( getLog() );
} }
_sdStreams[SDPC1Stream]->loadFromArray( sdpc[0] ); // advance random number cursor
_sdStreams[SDPC2Stream]->loadFromArray( sdpc[1] );
_sdStreams[InverseMassStream]->loadFromArray( inverseMass ); brookRandomNumberGenerator.advanceGVCursor( 2*getNumberOfParticles() );
// first Shake step
if( brookShakeAlgorithm.getNumberOfConstraints() > 0 ){
kshakeh_fix1(
(float) brookShakeAlgorithm.getMaxIterations(),
(float) getLangevinDynamicsParticleStreamWidth(),
brookShakeAlgorithm.getShakeTolerance(),
brookShakeAlgorithm.getShakeParticleIndicesStream()->getBrookStream(),
positionStream.getBrookStream(),
getXPrimeStream()->getBrookStream(),
brookShakeAlgorithm.getShakeParticleParameterStream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons0Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons1Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons2Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons3Stream()->getBrookStream() );
// first Shake gather
for( int ii = 0; ii < 2; ii++ ){ kshakeh_update1_fix1(
delete[] sdpc[ii]; (float) getLangevinDynamicsParticleStreamWidth(),
} brookShakeAlgorithm.getShakeInverseMapStream()->getBrookStream(),
delete[] inverseMass; getXPrimeStream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons0Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons1Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons2Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons3Stream()->getBrookStream(),
getXPrimeStream()->getBrookStream() );
// initialize SD2X if( ( 0 || PrintOn) && getLog() ){
BrookOpenMMFloat* sd2x = new BrookOpenMMFloat[3*sdParticleStreamSize]; (void) fprintf( getLog(), "\n%s Post kshakeh_update2_fix1: particleStrW=%3d",
//SimTKOpenMMUtilities::setRandomNumberSeed( (uint32_t) getRandomNumberSeed() ); methodName.c_str(), getLangevinDynamicsParticleStreamWidth() );
memset( sd2x, 0, 3*sdParticleStreamSize*sizeof( BrookOpenMMFloat ) ); (void) fprintf( getLog(), "\nShakeInverseMapStream\n" );
brookShakeAlgorithm.getShakeInverseMapStream()->printToFile( getLog() );
index = 0; BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
for( int ii = 0; ii < numberOfParticles; ii++, index += 3 ){ (void) fprintf( getLog(), "\nPositionStream\n" );
sd2x[index] = _inverseSqrtMasses[ii]*derivedParameters[X]*( static_cast<BrookOpenMMFloat> (SimTKOpenMMUtilities::getNormallyDistributedRandomNumber()) ); brookStreamInternalPos->printToFile( getLog() );
sd2x[index+1] = _inverseSqrtMasses[ii]*derivedParameters[X]*( static_cast<BrookOpenMMFloat> (SimTKOpenMMUtilities::getNormallyDistributedRandomNumber()) );
sd2x[index+2] = _inverseSqrtMasses[ii]*derivedParameters[X]*( static_cast<BrookOpenMMFloat> (SimTKOpenMMUtilities::getNormallyDistributedRandomNumber()) );
}
_sdStreams[SD2XStream]->loadFromArray( sd2x ); (void) fprintf( getLog(), "\nXPrimeStream\n" );
getXPrimeStream()->printToFile( getLog() );
delete[] sd2x; (void) fprintf( getLog(), "\nShakeXCons0\n" );
brookShakeAlgorithm.getShakeXCons0Stream()->printToFile( getLog() );
return DefaultReturnValue; (void) fprintf( getLog(), "\nShakeXCons1\n" );
brookShakeAlgorithm.getShakeXCons1Stream()->printToFile( getLog() );
} (void) fprintf( getLog(), "\nShakeXCons2\n" );
brookShakeAlgorithm.getShakeXCons2Stream()->printToFile( getLog() );
/** (void) fprintf( getLog(), "\nShakeXCons3\n" );
* Set masses brookShakeAlgorithm.getShakeXCons3Stream()->printToFile( getLog() );
*
* @param masses particle masses
*
*/
int BrookLangevinDynamics::_setInverseSqrtMasses( const std::vector<double>& masses ){ }
// ---------------------------------------------------------------------------------------
//static const std::string methodName = "BrookLangevinDynamics::_setInverseSqrtMasses"; }
BrookOpenMMFloat zero = (BrookOpenMMFloat) 0.0; // second integration step
BrookOpenMMFloat one = (BrookOpenMMFloat) 1.0;
// --------------------------------------------------------------------------------------- kupdate_sd2_fix1(
(float) getLangevinDynamicsParticleStreamWidth(),
(float) brookRandomNumberGenerator.getRandomNumberStreamWidth(),
(float) brookRandomNumberGenerator.getRvStreamOffset(),
derivedParameters[Sd2pc1],
derivedParameters[Sd2pc2],
getSDPC2Stream()->getBrookStream(),
brookRandomNumberGenerator.getRandomNumberStream( brookRandomNumberGenerator.getRvStreamIndex() )->getBrookStream(),
getSD1VStream()->getBrookStream(),
positionStream.getBrookStream(),
getXPrimeStream()->getBrookStream(),
getVPrimeStream()->getBrookStream(),
getSD2XStream()->getBrookStream(),
velocityStream.getBrookStream(),
getXPrimeStream()->getBrookStream()
);
// setup inverse sqrt masses // diagnostics
_inverseSqrtMasses = new BrookOpenMMFloat[masses.size()]; if( 0 || PrintOn ){
int index = 0; (void) fprintf( getLog(), "\n%s Post kupdate_sd2_fix1: particleStrW=%3d rngStrW=%3d rngOff=%5d "
for( std::vector<double>::const_iterator ii = masses.begin(); ii != masses.end(); ii++, index++ ){ "Sd2pc[]=[%12.5e %12.5e]", methodName.c_str(),
if( *ii != 0.0 ){ getLangevinDynamicsParticleStreamWidth(),
BrookOpenMMFloat value = static_cast<BrookOpenMMFloat>(*ii); brookRandomNumberGenerator.getRandomNumberStreamWidth(),
_inverseSqrtMasses[index] = ( SQRT( one/value ) ); brookRandomNumberGenerator.getRvStreamOffset(),
} else { derivedParameters[Sd2pc1], derivedParameters[Sd2pc2] );
_inverseSqrtMasses[index] = zero;
}
}
return DefaultReturnValue; (void) fprintf( getLog(), "\nSDPC2Stream\n" );
} getSDPC2Stream()->printToFile( getLog() );
/* (void) fprintf( getLog(), "\nSD2XStream\n" );
* Setup of LangevinDynamics parameters getSD1VStream()->printToFile( getLog() );
*
* @param masses masses
* @param platform Brook platform
*
* @return nonzero value if error
*
* */
int BrookLangevinDynamics::setup( const std::vector<double>& masses, const Platform& platform ){ BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nPositionStream\n" );
brookStreamInternalPos->printToFile( getLog() );
// --------------------------------------------------------------------------------------- (void) fprintf( getLog(), "\nVPrimeStream\n" );
getVPrimeStream()->printToFile( getLog() );
static const std::string methodName = "BrookLangevinDynamics::setup"; (void) fprintf( getLog(), "\nXPrimeStream\n" );
getXPrimeStream()->printToFile( getLog() );
// --------------------------------------------------------------------------------------- (void) fprintf( getLog(), "\ngetSD2XStream\n" );
getSD2XStream()->printToFile( getLog() );
const BrookPlatform brookPlatform = dynamic_cast<const BrookPlatform&> (platform); BrookStreamInternal* brookStreamInternalVel = velocityStream.getBrookStreamImpl();
setLog( brookPlatform.getLog() ); (void) fprintf( getLog(), "\nVelocityStream\n" );
brookStreamInternalVel->printToFile( getLog() );
int numberOfParticles = (int) masses.size(); (void) fprintf( getLog(), "\nRvStreamIndex=%d\n", brookRandomNumberGenerator.getRvStreamIndex() );
setNumberOfParticles( numberOfParticles ); // brookRandomNumberGenerator.getRandomNumberStream( brookRandomNumberGenerator.getRvStreamIndex() )->printToFile( getLog() );
}
// set stream sizes and then create streams // advance random number cursor
_initializeStreamSizes( numberOfParticles, platform ); brookRandomNumberGenerator.advanceGVCursor( 2*getNumberOfParticles() );
_initializeStreams( platform );
_setInverseSqrtMasses( masses ); // second Shake step
return DefaultReturnValue; if( brookShakeAlgorithm.getNumberOfConstraints() > 0 ){
}
/* kshakeh_fix1(
* Get contents of object (float) brookShakeAlgorithm.getMaxIterations(),
* (float) getLangevinDynamicsParticleStreamWidth(),
* @param level level of dump brookShakeAlgorithm.getShakeTolerance(),
* brookShakeAlgorithm.getShakeParticleIndicesStream()->getBrookStream(),
* @return string containing contents positionStream.getBrookStream(),
* getXPrimeStream()->getBrookStream(),
* */ brookShakeAlgorithm.getShakeParticleParameterStream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons0Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons1Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons2Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons3Stream()->getBrookStream() );
std::string BrookLangevinDynamics::getContentsString( int level ) const { // second Shake gather
// --------------------------------------------------------------------------------------- kshakeh_update2_fix1(
(float) getLangevinDynamicsParticleStreamWidth(),
brookShakeAlgorithm.getShakeInverseMapStream()->getBrookStream(),
positionStream.getBrookStream(),
getXPrimeStream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons0Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons1Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons2Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons3Stream()->getBrookStream(),
positionStream.getBrookStream() );
static const std::string methodName = "BrookLangevinDynamics::getContentsString"; // diagnostics
static const unsigned int MAX_LINE_CHARS = 256; if( PrintOn ){
char value[MAX_LINE_CHARS]; (void) fprintf( getLog(), "\n%s Post kshakeh_update2_fix1: particleStrW=%3d rngStrW=%3d rngOff=%5d "
static const char* Set = "Set"; "Sd2pc[]=[%12.5e %12.5e]", methodName.c_str(),
static const char* NotSet = "Not set"; getLangevinDynamicsParticleStreamWidth(),
brookRandomNumberGenerator.getRandomNumberStreamWidth(),
brookRandomNumberGenerator.getRvStreamOffset(),
derivedParameters[Sd2pc1], derivedParameters[Sd2pc2] );
// --------------------------------------------------------------------------------------- BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nPositionStream\n" );
brookStreamInternalPos->printToFile( getLog() );
std::stringstream message; brookStreamInternalPos = velocityStream.getBrookStreamImpl();
std::string tab = " "; (void) fprintf( getLog(), "\nVelocityStream\n" );
brookStreamInternalPos->printToFile( getLog() );
#ifdef WIN32 (void) fprintf( getLog(), "\nXPrimeStream\n" );
#define LOCAL_SPRINTF(a,b,c) sprintf_s( (a), MAX_LINE_CHARS, (b), (c) ); getXPrimeStream()->printToFile( getLog() );
#else
#define LOCAL_SPRINTF(a,b,c) sprintf( (a), (b), (c) );
#endif
(void) LOCAL_SPRINTF( value, "%d", getNumberOfParticles() );
message << _getLine( tab, "Number of particles:", value );
(void) LOCAL_SPRINTF( value, "%d", getParticleStreamWidth() ); // brookRandomNumberGenerator.getRandomNumberStream( brookRandomNumberGenerator.getRvStreamIndex() )->printToFile( getLog() );
message << _getLine( tab, "Particle stream width:", value ); }
(void) LOCAL_SPRINTF( value, "%d", getParticleStreamHeight() ); } else {
message << _getLine( tab, "Particle stream height:", value );
(void) LOCAL_SPRINTF( value, "%d", getParticleStreamSize() ); // no constraints
message << _getLine( tab, "Particle stream size:", value );
(void) LOCAL_SPRINTF( value, "%.5f", getTau() ); if( PrintOn ){
message << _getLine( tab, "Tau:", value ); (void) fprintf( getLog(), "\n%s Pre ksetStr3 (no constraints)", methodName.c_str() );
// (void) fprintf( getLog(), "\nXPrimeStream\n" );
// getXPrimeStream()->printToFile( getLog() );
(void) LOCAL_SPRINTF( value, "%.5f", getTemperature() ); BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
message << _getLine( tab, "Temperature:", value ); (void) fprintf( getLog(), "\nPositionStream\n" );
brookStreamInternalPos->printToFile( getLog() );
}
(void) LOCAL_SPRINTF( value, "%.5f", getStepSize() ); kadd3( getXPrimeStream()->getBrookStream(), positionStream.getBrookStream(), positionStream.getBrookStream() );
message << _getLine( tab, "Step size:", value ); //ksetStr3( getXPrimeStream()->getBrookStream(), positionStream.getBrookStream() );
const BrookOpenMMFloat* derivedParameters = getDerivedParameters(); // diagnostics
for( int ii = 0; ii < MaxDerivedParameters; ii++ ){
(void) LOCAL_SPRINTF( value, "%.5e", derivedParameters[ii] );
message << _getLine( tab, _getDerivedParametersString( ii ), value );
}
(void) LOCAL_SPRINTF( value, "%.5f", getTemperature() ); if( PrintOn ){
message << _getLine( tab, "Temperature:", value ); (void) fprintf( getLog(), "\n%s Post ksetStr3 (no constraints)", methodName.c_str() );
message << _getLine( tab, "Log:", (getLog() ? Set : NotSet) ); (void) fprintf( getLog(), "\nXPrimeStream\n" );
getXPrimeStream()->printToFile( getLog() );
message << _getLine( tab, "SDPC1:", (getSDPC1Stream() ? Set : NotSet) ); BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
message << _getLine( tab, "SDPC2:", (getSDPC2Stream() ? Set : NotSet) ); (void) fprintf( getLog(), "\nPositionStream\n" );
message << _getLine( tab, "SD2X:", (getSD2XStream() ? Set : NotSet) ); brookStreamInternalPos->printToFile( getLog() );
message << _getLine( tab, "SD1V:", (getSD1VStream() ? Set : NotSet) );
for( int ii = 0; ii < LastStreamIndex; ii++ ){ // brookRandomNumberGenerator.getRandomNumberStream( brookRandomNumberGenerator.getRvStreamIndex() )->printToFile( getLog() );
message << std::endl;
if( _sdStreams[ii] ){
message << _sdStreams[ii]->getContentsString( );
} }
} }
#undef LOCAL_SPRINTF return DefaultReturnValue;
return message.str();
} }
platforms/brook/src/BrookRemoveCMMotionKernel.cpp
View file @ adb4ec5a
...@@ -96,7 +96,9 @@ void BrookRemoveCMMotionKernel::initialize( const System& system, const CMMotion ...@@ -96,7 +96,9 @@ void BrookRemoveCMMotionKernel::initialize( const System& system, const CMMotion
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// static const std::string methodName = "BrookRemoveCMMotionKernel::initialize"; static const std::string methodName = "BrookRemoveCMMotionKernel::initialize";
static const int PrintOn = 0;
FILE* log = getLog();
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -110,6 +112,11 @@ void BrookRemoveCMMotionKernel::initialize( const System& system, const CMMotion ...@@ -110,6 +112,11 @@ void BrookRemoveCMMotionKernel::initialize( const System& system, const CMMotion
_brookVelocityCenterOfMassRemoval = new BrookVelocityCenterOfMassRemoval(); _brookVelocityCenterOfMassRemoval = new BrookVelocityCenterOfMassRemoval();
_brookVelocityCenterOfMassRemoval->setup( masses, getPlatform() ); _brookVelocityCenterOfMassRemoval->setup( masses, getPlatform() );
if( PrintOn && log ){
(void) fprintf( log, "%s\n", methodName.c_str() );
(void) fflush( log );
}
return; return;
} }
...@@ -162,7 +169,7 @@ void BrookRemoveCMMotionKernel::execute( OpenMMContextImpl& context ){ ...@@ -162,7 +169,7 @@ void BrookRemoveCMMotionKernel::execute( OpenMMContextImpl& context ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// static const std::string methodName = "BrookRemoveCMMotionKernel::execute"; static const std::string methodName = "BrookRemoveCMMotionKernel::execute";
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
......
platforms/brook/src/BrookVerletDynamics.cpp
View file @ adb4ec5a
...@@ -140,7 +140,7 @@ int BrookVerletDynamics::updateParameters( double stepSize ){ ...@@ -140,7 +140,7 @@ int BrookVerletDynamics::updateParameters( double stepSize ){
static int showUpdate = 1; static int showUpdate = 1;
static int maxShowUpdate = 3; static int maxShowUpdate = 3;
static const std::string methodName = "\nBrookVerletDynamics::updateParameters"; static const std::string methodName = "BrookVerletDynamics::updateParameters";
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -151,7 +151,7 @@ int BrookVerletDynamics::updateParameters( double stepSize ){ ...@@ -151,7 +151,7 @@ int BrookVerletDynamics::updateParameters( double stepSize ){
if( showUpdate && getLog() && (showUpdate++ < maxShowUpdate) ){ if( showUpdate && getLog() && (showUpdate++ < maxShowUpdate) ){
std::string contents = getContentsString( ); std::string contents = getContentsString( );
(void) fprintf( getLog(), "%s contents\n%s", methodName, contents.c_str() ); (void) fprintf( getLog(), "%s contents\n%s", methodName.c_str(), contents.c_str() );
(void) fflush( getLog() ); (void) fflush( getLog() );
} }
...@@ -160,215 +160,6 @@ int BrookVerletDynamics::updateParameters( double stepSize ){ ...@@ -160,215 +160,6 @@ int BrookVerletDynamics::updateParameters( double stepSize ){
} }
/**
* Update
*
* @param positions particle positions
* @param velocities particle velocities
* @param forces particle forces
* @param brookShakeAlgorithm BrookShakeAlgorithm reference
*
* @return DefaultReturnValue
*
*/
int BrookVerletDynamics::update( BrookStreamImpl& positionStream, BrookStreamImpl& velocityStream,
const BrookStreamImpl& forceStreamC,
BrookShakeAlgorithm& brookShakeAlgorithm ){
// ---------------------------------------------------------------------------------------
static std::string methodName = "\nBrookVerletDynamics::update";
static const int PrintOn = 0;
// ---------------------------------------------------------------------------------------
BrookStreamImpl& forceStream = const_cast<BrookStreamImpl&> (forceStreamC);
if( (1 || PrintOn) && getLog() ){
static int showAux = 1;
if( showAux ){
showAux = 0;
/*
std::string contents = _brookVelocityCenterOfMassRemoval->getContentsString( );
(void) fprintf( getLog(), "%s VelocityCenterOfMassRemoval contents\n%s", methodName, contents.c_str() );
*/
(void) fprintf( getLog(), "%s Shake contents\n%s", methodName, brookShakeAlgorithm.getContentsString().c_str() );
(void) fflush( getLog() );
}
}
// To Shake or not to Shake
if( brookShakeAlgorithm.getNumberOfConstraints() > 0 ){
// integration step
kupdate_md1( (float) getStepSize(),
positionStream.getBrookStream(),
velocityStream.getBrookStream(),
forceStream.getBrookStream(),
getInverseMassStream()->getBrookStream(),
getXPrimeStream()->getBrookStream()
);
// diagnostics
if( PrintOn && getLog() ){
(void) fprintf( getLog(), "\n%s Post kupdate_md_verlet: particleStrW=%3d step=%.5f",
methodName.c_str(), getVerletDynamicsParticleStreamWidth(), getStepSize() );
(void) fprintf( getLog(), "\nInverseMassStream\n" );
getInverseMassStream()->printToFile( getLog() );
BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nPositionStream\n" );
brookStreamInternalPos->printToFile( getLog() );
(void) fprintf( getLog(), "\nForceStream\n" );
BrookStreamInternal* brookStreamInternalF = forceStream.getBrookStreamImpl();
brookStreamInternalF->printToFile( getLog() );
BrookStreamInternal* brookStreamInternalV = velocityStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nVelocityStream\n" );
brookStreamInternalV->printToFile( getLog() );
(void) fprintf( getLog(), "\nXPrimeStream\n" );
getXPrimeStream()->printToFile( getLog() );
}
kshakeh_fix1(
(float) brookShakeAlgorithm.getMaxIterations(),
(float) getVerletDynamicsParticleStreamWidth(),
brookShakeAlgorithm.getShakeTolerance(),
brookShakeAlgorithm.getShakeParticleIndicesStream()->getBrookStream(),
positionStream.getBrookStream(),
getXPrimeStream()->getBrookStream(),
brookShakeAlgorithm.getShakeParticleParameterStream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons0Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons1Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons2Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons3Stream()->getBrookStream() );
if( (1|| PrintOn) && getLog() ){
(void) fprintf( getLog(), "\n%s Post kshakeh_fix1: particleStrW=%3d", methodName.c_str(), getVerletDynamicsParticleStreamWidth() );
(void) fprintf( getLog(), "\nShakeParticleIndicesStream\n" );
brookShakeAlgorithm.getShakeParticleIndicesStream()->printToFile( getLog() );
BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nPositionStream\n" );
brookStreamInternalPos->printToFile( getLog() );
(void) fprintf( getLog(), "\nXPrimeStream\n" );
getXPrimeStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeParticleParameterStream\n" );
brookShakeAlgorithm.getShakeParticleParameterStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons0\n" );
brookShakeAlgorithm.getShakeXCons0Stream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons1\n" );
brookShakeAlgorithm.getShakeXCons1Stream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons2\n" );
brookShakeAlgorithm.getShakeXCons2Stream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons3\n" );
brookShakeAlgorithm.getShakeXCons3Stream()->printToFile( getLog() );
}
// second Shake gather
kshakeh_update2_fix1(
(float) getVerletDynamicsParticleStreamWidth(),
brookShakeAlgorithm.getShakeInverseMapStream()->getBrookStream(),
positionStream.getBrookStream(),
getXPrimeStream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons0Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons1Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons2Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons3Stream()->getBrookStream(),
positionStream.getBrookStream() );
if( ( 1 || PrintOn) && getLog() ){
(void) fprintf( getLog(), "\n%s Post kshakeh_update2_fix1: particleStrW=%3d",
methodName.c_str(), getVerletDynamicsParticleStreamWidth() );
(void) fprintf( getLog(), "\nShakeInverseMapStream\n" );
brookShakeAlgorithm.getShakeInverseMapStream()->printToFile( getLog() );
BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nPositionStream\n" );
brookStreamInternalPos->printToFile( getLog() );
(void) fprintf( getLog(), "\nXPrimeStream\n" );
getXPrimeStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons0\n" );
brookShakeAlgorithm.getShakeXCons0Stream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons1\n" );
brookShakeAlgorithm.getShakeXCons1Stream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons2\n" );
brookShakeAlgorithm.getShakeXCons2Stream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons3\n" );
brookShakeAlgorithm.getShakeXCons3Stream()->printToFile( getLog() );
}
// second integration step
float inverseStepSize = 1.0f/getStepSize();
kupdate_md2( inverseStepSize,
getXPrimeStream()->getBrookStream(),
positionStream.getBrookStream(),
velocityStream.getBrookStream(),
positionStream.getBrookStream() );
if( ( 1 || PrintOn) && getLog() ){
(void) fprintf( getLog(), "\n%s Post kupdate_md2: inverseStepSize=%3e",
methodName.c_str(), inverseStepSize );
BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nPositionStream\n" );
brookStreamInternalPos->printToFile( getLog() );
(void) fprintf( getLog(), "\nXPrimeStream\n" );
getXPrimeStream()->printToFile( getLog() );
brookStreamInternalPos = velocityStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nVelocityStream\n" );
brookStreamInternalPos->printToFile( getLog() );
}
} else {
kupdateMdNoShake( getStepSize(),
positionStream.getBrookStream(),
velocityStream.getBrookStream(),
forceStream.getBrookStream(),
getInverseMassStream()->getBrookStream(),
velocityStream.getBrookStream(),
positionStream.getBrookStream() );
}
//_brookVelocityCenterOfMassRemoval->removeVelocityCenterOfMass( velocities );
return DefaultReturnValue;
};
/** /**
* Get Particle stream size * Get Particle stream size
* *
...@@ -656,3 +447,213 @@ std::string BrookVerletDynamics::getContentsString( int level ) const { ...@@ -656,3 +447,213 @@ std::string BrookVerletDynamics::getContentsString( int level ) const {
return message.str(); return message.str();
} }
/**
* Update
*
* @param positions particle positions
* @param velocities particle velocities
* @param forces particle forces
* @param brookShakeAlgorithm BrookShakeAlgorithm reference
*
* @return DefaultReturnValue
*
*/
int BrookVerletDynamics::update( BrookStreamImpl& positionStream, BrookStreamImpl& velocityStream,
const BrookStreamImpl& forceStreamC,
BrookShakeAlgorithm& brookShakeAlgorithm ){
// ---------------------------------------------------------------------------------------
static std::string methodName = "\nBrookVerletDynamics::update";
static const int PrintOn = 0;
// ---------------------------------------------------------------------------------------
BrookStreamImpl& forceStream = const_cast<BrookStreamImpl&> (forceStreamC);
if( (1 || PrintOn) && getLog() ){
static int showAux = 1;
if( showAux ){
showAux = 0;
/*
std::string contents = _brookVelocityCenterOfMassRemoval->getContentsString( );
(void) fprintf( getLog(), "%s VelocityCenterOfMassRemoval contents\n%s", methodName, contents.c_str() );
*/
(void) fprintf( getLog(), "%s Shake contents\n%s", methodName.c_str(), brookShakeAlgorithm.getContentsString().c_str() );
(void) fflush( getLog() );
}
}
// To Shake or not to Shake
if( brookShakeAlgorithm.getNumberOfConstraints() > 0 ){
// integration step
kupdate_md1( (float) getStepSize(),
positionStream.getBrookStream(),
velocityStream.getBrookStream(),
forceStream.getBrookStream(),
getInverseMassStream()->getBrookStream(),
getXPrimeStream()->getBrookStream()
);
// diagnostics
if( PrintOn && getLog() ){
(void) fprintf( getLog(), "\n%s Post kupdate_md1: particleStrW=%3d step=%.5f",
methodName.c_str(), getVerletDynamicsParticleStreamWidth(), getStepSize() );
(void) fprintf( getLog(), "\nInverseMassStream\n" );
getInverseMassStream()->printToFile( getLog() );
BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nPositionStream\n" );
brookStreamInternalPos->printToFile( getLog() );
(void) fprintf( getLog(), "\nForceStream\n" );
BrookStreamInternal* brookStreamInternalF = forceStream.getBrookStreamImpl();
brookStreamInternalF->printToFile( getLog() );
BrookStreamInternal* brookStreamInternalV = velocityStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nVelocityStream\n" );
brookStreamInternalV->printToFile( getLog() );
(void) fprintf( getLog(), "\nXPrimeStream\n" );
getXPrimeStream()->printToFile( getLog() );
}
// Shake
kshakeh_fix1(
(float) brookShakeAlgorithm.getMaxIterations(),
(float) getVerletDynamicsParticleStreamWidth(),
brookShakeAlgorithm.getShakeTolerance(),
brookShakeAlgorithm.getShakeParticleIndicesStream()->getBrookStream(),
positionStream.getBrookStream(),
getXPrimeStream()->getBrookStream(),
brookShakeAlgorithm.getShakeParticleParameterStream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons0Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons1Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons2Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons3Stream()->getBrookStream() );
if( (0|| PrintOn) && getLog() ){
(void) fprintf( getLog(), "\n%s Post kshakeh_fix1: particleStrW=%3d", methodName.c_str(), getVerletDynamicsParticleStreamWidth() );
(void) fprintf( getLog(), "\nShakeParticleIndicesStream\n" );
brookShakeAlgorithm.getShakeParticleIndicesStream()->printToFile( getLog() );
BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nPositionStream\n" );
brookStreamInternalPos->printToFile( getLog() );
(void) fprintf( getLog(), "\nXPrimeStream\n" );
getXPrimeStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeParticleParameterStream\n" );
brookShakeAlgorithm.getShakeParticleParameterStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons0\n" );
brookShakeAlgorithm.getShakeXCons0Stream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons1\n" );
brookShakeAlgorithm.getShakeXCons1Stream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons2\n" );
brookShakeAlgorithm.getShakeXCons2Stream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons3\n" );
brookShakeAlgorithm.getShakeXCons3Stream()->printToFile( getLog() );
}
// Shake gather
kshakeh_update1_fix1(
(float) getVerletDynamicsParticleStreamWidth(),
brookShakeAlgorithm.getShakeInverseMapStream()->getBrookStream(),
getXPrimeStream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons0Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons1Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons2Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons3Stream()->getBrookStream(),
getXPrimeStream()->getBrookStream() );
//positionStream.getBrookStream() );
if( ( 0 || PrintOn) && getLog() ){
(void) fprintf( getLog(), "\n%s Post kshakeh_update2_fix1: particleStrW=%3d",
methodName.c_str(), getVerletDynamicsParticleStreamWidth() );
(void) fprintf( getLog(), "\nShakeInverseMapStream\n" );
brookShakeAlgorithm.getShakeInverseMapStream()->printToFile( getLog() );
BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nPositionStream\n" );
brookStreamInternalPos->printToFile( getLog() );
(void) fprintf( getLog(), "\nXPrimeStream\n" );
getXPrimeStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons0\n" );
brookShakeAlgorithm.getShakeXCons0Stream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons1\n" );
brookShakeAlgorithm.getShakeXCons1Stream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons2\n" );
brookShakeAlgorithm.getShakeXCons2Stream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons3\n" );
brookShakeAlgorithm.getShakeXCons3Stream()->printToFile( getLog() );
}
// second integration step
float inverseStepSize = 1.0f/getStepSize();
kupdate_md2( inverseStepSize,
getXPrimeStream()->getBrookStream(),
positionStream.getBrookStream(),
velocityStream.getBrookStream(),
positionStream.getBrookStream() );
if( ( 0 || PrintOn) && getLog() ){
(void) fprintf( getLog(), "\n%s Post kupdate_md2: inverseStepSize=%3e",
methodName.c_str(), inverseStepSize );
BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nPositionStream\n" );
brookStreamInternalPos->printToFile( getLog() );
(void) fprintf( getLog(), "\nXPrimeStream\n" );
getXPrimeStream()->printToFile( getLog() );
brookStreamInternalPos = velocityStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nVelocityStream\n" );
brookStreamInternalPos->printToFile( getLog() );
}
} else {
kupdateMdNoShake( getStepSize(),
positionStream.getBrookStream(),
velocityStream.getBrookStream(),
forceStream.getBrookStream(),
getInverseMassStream()->getBrookStream(),
velocityStream.getBrookStream(),
positionStream.getBrookStream() );
}
//_brookVelocityCenterOfMassRemoval->removeVelocityCenterOfMass( velocities );
return DefaultReturnValue;
}
platforms/brook/src/gpu/kcommon.br
View file @ adb4ec5a
...@@ -30,31 +30,29 @@ ...@@ -30,31 +30,29 @@
* USE OR OTHER DEALINGS IN THE SOFTWARE. * * USE OR OTHER DEALINGS IN THE SOFTWARE. *
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
//Inverse of above kernel void kgetxyz( float4 instr<>, out float3 outstr<> ){
kernel void kgetxyz( float4 instr<>, out float3 outstr<> ) {
outstr = instr.xyz; outstr = instr.xyz;
} }
//Zeroes out a stream //Zeroes out a stream
kernel void kzerof3( out float3 outstr<> ) { kernel void kzerof3( out float3 outstr<> ){
outstr = float3( 0.0f, 0.0f, 0.0f ); outstr = float3( 0.0f, 0.0f, 0.0f );
} }
//Zeros out a stream //Zeros out a stream
kernel void kzerof4( out float4 outstr<> ) { kernel void kzerof4( out float4 outstr<> ){
outstr = float4( 0.0f, 0.0f, 0.0f, 0.0f ); outstr = float4( 0.0f, 0.0f, 0.0f, 0.0f );
} }
kernel void ksetf4( float4 val, out float4 outstr<> ) { kernel void ksetf4( float4 val, out float4 outstr<> ){
outstr = val; outstr = val;
} }
kernel void ksetStr3( float3 instr<>, out float3 outstr<> ) { kernel void ksetStr3( float3 instr<>, out float3 outstr<> ){
outstr = instr; outstr = instr;
} }
kernel void kadd3( float3 val<>, out float3 outstr<> ) { kernel void kadd3( float3 in1<>, float3 in2<>, out float3 outstr<> ){
outstr += val; outstr = in1 + in2;
} }
platforms/brook/src/gpu/kcommon.h
View file @ adb4ec5a
...@@ -33,15 +33,14 @@ ...@@ -33,15 +33,14 @@
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
void kgetxyz (::brook::stream instr, void kgetxyz(::brook::stream instr, ::brook::stream outstr);
::brook::stream outstr);
void kzerof3 (::brook::stream outstr); void kzerof3(::brook::stream outstr);
void kzerof4 (::brook::stream outstr); void kzerof4(::brook::stream outstr);
void kzerof4 (::brook::stream outstr); void kzerof4(::brook::stream outstr);
void ksetf4 (const float4 val, ::brook::stream outstr); void ksetf4(const float4 val, ::brook::stream outstr);
void kadd3( ::brook::stream instr, ::brook::stream outstr ); void kadd3( ::brook::stream instr1, ::brook::stream instr2, ::brook::stream outstr );
void ksetStr3( ::brook::stream instr, ::brook::stream outstr ); void ksetStr3( ::brook::stream instr, ::brook::stream outstr );
#endif // __KCOMMON_H__ #endif // __KCOMMON_H__
platforms/brook/src/gpu/kshakeh.br
View file @ adb4ec5a
...@@ -145,7 +145,7 @@ kshakeh_fix1( ...@@ -145,7 +145,7 @@ kshakeh_fix1(
acor = ( ld1 - 2 * rrpr - rpsqij ) * params.y / ( rrpr + rij1sq ) ; acor = ( ld1 - 2 * rrpr - rpsqij ) * params.y / ( rrpr + rij1sq ) ;
diff = abs( ld1 - 2 * rrpr - rpsqij ) / (params.z * tolerance ); diff = abs( ld1 - 2 * rrpr - rpsqij ) / (params.z * tolerance );
acor = (diff < 1.0f) ? 0.0f : acor; acor = (diff < 1.0f) ? 0.0f : acor;
converged = acor; converged = abs( acor );
dr = rij1 * acor; dr = rij1 * acor;
xpi += dr * params.x; xpi += dr * params.x;
...@@ -160,7 +160,7 @@ kshakeh_fix1( ...@@ -160,7 +160,7 @@ kshakeh_fix1(
diff = abs( ld2 - 2.0f * rrpr - rpsqij ) / (params.z * tolerance ); diff = abs( ld2 - 2.0f * rrpr - rpsqij ) / (params.z * tolerance );
acor = mask2 * ( ld2 - 2.0f * rrpr - rpsqij ) * params.y / ( rrpr + rij2sq ) ; acor = mask2 * ( ld2 - 2.0f * rrpr - rpsqij ) * params.y / ( rrpr + rij2sq ) ;
acor = (diff < 1.0f) ? 0.0f : acor; acor = (diff < 1.0f) ? 0.0f : acor;
converged += acor; converged += abs( acor );
dr = rij2 * acor; dr = rij2 * acor;
xpi += dr * params.x; xpi += dr * params.x;
...@@ -174,7 +174,7 @@ kshakeh_fix1( ...@@ -174,7 +174,7 @@ kshakeh_fix1(
diff = abs( ld3 - 2.0f * rrpr - rpsqij ) / (params.z * tolerance ); diff = abs( ld3 - 2.0f * rrpr - rpsqij ) / (params.z * tolerance );
acor = mask3 * ( ld3 - 2.0f * rrpr - rpsqij ) * params.y / ( rrpr + rij3sq ) ; acor = mask3 * ( ld3 - 2.0f * rrpr - rpsqij ) * params.y / ( rrpr + rij3sq ) ;
acor = (diff < 1.0f) ? 0.0f : acor; acor = (diff < 1.0f) ? 0.0f : acor;
converged += acor; converged += abs( acor );
dr = rij3 * acor; dr = rij3 * acor;
xpi += dr * params.x; xpi += dr * params.x;
...@@ -195,7 +195,6 @@ kshakeh_fix1( ...@@ -195,7 +195,6 @@ kshakeh_fix1(
kernel void kshakeh_update1_fix1( kernel void kshakeh_update1_fix1(
float strwidth, //width of cposq streams float strwidth, //width of cposq streams
float2 invmap<>, //shakeh inverse map float2 invmap<>, //shakeh inverse map
float3 posq<>, //old positions
float3 posqp<>, //deltas from sd2 float3 posqp<>, //deltas from sd2
float3 cposq0[][], //constrained delta for heavy atom float3 cposq0[][], //constrained delta for heavy atom
float3 cposq1[][], //ditto for h1 float3 cposq1[][], //ditto for h1
......
platforms/brook/src/gpu/kshakeh.h
View file @ adb4ec5a
...@@ -45,7 +45,6 @@ void kshakeh_fix1 ( ...@@ -45,7 +45,6 @@ void kshakeh_fix1 (
void kshakeh_update1_fix1 ( void kshakeh_update1_fix1 (
const float strwidth, const float strwidth,
::brook::stream invmap, ::brook::stream invmap,
::brook::stream posq,
::brook::stream posqp, ::brook::stream posqp,
::brook::stream cposq0, ::brook::stream cposq0,
::brook::stream cposq1, ::brook::stream cposq1,
......
platforms/brook/src/gpu/kupdatemd.br
View file @ adb4ec5a
...@@ -48,8 +48,8 @@ kernel void kupdate_md2( ...@@ -48,8 +48,8 @@ kernel void kupdate_md2(
out float3 vnew<>, //Corrected velocities out float3 vnew<>, //Corrected velocities
out float3 posqnew<> //equal to posqp, avoids an extra call to copy out float3 posqnew<> //equal to posqp, avoids an extra call to copy
){ ){
posqnew = posq + posqp;
vnew = posqp * dtinv; vnew = posqp * dtinv;
posqnew = posq + posqp;
} }
kernel void kupdateMdNoShake( kernel void kupdateMdNoShake(
...@@ -64,4 +64,3 @@ kernel void kupdateMdNoShake( ...@@ -64,4 +64,3 @@ kernel void kupdateMdNoShake(
outv = v + dt*invmass*f; outv = v + dt*invmass*f;
posqp += dt*outv; posqp += dt*outv;
} }
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