Skip to content

GitLab

Commit 309008f7 authored by Mark Friedrichs's avatar Mark Friedrichs
Browse files

Mods

parent cdee990d
Hide whitespace changes
Inline Side-by-side
Showing with 1857 additions and 1481 deletions
platforms/brook/src/BrookNonBonded.cpp
View file @ 309008f7
......@@ -53,7 +53,7 @@ BrookNonBonded::BrookNonBonded( ){
// ---------------------------------------------------------------------------------------
_atomSizeCeiling = -1;
_particleSizeCeiling = -1;
_outerUnroll = 4;
_innerUnroll = 4;
......@@ -149,37 +149,37 @@ int BrookNonBonded::getOuterLoopUnroll( void ) const {
int BrookNonBonded::setOuterLoopUnroll( int outerUnroll ){
if( outerUnroll != _outerUnroll ){
_atomSizeCeiling = -1;
_particleSizeCeiling = -1;
}
_outerUnroll = _outerUnroll;
return _outerUnroll;
}
/**
* Get atom ceiling parameter
* Get particle ceiling parameter
*
* @return atom ceiling parameter
* @return particle ceiling parameter
*
*/
int BrookNonBonded::getAtomSizeCeiling( void ) const {
int BrookNonBonded::getParticleSizeCeiling( void ) const {
// ---------------------------------------------------------------------------------------
//static const std::string methodName = "BrookNonBonded::getAtomSizeCeiling";
//static const std::string methodName = "BrookNonBonded::getParticleSizeCeiling";
// ---------------------------------------------------------------------------------------
if( _atomSizeCeiling < 0 ){
if( _particleSizeCeiling < 0 ){
BrookNonBonded* localThis = const_cast<BrookNonBonded* const>(this);
localThis->_atomSizeCeiling = localThis->getNumberOfAtoms() % localThis->getOuterLoopUnroll();
if( localThis->_atomSizeCeiling ){
localThis->_atomSizeCeiling = localThis->getOuterLoopUnroll() - localThis->_atomSizeCeiling;
localThis->_particleSizeCeiling = localThis->getNumberOfParticles() % localThis->getOuterLoopUnroll();
if( localThis->_particleSizeCeiling ){
localThis->_particleSizeCeiling = localThis->getOuterLoopUnroll() - localThis->_particleSizeCeiling;
}
localThis->_atomSizeCeiling += localThis->getNumberOfAtoms();
localThis->_particleSizeCeiling += localThis->getNumberOfParticles();
}
return _atomSizeCeiling;
return _particleSizeCeiling;
}
/**
......@@ -465,14 +465,14 @@ int BrookNonBonded::isForceStreamSet( int index ) const {
/**
* Initialize stream dimensions
*
* @param numberOfAtoms number of atoms
* @param numberOfParticles number of particles
* @param platform platform
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
*/
int BrookNonBonded::_initializeStreamSizes( int numberOfAtoms, const Platform& platform ){
int BrookNonBonded::_initializeStreamSizes( int numberOfParticles, const Platform& platform ){
// ---------------------------------------------------------------------------------------
......@@ -481,13 +481,13 @@ int BrookNonBonded::_initializeStreamSizes( int numberOfAtoms, const Platform& p
// ---------------------------------------------------------------------------------------
int atomStreamSize = getAtomStreamSize( platform );
int atomStreamWidth = getAtomStreamWidth( platform );
int particleStreamSize = getParticleStreamSize( platform );
int particleStreamWidth = getParticleStreamWidth( platform );
_initializeExclusionStreamSize( atomStreamSize, atomStreamWidth );
_initializeJStreamSize( atomStreamSize, atomStreamWidth );
_initializeOuterVdwStreamSize( atomStreamSize, atomStreamWidth );
_initializePartialForceStreamSize( atomStreamSize, atomStreamWidth );
_initializeExclusionStreamSize( particleStreamSize, particleStreamWidth );
_initializeJStreamSize( particleStreamSize, particleStreamWidth );
_initializeOuterVdwStreamSize( particleStreamSize, particleStreamWidth );
_initializePartialForceStreamSize( particleStreamSize, particleStreamWidth );
return DefaultReturnValue;
}
......@@ -521,8 +521,8 @@ int BrookNonBonded::_initializeStreams( const Platform& platform ){
// outer vdw
_nonbondedStreams[OuterVdwStream] = new BrookFloatStreamInternal( BrookCommon::OuterVdwStream, getAtomStreamSize(),
getAtomStreamWidth(), BrookStreamInternal::Float2, dangleValue );
_nonbondedStreams[OuterVdwStream] = new BrookFloatStreamInternal( BrookCommon::OuterVdwStream, getParticleStreamSize(),
getParticleStreamWidth(), BrookStreamInternal::Float2, dangleValue );
// inner sigma & epsilon
......@@ -534,8 +534,8 @@ int BrookNonBonded::_initializeStreams( const Platform& platform ){
// charge stream
_nonbondedStreams[ChargeStream] = new BrookFloatStreamInternal( BrookCommon::NonBondedChargeStream, getAtomStreamSize(),
getAtomStreamWidth(), BrookStreamInternal::Float, dangleValue );
_nonbondedStreams[ChargeStream] = new BrookFloatStreamInternal( BrookCommon::NonBondedChargeStream, getParticleStreamSize(),
getParticleStreamWidth(), BrookStreamInternal::Float, dangleValue );
// partial force streams
......@@ -554,8 +554,8 @@ int BrookNonBonded::_initializeStreams( const Platform& platform ){
/**
* Set exclusion (4x4)
*
* @param i atom i index
* @param j atom j index
* @param i particle i index
* @param j particle j index
* @param exclusionStreamWidth exclusion stream width
* @param exclusion array of packed exclusions
*
......@@ -603,7 +603,7 @@ int BrookNonBonded::_setExclusion( int i, int j, int exclusionStreamWidth, Brook
/**
* Initialize exclusions
*
* @param exclusions vector of sets containing exclusions (1 set entry for every atom)
* @param exclusions vector of sets containing exclusions (1 set entry for every particle)
* @param platform Brook platform
* @param log optional Log file reference
*
......@@ -642,17 +642,17 @@ int BrookNonBonded::_initializeExclusions( const std::vector<std::set<int> >& ex
// pack in values
int exclusionStreamWidth = getExclusionStreamWidth();
int numberOfAtoms = getNumberOfAtoms();
int atomStreamSize = getAtomStreamSize();
int numberOfParticles = getNumberOfParticles();
int particleStreamSize = getParticleStreamSize();
for( unsigned int ii = 0; ii < exclusionsVector.size(); ii++ ){
set<int> exclusionIndices = exclusionsVector[ii];
//(void) fprintf( getLog(), "%s atoms=%d excludeSz=%d\n", methodName.c_str(), ii, exclusionIndices.size() );
//(void) fprintf( getLog(), "%s particles=%d excludeSz=%d\n", methodName.c_str(), ii, exclusionIndices.size() );
int hitII = 0;
for( set<int>::const_iterator jj = exclusionIndices.begin(); jj != exclusionIndices.end(); jj++ ){
//(void) fprintf( getLog(), "%s atoms=%d exclude=%d\n", methodName.c_str(), ii, *jj );
//(void) fprintf( getLog(), "%s particles=%d exclude=%d\n", methodName.c_str(), ii, *jj );
_setExclusion( ii, *jj, exclusionStreamWidth, exclusions );
if( *jj == ii )hitII = 1;
}
......@@ -660,16 +660,16 @@ int BrookNonBonded::_initializeExclusions( const std::vector<std::set<int> >& ex
_setExclusion( ii, ii, exclusionStreamWidth, exclusions );
}
// explicitly exclude junk atoms from interacting w/ atom ii
for( int jj = numberOfAtoms; jj < atomStreamSize; jj++ ){
// explicitly exclude junk particles from interacting w/ particle ii
for( int jj = numberOfParticles; jj < particleStreamSize; jj++ ){
_setExclusion( ii, jj, exclusionStreamWidth, exclusions );
}
}
// explicitly exclude junk atoms from interacting w/ all atoms
// explicitly exclude junk particles from interacting w/ all particles
for( int ii = numberOfAtoms; ii < atomStreamSize; ii++ ){
for( int jj = 0; jj < atomStreamSize; jj++ ){
for( int ii = numberOfParticles; ii < particleStreamSize; ii++ ){
for( int jj = 0; jj < particleStreamSize; jj++ ){
_setExclusion( ii, jj, exclusionStreamWidth, exclusions );
}
}
......@@ -678,8 +678,8 @@ int BrookNonBonded::_initializeExclusions( const std::vector<std::set<int> >& ex
if( 1 && debug && getLog() ){
FILE* log = getLog();
(void) fprintf( log, "%s atoms=%d excl=%d exStrSz=%d w=%d atmStrSz=%d\n", methodName.c_str(), numberOfAtoms, exclusionsVector.size(),
exclusionStreamSize, exclusionStreamWidth, atomStreamSize );
(void) fprintf( log, "%s particles=%d excl=%d exStrSz=%d w=%d atmStrSz=%d\n", methodName.c_str(), numberOfParticles, exclusionsVector.size(),
exclusionStreamSize, exclusionStreamWidth, particleStreamSize );
/*
for( int ii = 0; ii < exclusionStreamSize; ii++ ){
int index = ii/exclusionStreamWidth;
......@@ -688,17 +688,17 @@ int offset = ii - index*exclusionStreamWidth;
}
*/
for( int ii = 0; ii < numberOfAtoms; ii++ ){
for( int ii = 0; ii < numberOfParticles; ii++ ){
(void) fprintf( log, "%6d ", ii );
int count = 0;
for( int jj = 0; jj <= numberOfAtoms/4; jj++ ){
for( int jj = 0; jj <= numberOfParticles/4; jj++ ){
int index = jj*exclusionStreamWidth + ii;
(void) fprintf( log, " [%4d %4d] %5.1f", jj*4, jj*4+3, exclusions[index] );
int excludeValue = (int) (exclusions[index] + 0.01);
if( (excludeValue % 2) )count++;
if( (jj*4+1) < numberOfAtoms && (excludeValue % 3) )count++;
if( (jj*4+2) < numberOfAtoms && (excludeValue % 5) )count++;
if( (jj*4+3) < numberOfAtoms && (excludeValue % 7) )count++;
if( (jj*4+1) < numberOfParticles && (excludeValue % 3) )count++;
if( (jj*4+2) < numberOfParticles && (excludeValue % 5) )count++;
if( (jj*4+3) < numberOfParticles && (excludeValue % 7) )count++;
}
(void) fprintf( log, " TtlExcl=%d\n", count );
}
......@@ -750,7 +750,7 @@ int BrookNonBonded::_setSigmaEpsilon( double c6, double c12, double* sigma , dou
/**
* Initialize vdw & charge
*
* @param exclusions vector of sets containing exclusions (1 set entry for every atom)
* @param exclusions vector of sets containing exclusions (1 set entry for every particle)
* @param platform platform
*
* @return ErrorReturnValue if error, else DefaultReturnValue
......@@ -770,22 +770,22 @@ int BrookNonBonded::_initializeVdwAndCharge( const vector<vector<double> >& nonb
(void) fprintf( getLog(), "%s nonbonded vector size=%d\n", methodName.c_str(), nonbondedParameters.size() );
}
int atomStreamSize = getAtomStreamSize();
int particleStreamSize = getParticleStreamSize();
// allocate and initialize vdw & charge array
unsigned int vdwParametersSize = 2*atomStreamSize;
unsigned int vdwParametersSize = 2*particleStreamSize;
BrookOpenMMFloat* vdwParameters = new BrookOpenMMFloat[vdwParametersSize];
memset( vdwParameters, 0, sizeof( BrookOpenMMFloat )*vdwParametersSize );
BrookOpenMMFloat* charges = new BrookOpenMMFloat[atomStreamSize];
memset( charges, 0, sizeof( BrookOpenMMFloat )*atomStreamSize );
BrookOpenMMFloat* charges = new BrookOpenMMFloat[particleStreamSize];
memset( charges, 0, sizeof( BrookOpenMMFloat )*particleStreamSize );
// ---------------------------------------------------------------------------------------
// pack in values
int numberOfAtoms = getNumberOfAtoms();
int numberOfParticles = getNumberOfParticles();
int trackingIndex = 0;
double sigma, epsilon;
for( unsigned int ii = 0; ii < nonbondedParameters.size(); ii++ ){
......@@ -813,9 +813,9 @@ int BrookNonBonded::_initializeVdwAndCharge( const vector<vector<double> >& nonb
}
// set outlier atoms
// set outlier particles
for( unsigned int ii = nonbondedParameters.size(); ii < (unsigned int) atomStreamSize; ii++ ){
for( unsigned int ii = nonbondedParameters.size(); ii < (unsigned int) particleStreamSize; ii++ ){
vdwParameters[trackingIndex++] = (BrookOpenMMFloat) 1.0;
vdwParameters[trackingIndex++] = (BrookOpenMMFloat) 0.0;
}
......@@ -832,8 +832,8 @@ int BrookNonBonded::_initializeVdwAndCharge( const vector<vector<double> >& nonb
if( 1 && debug && getLog() ){
FILE* log = getLog();
int trackingIndex = 0;
(void) fprintf( log, "%s atoms=%d strSz=%d\n vdw[Sig Eps] Q\n", methodName.c_str(), numberOfAtoms, atomStreamSize );
for( int ii = 0; ii < atomStreamSize; ii++, trackingIndex += 2 ){
(void) fprintf( log, "%s particles=%d strSz=%d\n vdw[Sig Eps] Q\n", methodName.c_str(), numberOfParticles, particleStreamSize );
for( int ii = 0; ii < particleStreamSize; ii++, trackingIndex += 2 ){
(void) fprintf( log, " %d %10.3f %10.3f %10.3f\n", ii, vdwParameters[trackingIndex], vdwParameters[trackingIndex+1], charges[ii] );
}
(void) fflush( log );
......@@ -849,7 +849,7 @@ int BrookNonBonded::_initializeVdwAndCharge( const vector<vector<double> >& nonb
/**
* Initialize vdw & charge
*
* @param exclusions vector of sets containing exclusions (1 set entry for every atom)
* @param exclusions vector of sets containing exclusions (1 set entry for every particle)
* @param platform platform
*
* @return ErrorReturnValue if error, else DefaultReturnValue
......@@ -885,7 +885,7 @@ int BrookNonBonded::_initializeJStreamVdw( const vector<vector<double> >& nonbon
// pack in values
int numberOfAtoms = getNumberOfAtoms();
int numberOfParticles = getNumberOfParticles();
int trackingIndex = 0;
double sigma, epsilon;
for( unsigned int ii = 0; ii < nonbondedParameters.size(); ii++ ){
......@@ -908,7 +908,7 @@ int BrookNonBonded::_initializeJStreamVdw( const vector<vector<double> >& nonbon
}
// set outlier atoms
// set outlier particles
for( unsigned int ii = nonbondedParameters.size(); ii < (unsigned int) jParametersSize; ii++ ){
sigmaParameters[ii] = (BrookOpenMMFloat) 1.0;
......@@ -927,7 +927,7 @@ int BrookNonBonded::_initializeJStreamVdw( const vector<vector<double> >& nonbon
if( 1 && debug && getLog() ){
FILE* log = getLog();
int trackingIndex = 0;
(void) fprintf( log, "%s atoms=%d strSz=%d\n Innervdw[Sig Eps]\n", methodName.c_str(), numberOfAtoms, jStreamSize );
(void) fprintf( log, "%s particles=%d strSz=%d\n Innervdw[Sig Eps]\n", methodName.c_str(), numberOfParticles, jStreamSize );
for( unsigned int ii = 0; ii < jParametersSize; ii++ ){
(void) fprintf( log, " %d %10.3f %10.3f\n", ii, sigmaParameters[ii], epsilonParameters[ii] );
}
......@@ -943,17 +943,17 @@ int BrookNonBonded::_initializeJStreamVdw( const vector<vector<double> >& nonbon
/*
* Setup of nonbonded ixns
*
* @param numberOfAtoms number of atoms
* @param nonbondedParameters vector of nonbonded parameters [atomI][0=c6]
* [atomI][1=c12]
* [atomI][2=charge]
* @param numberOfParticles number of particles
* @param nonbondedParameters vector of nonbonded parameters [particleI][0=c6]
* [particleI][1=c12]
* [particleI][2=charge]
* @param platform Brook platform
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
* */
int BrookNonBonded::setup( int numberOfAtoms, const std::vector<std::vector<double> >& nonbondedParameters,
int BrookNonBonded::setup( int numberOfParticles, const std::vector<std::vector<double> >& nonbondedParameters,
const std::vector<std::set<int> >& exclusions, const Platform& platform ){
// ---------------------------------------------------------------------------------------
......@@ -963,9 +963,9 @@ int BrookNonBonded::setup( int numberOfAtoms, const std::vector<std::vector<doub
// ---------------------------------------------------------------------------------------
setNumberOfAtoms( numberOfAtoms );
setNumberOfParticles( numberOfParticles );
_initializeStreamSizes( numberOfAtoms, platform );
_initializeStreamSizes( numberOfParticles, platform );
_initializeStreams( platform );
_initializeExclusions( exclusions, platform );
......@@ -978,14 +978,14 @@ int BrookNonBonded::setup( int numberOfAtoms, const std::vector<std::vector<doub
/*
* Setup of stream dimensions for exclusion stream
*
* @param atomStreamSize atom stream size
* @param atomStreamWidth atom stream width
* @param particleStreamSize particle stream size
* @param particleStreamWidth particle stream width
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
* */
int BrookNonBonded::_initializeExclusionStreamSize( int atomStreamSize, int atomStreamWidth ){
int BrookNonBonded::_initializeExclusionStreamSize( int particleStreamSize, int particleStreamWidth ){
// ---------------------------------------------------------------------------------------
......@@ -994,7 +994,7 @@ int BrookNonBonded::_initializeExclusionStreamSize( int atomStreamSize, int atom
// ---------------------------------------------------------------------------------------
_exclusionStreamWidth = atomStreamSize;
_exclusionStreamWidth = particleStreamSize;
int innerUnroll = getInnerLoopUnroll();
if( innerUnroll < 1 ){
std::stringstream message;
......@@ -1012,8 +1012,8 @@ int BrookNonBonded::_initializeExclusionStreamSize( int atomStreamSize, int atom
/*
* Setup of j-stream dimensions
*
* @param atomStreamSize atom stream size
* @param atomStreamWidth atom stream width
* @param particleStreamSize particle stream size
* @param particleStreamWidth particle stream width
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
......@@ -1021,7 +1021,7 @@ int BrookNonBonded::_initializeExclusionStreamSize( int atomStreamSize, int atom
*
* */
int BrookNonBonded::_initializeJStreamSize( int atomStreamSize, int atomStreamWidth ){
int BrookNonBonded::_initializeJStreamSize( int particleStreamSize, int particleStreamWidth ){
// ---------------------------------------------------------------------------------------
......@@ -1049,7 +1049,7 @@ int BrookNonBonded::_initializeJStreamSize( int atomStreamSize, int atomStreamWi
// set dimesnions
_jStreamSize = atomStreamSize/innerUnroll;
_jStreamSize = particleStreamSize/innerUnroll;
_jStreamHeight = _jStreamSize/jStreamWidth;
_jStreamHeight += ( (_jStreamSize % _jStreamWidth) ? 1 : 0 );
_jStreamSize = jStreamWidth*_jStreamHeight;
......@@ -1060,8 +1060,8 @@ int BrookNonBonded::_initializeJStreamSize( int atomStreamSize, int atomStreamWi
/*
* Setup of outer vdw stream size
*
* @param atomStreamSize atom stream size
* @param atomStreamWidth atom stream width
* @param particleStreamSize particle stream size
* @param particleStreamWidth particle stream width
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
......@@ -1069,7 +1069,7 @@ int BrookNonBonded::_initializeJStreamSize( int atomStreamSize, int atomStreamWi
*
* */
int BrookNonBonded::_initializeOuterVdwStreamSize( int atomStreamSize, int atomStreamWidth ){
int BrookNonBonded::_initializeOuterVdwStreamSize( int particleStreamSize, int particleStreamWidth ){
// ---------------------------------------------------------------------------------------
......@@ -1097,7 +1097,7 @@ int BrookNonBonded::_initializeOuterVdwStreamSize( int atomStreamSize, int atomS
// set dimesnions
_jStreamSize = atomStreamSize/innerUnroll;
_jStreamSize = particleStreamSize/innerUnroll;
_jStreamHeight = _jStreamSize/jStreamWidth;
_jStreamHeight += ( (_jStreamSize % _jStreamWidth) ? 1 : 0 );
_jStreamSize = jStreamWidth*_jStreamHeight;
......@@ -1109,14 +1109,14 @@ int BrookNonBonded::_initializeOuterVdwStreamSize( int atomStreamSize, int atomS
/*
* Setup of stream dimensions for partial force streams
*
* @param atomStreamSize atom stream size
* @param atomStreamWidth atom stream width
* @param particleStreamSize particle stream size
* @param particleStreamWidth particle stream width
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
* */
int BrookNonBonded::_initializePartialForceStreamSize( int atomStreamSize, int atomStreamWidth ){
int BrookNonBonded::_initializePartialForceStreamSize( int particleStreamSize, int particleStreamWidth ){
// ---------------------------------------------------------------------------------------
......@@ -1139,7 +1139,7 @@ int BrookNonBonded::_initializePartialForceStreamSize( int atomStreamSize, int a
return ErrorReturnValue;
}
_partialForceStreamSize = atomStreamSize*getDuplicationFactor()/innerUnroll;
_partialForceStreamSize = particleStreamSize*getDuplicationFactor()/innerUnroll;
_partialForceStreamHeight = _partialForceStreamSize/_partialForceStreamWidth;
_partialForceStreamHeight += ( (_partialForceStreamSize % _partialForceStreamWidth) ? 1 : 0);
......@@ -1177,8 +1177,8 @@ std::string BrookNonBonded::getContentsString( int level ) const {
#define LOCAL_SPRINTF(a,b,c) sprintf( (a), (b), (c) );
#endif
(void) LOCAL_SPRINTF( value, "%d", getNumberOfAtoms() );
message << _getLine( tab, "Number of atoms:", value );
(void) LOCAL_SPRINTF( value, "%d", getNumberOfParticles() );
message << _getLine( tab, "Number of particles:", value );
(void) LOCAL_SPRINTF( value, "%d", getNumberOfForceStreams() );
message << _getLine( tab, "Number of force streams:", value );
......@@ -1192,17 +1192,17 @@ std::string BrookNonBonded::getContentsString( int level ) const {
(void) LOCAL_SPRINTF( value, "%d", getOuterLoopUnroll() )
message << _getLine( tab, "Outer loop unroll:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomSizeCeiling() );
message << _getLine( tab, "Atom ceiling:", value );
(void) LOCAL_SPRINTF( value, "%d", getParticleSizeCeiling() );
message << _getLine( tab, "Particle ceiling:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamWidth() );
message << _getLine( tab, "Atom stream width:", value );
(void) LOCAL_SPRINTF( value, "%d", getParticleStreamWidth() );
message << _getLine( tab, "Particle stream width:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamHeight() );
message << _getLine( tab, "Atom stream height:", value );
(void) LOCAL_SPRINTF( value, "%d", getParticleStreamHeight() );
message << _getLine( tab, "Particle stream height:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamSize() );
message << _getLine( tab, "Atom stream size:", value );
(void) LOCAL_SPRINTF( value, "%d", getParticleStreamSize() );
message << _getLine( tab, "Particle stream size:", value );
(void) LOCAL_SPRINTF( value, "%d", getJStreamWidth() );
message << _getLine( tab, "J-stream width:", value );
......@@ -1264,3 +1264,123 @@ std::string BrookNonBonded::getContentsString( int level ) const {
return message.str();
}
/**
* Compute forces
*
* @param context OpenMMContextImpl context
*
*/
void BrookNonBonded::computeForces( BrookStreamImpl& positionStream, BrookStreamImpl& forceStream ){
// ---------------------------------------------------------------------------------------
static const std::string methodName = "BrookNonBonded::computeForces";
static const int PrintOn = 0;
static const int MaxErrorMessages = 2;
static int ErrorMessages = 0;
static const float4 dummyParameters( 0.0, 0.0, 0.0, 0.0 );
// static const int debug = 1;
// ---------------------------------------------------------------------------------------
// nonbonded forces
float epsfac = 138.935485f;
BrookFloatStreamInternal** nonbondedForceStreams = getForceStreams();
knbforce_CDLJ4(
(float) getNumberOfParticles(),
(float) getParticleSizeCeiling(),
(float) getDuplicationFactor(),
(float) getParticleStreamHeight( ),
(float) getParticleStreamWidth( ),
(float) getJStreamWidth( ),
(float) getPartialForceStreamWidth( ),
epsfac,
dummyParameters,
positionStream.getBrookStream(),
getChargeStream()->getBrookStream(),
getOuterVdwStream()->getBrookStream(),
getInnerSigmaStream()->getBrookStream(),
getInnerEpsilonStream()->getBrookStream(),
getExclusionStream()->getBrookStream(),
nonbondedForceStreams[0]->getBrookStream(),
nonbondedForceStreams[1]->getBrookStream(),
nonbondedForceStreams[2]->getBrookStream(),
nonbondedForceStreams[3]->getBrookStream()
);
/*
float zerof = 0.0f;
nonbondedForceStreams[0]->fillWithValue( &zerof );
nonbondedForceStreams[1]->fillWithValue( &zerof );
nonbondedForceStreams[2]->fillWithValue( &zerof );
nonbondedForceStreams[3]->fillWithValue( &zerof );
*/
// diagnostics
if( 1 && PrintOn ){
(void) fprintf( getLog(), "\nPost knbforce_CDLJ4: particles=%6d ceiling=%3d dupFac=%3d", getNumberOfParticles(),
getParticleSizeCeiling(),
getDuplicationFactor() );
(void) fprintf( getLog(), "\n hght=%6d width=%3d jWid=%3d", getParticleStreamHeight( ),
getParticleStreamWidth( ),
getJStreamWidth( ) );
(void) fprintf( getLog(), "\n pFrc=%6d eps=%12.5e\n", getPartialForceStreamWidth( ), epsfac );
(void) fprintf( getLog(), "\nOuterVdwStreamd\n" );
getOuterVdwStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nInnerSigmaStream\n" );
getInnerSigmaStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nInnerEpsilonStream\n" );
getInnerEpsilonStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nExclusionStream\n" );
getExclusionStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nChargeStream\n" );
getChargeStream()->printToFile( getLog() );
for( int ii = 0; ii < 4; ii++ ){
(void) fprintf( getLog(), "\nForce stream %d\n", ii );
nonbondedForceStreams[ii]->printToFile( getLog() );
}
}
// ---------------------------------------------------------------------------------------
// gather forces
kMergeFloat3_4_nobranch( (float) getDuplicationFactor(),
(float) getParticleStreamWidth(),
(float) getPartialForceStreamWidth(),
(float) getNumberOfParticles(),
(float) getParticleSizeCeiling(),
(float) getOuterLoopUnroll(),
nonbondedForceStreams[0]->getBrookStream(),
nonbondedForceStreams[1]->getBrookStream(),
nonbondedForceStreams[2]->getBrookStream(),
nonbondedForceStreams[3]->getBrookStream(),
forceStream.getBrookStream() );
// diagnostics
if( 0 && PrintOn ){
(void) fprintf( getLog(), "\nNB forces" );
BrookStreamInternal* brookStreamInternalF = forceStream.getBrookStreamImpl();
brookStreamInternalF->printToFile( getLog() );
}
return;
}
platforms/brook/src/BrookNonBonded.h
View file @ 309008f7
......@@ -35,8 +35,7 @@
#include <vector>
#include <set>
#include "BrookFloatStreamInternal.h"
#include "BrookIntStreamInternal.h"
#include "BrookStreamImpl.h"
#include "BrookPlatform.h"
#include "BrookCommon.h"
......@@ -72,13 +71,13 @@ class BrookNonBonded : public BrookCommon {
int getDuplicationFactor( void ) const;
/**
* Get atom ceiling parameter
* Get particle ceiling parameter
*
* @return atom ceiling parameter
* @return particle ceiling parameter
*
*/
int getAtomSizeCeiling( void ) const;
int getParticleSizeCeiling( void ) const;
/**
* Get outer loop unroll
......@@ -292,6 +291,13 @@ class BrookNonBonded : public BrookCommon {
BrookFloatStreamInternal** getForceStreams( void );
/**
* Compute forces
*
*/
void computeForces( BrookStreamImpl& positionStream, BrookStreamImpl& forceStream );
/**
* Return true if force[index] stream is set
*
......@@ -304,17 +310,17 @@ class BrookNonBonded : public BrookCommon {
/*
* Setup of nonbonded ixns
*
* @param numberOfAtoms number of atoms
* @param nonbondedParameters vector of nonbonded parameters [atomI][0=c6]
* [atomI][1=c12]
* [atomI][2=charge]
* @param numberOfParticles number of particles
* @param nonbondedParameters vector of nonbonded parameters [particleI][0=c6]
* [particleI][1=c12]
* [particleI][2=charge]
* @param platform Brook platform
* @param log optional Log file reference
*
* @return nonzero value if error
* */
int setup( int numberOfAtoms, const std::vector<std::vector<double> >& nonbondedParameters,
int setup( int numberOfParticles, const std::vector<std::vector<double> >& nonbondedParameters,
const std::vector<std::set<int> >& exclusions, const Platform& platform );
/*
......@@ -345,9 +351,9 @@ class BrookNonBonded : public BrookCommon {
LastStreamIndex
};
// atom ceiling
// particle ceiling
int _atomSizeCeiling;
int _particleSizeCeiling;
// unroll in i/j dimensions
......@@ -384,14 +390,14 @@ class BrookNonBonded : public BrookCommon {
/*
* Setup of stream dimensions for exclusion stream
*
* @param atomStreamSize atom stream size
* @param atomStreamWidth atom stream width
* @param particleStreamSize particle stream size
* @param particleStreamWidth particle stream width
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
* */
int _initializeExclusionStreamSize( int atomStreamSize, int atomStreamWidth );
int _initializeExclusionStreamSize( int particleStreamSize, int particleStreamWidth );
/**
* Initialize exclusion stream dimensions and stream
......@@ -407,8 +413,8 @@ class BrookNonBonded : public BrookCommon {
/**
* Set exclusion (4x4)
*
* @param i atom i index
* @param j atom j index
* @param i particle i index
* @param j particle j index
* @param exclusionStreamWidth exclusion stream width
* @param exclusion array of packed exclusions
*
......@@ -421,7 +427,7 @@ class BrookNonBonded : public BrookCommon {
/**
* Initialize exclusions
*
* @param exclusions vector of sets containing exclusions (1 set entry for every atom)
* @param exclusions vector of sets containing exclusions (1 set entry for every particle)
* @param platform platform
*
* @return nonzero value if error
......@@ -433,14 +439,14 @@ class BrookNonBonded : public BrookCommon {
/**
* Initialize stream dimensions
*
* @param numberOfAtoms number of atoms
* @param numberOfParticles number of particles
* @param platform platform
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
*/
int _initializeStreamSizes( int numberOfAtoms, const Platform& platform );
int _initializeStreamSizes( int numberOfParticles, const Platform& platform );
/**
* Initialize stream dimensions and streams
......@@ -456,8 +462,8 @@ class BrookNonBonded : public BrookCommon {
/*
* Setup of j-stream dimensions
*
* @param atomStreamSize atom stream size
* @param atomStreamWidth atom stream width
* @param particleStreamSize particle stream size
* @param particleStreamWidth particle stream width
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
......@@ -465,13 +471,13 @@ class BrookNonBonded : public BrookCommon {
*
* */
int _initializeJStreamSize( int atomStreamSize, int atomStreamWidth );
int _initializeJStreamSize( int particleStreamSize, int particleStreamWidth );
/*
* Setup of outer vdw stream size
*
* @param atomStreamSize atom stream size
* @param atomStreamWidth atom stream width
* @param particleStreamSize particle stream size
* @param particleStreamWidth particle stream width
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
......@@ -479,7 +485,7 @@ class BrookNonBonded : public BrookCommon {
*
* */
int _initializeOuterVdwStreamSize( int atomStreamSize, int atomStreamWidth );
int _initializeOuterVdwStreamSize( int particleStreamSize, int particleStreamWidth );
/**
* Set sigma & epsilon given c6 & c12 (geometric rule)
......@@ -498,7 +504,7 @@ class BrookNonBonded : public BrookCommon {
/**
* Initialize vdw & charge
*
* @param exclusions vector of sets containing exclusions (1 set entry for every atom)
* @param exclusions vector of sets containing exclusions (1 set entry for every particle)
* @param platform platform
*
* @return nonzero value if error
......@@ -510,7 +516,7 @@ class BrookNonBonded : public BrookCommon {
/**
* Initialize vdw & charge
*
* @param exclusions vector of sets containing exclusions (1 set entry for every atom)
* @param exclusions vector of sets containing exclusions (1 set entry for every particle)
* @param platform platform
*
* @return nonzero value if error
......@@ -522,14 +528,14 @@ class BrookNonBonded : public BrookCommon {
/*
* Setup of stream dimensions for partial force streams
*
* @param atomStreamSize atom stream size
* @param atomStreamWidth atom stream width
* @param particleStreamSize particle stream size
* @param particleStreamWidth particle stream width
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
* */
int _initializePartialForceStreamSize( int atomStreamSize, int atomStreamWidth );
int _initializePartialForceStreamSize( int particleStreamSize, int particleStreamWidth );
};
......
platforms/brook/src/BrookPlatform.cpp
View file @ 309008f7
......@@ -31,6 +31,8 @@
#include "BrookPlatform.h"
#include "BrookKernelFactory.h"
#include "OpenMMBrookInterface.h"
#include "internal/OpenMMContextImpl.h"
#include "OpenMMException.h"
#include "kernels.h"
#include "../../reference/src/SimTKUtilities/SimTKOpenMMRealType.h"
......@@ -42,6 +44,121 @@
using namespace OpenMM;
/**
* BrookPlatformData constructor
*
*/
BrookPlatformData::BrookPlatformData( void ){
// ---------------------------------------------------------------------------------------
// static const std::string methodName = "BrookPlatformData::BrookPlatformData";
// ---------------------------------------------------------------------------------------
//_forceKernel = NULL;
_removeCOM = 0;
_useOBC = 0;
_hasBonds = 0;
_hasAngles = 0;
_hasPeriodicTorsions = 0;
_hasRB = 0;
_hasNonbonded = 0;
_cmMotionFrequency = 0;
}
/**
* Get _removeCOM flag
*
* @return _removeCOM
*
*/
int BrookPlatformData::removeCOM( void ) const {
return _removeCOM;
}
/**
* Get _useOBC flag
*
* @return _useOBC
*
*/
int BrookPlatformData::useOBC( void ) const {
return _useOBC;
}
/**
* Get _hasBonds flag
*
* @return _hasBonds
*
*/
int BrookPlatformData::hasBonds( void ) const {
return _hasBonds;
}
/**
* Get _hasAngles
*
* @return _hasAngles
*
*/
int BrookPlatformData::hasAngles( void ) const {
return _hasAngles;
}
/**
* Get _hasPeriodicTorsions
*
* @return _hasPeriodicTorsions
*
*/
int BrookPlatformData::hasPeriodicTorsions( void ) const {
return _hasPeriodicTorsions;
}
/**
* Get _hasRB
*
* @return _hasRB
*
*/
int BrookPlatformData::hasRB( void ) const {
return _hasRB;
}
/**
* Get _hasNonbonded
*
* @return _hasNonbonded
*
*/
int BrookPlatformData::hasNonbonded( void ) const {
return _hasNonbonded;
}
/**
* Get _cmMotionFrequency
*
* @return _cmMotionFrequency
*
*/
int BrookPlatformData::cmMotionFrequency( void ) const {
return _cmMotionFrequency;
}
/**
* Register BrookPlatform
*
......@@ -78,8 +195,9 @@ BrookPlatform::BrookPlatform( ){
// ---------------------------------------------------------------------------------------
_atomStreamWidth = DefaultAtomStreamWidth;
_log = NULL;
_particleStreamWidth = DefaultParticleStreamWidth;
_log = NULL;
_openMMBrookInterface = NULL;
// get Brook runtime
......@@ -102,13 +220,13 @@ BrookPlatform::BrookPlatform( ){
/**
* BrookPlatform constructor
*
* @param defaultAtomStreamWidth stream width
* @param runtime Brook runtime (cal/cpu)
* @param log log file reference
* @param defaultParticleStreamWidth stream width
* @param runtime Brook runtime (cal/cpu)
* @param log log file reference
*
*/
BrookPlatform::BrookPlatform( int atomStreamWidth, const std::string& runtime, FILE* log ){
BrookPlatform::BrookPlatform( int particleStreamWidth, const std::string& runtime, FILE* log ) : _particleStreamWidth( particleStreamWidth ), _log( log ){
// ---------------------------------------------------------------------------------------
......@@ -116,8 +234,8 @@ BrookPlatform::BrookPlatform( int atomStreamWidth, const std::string& runtime, F
// ---------------------------------------------------------------------------------------
_log = log;
_atomStreamWidth = atomStreamWidth;
_openMMBrookInterface = NULL;
_initializeKernelFactory( );
_setBrookRuntime( runtime );
......@@ -153,8 +271,8 @@ void BrookPlatform::_initializeKernelFactory( void ){
BrookKernelFactory* factory = new BrookKernelFactory();
registerKernelFactory( CalcNonbondedForceKernel::Name(), factory);
registerKernelFactory( CalcGBSAOBCForceKernel::Name(), factory);
registerKernelFactory( CalcNonbondedForceKernel::Name(), factory);
registerKernelFactory( CalcGBSAOBCForceKernel::Name(), factory);
registerKernelFactory( IntegrateVerletStepKernel::Name(), factory);
registerKernelFactory( IntegrateLangevinStepKernel::Name(), factory);
registerKernelFactory( IntegrateBrownianStepKernel::Name(), factory);
......@@ -183,7 +301,10 @@ void BrookPlatform::_setBrookRuntime( const std::string& runtime ){
// set & validate runtime
_runtime = runtime;
std::transform( _runtime.begin(), _runtime.end(), _runtime.begin(), tolower);
// lower case
std::transform( _runtime.begin(), _runtime.end(), _runtime.begin(), tolower );
if( _runtime != "cal" && _runtime != "cpu" ){
std::stringstream message;
message << methodName << " Brook runtime=" << _runtime << " not recognized.";
......@@ -306,3 +427,38 @@ int BrookPlatform::setLog( FILE* log ){
return BrookPlatform::DefaultErrorValue;
}
/**
*
* This is called whenever a new OpenMMContext is created. It gives the Platform a chance to initialize
* the context and store platform-specific data in it.
*
*/
void BrookPlatform::contextCreated( OpenMMContextImpl& context ) const {
// ---------------------------------------------------------------------------------------
// static const std::string methodName = "BrookPlatform::contextCreated";
// ---------------------------------------------------------------------------------------
context.setPlatformData( new OpenMMBrookInterface() );
}
/**
*
* This is called whenever an OpenMMContext is deleted. It gives the Platform a chance to clean up
* any platform-specific data that was stored in it.
*
*/
void BrookPlatform::contextDestroyed( OpenMMContextImpl& context ) const {
// ---------------------------------------------------------------------------------------
// static const std::string methodName = "BrookPlatform::contextDestroyed";
// ---------------------------------------------------------------------------------------
delete _openMMBrookInterface;
}
platforms/brook/src/BrookRandomNumberGenerator.cpp
View file @ 309008f7
......@@ -65,7 +65,8 @@ BrookRandomNumberGenerator::BrookRandomNumberGenerator( ){
_rvStreamIndex = 0;
_rvStreamOffset = 0;
_numberOfShuffles = 0;
_maxShuffles = 100;
_maxShuffles = 3;
//_maxShuffles = 100;
_loadBuffer = NULL;
_shuffleIndices = NULL;
......@@ -617,7 +618,7 @@ int BrookRandomNumberGenerator::_shuffleGVStreams( void ){
}
/**
* Advances the current position by 2*gpu->natoms
* Advances the current position by 2*gpu->particles
* If we run out of rand numbers, we shuffle and
* reuse a few times before reloading from the cpu
*
......@@ -630,7 +631,9 @@ int BrookRandomNumberGenerator::advanceGVCursor( int numberOfRandomValuesConsume
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nBrookRandomNumberGenerator::advanceGVCursor";
static const char* methodName = "\nBrookRandomNumberGenerator::advanceGVCursor";
static const int PrintOn = 1;
// ---------------------------------------------------------------------------------------
......@@ -644,12 +647,15 @@ int BrookRandomNumberGenerator::advanceGVCursor( int numberOfRandomValuesConsume
if ( _rvStreamOffset > rvStreamSize - numberOfRandomValuesConsumedPerIteration ){
char* action;
// next one if available
_rvStreamOffset = 0;
if ( _rvStreamIndex < _numberOfRandomNumberStreams - 1 ){
_rvStreamIndex++;
action = "incremented stream index";
} else {
//No more textures, need to shuffle
......@@ -658,18 +664,26 @@ int BrookRandomNumberGenerator::advanceGVCursor( int numberOfRandomValuesConsume
_shuffleGVStreams( );
_numberOfShuffles++;
action = "shuffled streams";
} else { //Need to refresh random numbers from cpu
if( UseOriginalRng ){
action = "loaded new values from GPU using original rng";
_loadGVStreamsOriginal( );
} else {
_loadRandomNumberStreamsKiss( );
action = "loaded new values from GPU using KISS rng";
}
_numberOfShuffles = 0;
}
_rvStreamIndex = 0;
}
if( PrintOn && getLog() ){
(void) fprintf( getLog(), "%s StrmIdx=%d action=%s", methodName, _rvStreamIndex, action );
(void) fflush( getLog() );
}
}
return DefaultReturnValue;
......@@ -700,7 +714,7 @@ BrookFloatStreamInternal* BrookRandomNumberGenerator::_getShuffleStream( void )
/**
* Get random number stream
*
* @param index random number stream index
* @param index random number stream index
*
* @return random number stream
*
......@@ -780,14 +794,14 @@ int BrookRandomNumberGenerator::_getNumberOfShuffles( void ) const {
/**
* Initialize stream dimensions
*
* @param numberOfAtoms number of atoms
* @param numberOfParticles number of particles
* @param platform platform
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
*/
int BrookRandomNumberGenerator::_initializeStreamSizes( int numberOfAtoms, const Platform& platform ){
int BrookRandomNumberGenerator::_initializeStreamSizes( int numberOfParticles, const Platform& platform ){
// ---------------------------------------------------------------------------------------
......@@ -795,7 +809,7 @@ int BrookRandomNumberGenerator::_initializeStreamSizes( int numberOfAtoms, const
// ---------------------------------------------------------------------------------------
setNumberOfAtoms( numberOfAtoms );
setNumberOfParticles( numberOfParticles );
// get randomNumber stream dimensions
......@@ -862,14 +876,14 @@ int BrookRandomNumberGenerator::_initializeStreams( const Platform& platform ){
/*
* Setup of StochasticDynamics parameters
*
* @param numberOfAtoms number of atoms
* @param numberOfParticles number of particles
* @param platform Brook platform
*
* @return nonzero value if error
*
* */
int BrookRandomNumberGenerator::setup( int numberOfAtoms, const Platform& platform ){
int BrookRandomNumberGenerator::setup( int numberOfParticles, const Platform& platform ){
// ---------------------------------------------------------------------------------------
......@@ -877,9 +891,12 @@ int BrookRandomNumberGenerator::setup( int numberOfAtoms, const Platform& platf
// ---------------------------------------------------------------------------------------
const BrookPlatform brookPlatform = dynamic_cast<const BrookPlatform&> (platform);
setLog( brookPlatform.getLog() );
// set stream sizes and then create streams
_initializeStreamSizes( numberOfAtoms, platform );
_initializeStreamSizes( numberOfParticles, platform );
_initializeStreams( platform );
if( UseOriginalRng ){
_loadGVStreamsOriginal( );
......
platforms/brook/src/BrookRandomNumberGenerator.h
View file @ 309008f7
......@@ -109,14 +109,14 @@ class BrookRandomNumberGenerator : public BrookCommon {
/*
* Setup of RNG parameters
*
* @param numberOfAtoms number of atoms
* @param numberOfParticles number of particles
* @param platform Brook platform
*
* @return ErrorReturnValue value if error, else DefaultReturnValue
*
* */
int setup( int numberOfAtoms, const Platform& platform );
int setup( int numberOfParticles, const Platform& platform );
/*
* Get contents of object
......@@ -266,26 +266,26 @@ class BrookRandomNumberGenerator : public BrookCommon {
/*
* Setup of stream dimensions
*
* @param atomStreamSize atom stream size
* @param atomStreamWidth atom stream width
* @param particleStreamSize particle stream size
* @param particleStreamWidth particle stream width
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
* */
int _initializeStreamSizes( int atomStreamSize, int atomStreamWidth );
int _initializeStreamSizes( int particleStreamSize, int particleStreamWidth );
/**
* Initialize stream dimensions
*
* @param numberOfAtoms number of atoms
* @param numberOfParticles number of particles
* @param platform platform
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
*/
int _initializeStreamSizes( int numberOfAtoms, const Platform& platform );
int _initializeStreamSizes( int numberOfParticles, const Platform& platform );
/**
* Initialize stream dimensions and streams
......
platforms/brook/src/BrookRemoveCMMotionKernel.cpp
View file @ 309008f7
......@@ -75,7 +75,7 @@ BrookRemoveCMMotionKernel::~BrookRemoveCMMotionKernel( ){
/**
* Initialize the kernel
*
* @param masses array of atom masses
* @param masses array of particle masses
*
*/
......@@ -97,7 +97,7 @@ void BrookRemoveCMMotionKernel::initialize( const vector<double>& masses ){
/**
* Execute kernel
*
* @param velocities array of atom velocities
* @param velocities array of particle velocities
*
*/
......
platforms/brook/src/BrookRemoveCMMotionKernel.h
View file @ 309008f7
......@@ -65,7 +65,7 @@ class BrookRemoveCMMotionKernel : public RemoveCMMotionKernel {
/**
* Initialize the kernel
*
* @param masses mass of each atom
* @param masses mass of each particle
*
*/
void initialize( const std::vector<double>& masses );
......@@ -73,7 +73,7 @@ class BrookRemoveCMMotionKernel : public RemoveCMMotionKernel {
/**
* Execute the kernel.
*
* @param velocities stream of atom velocities
* @param velocities stream of particle velocities
*
*/
......
platforms/brook/src/BrookShakeAlgorithm.cpp
View file @ 309008f7
......@@ -55,14 +55,14 @@ BrookShakeAlgorithm::BrookShakeAlgorithm( ){
// ---------------------------------------------------------------------------------------
_numberOfAtoms = -1;
_numberOfParticles = -1;
_numberOfConstraints = -1;
// mark stream dimension variables as unset
_shakeAtomStreamWidth = -1;
_shakeAtomStreamHeight = -1;
_shakeAtomStreamSize = -1;
_shakeParticleStreamWidth = -1;
_shakeParticleStreamHeight = -1;
_shakeParticleStreamSize = -1;
_shakeConstraintStreamSize = -1;
_shakeConstraintStreamWidth = -1;
......@@ -124,35 +124,35 @@ BrookOpenMMFloat BrookShakeAlgorithm::getInverseHydrogenMass( void ) const {
}
/**
* Get Atom stream size
* Get Particle stream size
*
* @return Atom stream size
* @return Particle stream size
*
*/
int BrookShakeAlgorithm::getShakeAtomStreamSize( void ) const {
return _shakeAtomStreamSize;
int BrookShakeAlgorithm::getShakeParticleStreamSize( void ) const {
return _shakeParticleStreamSize;
}
/**
* Get atom stream width
* Get particle stream width
*
* @return atom stream width
* @return particle stream width
*
*/
int BrookShakeAlgorithm::getShakeAtomStreamWidth( void ) const {
return _shakeAtomStreamWidth;
int BrookShakeAlgorithm::getShakeParticleStreamWidth( void ) const {
return _shakeParticleStreamWidth;
}
/**
* Get atom stream height
* Get particle stream height
*
* @return atom stream height
* @return particle stream height
*/
int BrookShakeAlgorithm::getShakeAtomStreamHeight( void ) const {
return _shakeAtomStreamHeight;
int BrookShakeAlgorithm::getShakeParticleStreamHeight( void ) const {
return _shakeParticleStreamHeight;
}
/**
......@@ -188,25 +188,25 @@ int BrookShakeAlgorithm::getShakeConstraintStreamHeight( void ) const {
}
/**
* Get Shake atom indices stream
* Get Shake particle indices stream
*
* @return Shake atom indices stream
* @return Shake particle indices stream
*
*/
BrookFloatStreamInternal* BrookShakeAlgorithm::getShakeAtomIndicesStream( void ) const {
return _shakeStreams[ShakeAtomIndicesStream];
BrookFloatStreamInternal* BrookShakeAlgorithm::getShakeParticleIndicesStream( void ) const {
return _shakeStreams[ShakeParticleIndicesStream];
}
/**
* Get Shake atom parameter stream
* Get Shake particle parameter stream
*
* @return Shake atom parameter sStream
* @return Shake particle parameter sStream
*
*/
BrookFloatStreamInternal* BrookShakeAlgorithm::getShakeAtomParameterStream( void ) const {
return _shakeStreams[ShakeAtomParameterStream];
BrookFloatStreamInternal* BrookShakeAlgorithm::getShakeParticleParameterStream( void ) const {
return _shakeStreams[ShakeParticleParameterStream];
}
/**
......@@ -267,7 +267,7 @@ BrookFloatStreamInternal* BrookShakeAlgorithm::getShakeInverseMapStream( void )
/**
* Initialize stream dimensions
*
* @param numberOfAtoms number of atoms
* @param numberOfParticles number of particles
* @param numberOfConstraints number of constraints
* @param platform platform
*
......@@ -275,7 +275,7 @@ BrookFloatStreamInternal* BrookShakeAlgorithm::getShakeInverseMapStream( void )
*
*/
int BrookShakeAlgorithm::_initializeStreamSizes( int numberOfAtoms, int numberOfConstraints,
int BrookShakeAlgorithm::_initializeStreamSizes( int numberOfParticles, int numberOfConstraints,
const Platform& platform ){
// ---------------------------------------------------------------------------------------
......@@ -284,9 +284,9 @@ int BrookShakeAlgorithm::_initializeStreamSizes( int numberOfAtoms, int numberOf
// ---------------------------------------------------------------------------------------
_shakeAtomStreamSize = getAtomStreamSize( platform );
_shakeAtomStreamWidth = getAtomStreamWidth( platform );
_shakeAtomStreamHeight = getAtomStreamHeight( platform );
_shakeParticleStreamSize = getParticleStreamSize( platform );
_shakeParticleStreamWidth = getParticleStreamWidth( platform );
_shakeParticleStreamHeight = getParticleStreamHeight( platform );
// get constraint stream width & height, and then set stream size to the product
......@@ -315,17 +315,19 @@ int BrookShakeAlgorithm::_initializeStreams( const Platform& platform ){
// ---------------------------------------------------------------------------------------
int shakeAtomStreamSize = getShakeAtomStreamSize();
int shakeAtomStreamWidth = getShakeAtomStreamWidth();
int shakeParticleStreamSize = getShakeParticleStreamSize();
int shakeParticleStreamWidth = getShakeParticleStreamWidth();
int shakeConstraintStreamSize = getShakeConstraintStreamSize();
int shakeConstraintStreamWidth = getShakeConstraintStreamWidth();
_shakeStreams[ShakeAtomIndicesStream] = new BrookFloatStreamInternal( BrookCommon::ShakeAtomIndicesStream,
_shakeStreams[ShakeParticleIndicesStream]
= new BrookFloatStreamInternal( BrookCommon::ShakeParticleIndicesStream,
shakeConstraintStreamSize, shakeConstraintStreamWidth,
BrookStreamInternal::Float4, dangleValue );
_shakeStreams[ShakeAtomParameterStream] = new BrookFloatStreamInternal( BrookCommon::ShakeAtomParameterStream,
_shakeStreams[ShakeParticleParameterStream]
= new BrookFloatStreamInternal( BrookCommon::ShakeParticleParameterStream,
shakeConstraintStreamSize, shakeConstraintStreamWidth,
BrookStreamInternal::Float4, dangleValue );
......@@ -346,7 +348,7 @@ int BrookShakeAlgorithm::_initializeStreams( const Platform& platform ){
BrookStreamInternal::Float3, dangleValue );
_shakeStreams[ShakeInverseMapStream] = new BrookFloatStreamInternal( BrookCommon::ShakeInverseMapStream,
shakeAtomStreamSize, shakeAtomStreamWidth,
shakeParticleStreamSize, shakeParticleStreamWidth,
BrookStreamInternal::Float2, dangleValue );
return DefaultReturnValue;
......@@ -356,7 +358,7 @@ int BrookShakeAlgorithm::_initializeStreams( const Platform& platform ){
* Set Shake streams
*
* @param masses masses
* @param constraintIndices constraint atom indices
* @param constraintIndices constraint particle indices
* @param constraintLengths constraint lengths
*
* @return ErrorReturnValue if error
......@@ -377,7 +379,7 @@ int BrookShakeAlgorithm::_setShakeStreams( const std::vector<double>& masses, co
// ---------------------------------------------------------------------------------------
int shakeAtomStreamSize = getShakeAtomStreamSize();
int shakeParticleStreamSize = getShakeParticleStreamSize();
int shakeConstraintStreamSize = getShakeConstraintStreamSize();
// check that number of constraints for two input vectors is consistent
......@@ -391,89 +393,89 @@ int BrookShakeAlgorithm::_setShakeStreams( const std::vector<double>& masses, co
// allocate arrays to be read down to board
BrookOpenMMFloat* atomIndices = new BrookOpenMMFloat[4*shakeConstraintStreamSize];
BrookOpenMMFloat* particleIndices = new BrookOpenMMFloat[4*shakeConstraintStreamSize];
BrookOpenMMFloat* shakeParameters = new BrookOpenMMFloat[4*shakeConstraintStreamSize];
for( int ii = 0; ii < 4*shakeConstraintStreamSize; ii++ ){
atomIndices[ii] = (BrookOpenMMFloat) -1;
particleIndices[ii] = (BrookOpenMMFloat) -1;
}
memset( shakeParameters, 0, 4*shakeConstraintStreamSize*sizeof( BrookOpenMMFloat ) );
std::vector< std::vector<int> >::const_iterator atomIterator = constraintIndices.begin();
std::vector<double>::const_iterator distanceIterator = constraintLengths.begin();
std::vector< std::vector<int> >::const_iterator particleIterator = constraintIndices.begin();
std::vector<double>::const_iterator distanceIterator = constraintLengths.begin();
int constraintIndex = 0;
_numberOfConstraints = 0;
while( atomIterator != constraintIndices.end() ){
while( particleIterator != constraintIndices.end() ){
std::vector<int> atomVector = *atomIterator;
std::vector<int> particleVector = *particleIterator;
// check that array of indices is not too small or large
if( atomVector.size() < 2 ){
if( particleVector.size() < 2 ){
std::stringstream message;
message << methodName << " atomIndices size=" << atomVector.size() << " is too small at constraintIndex=" << (constraintIndex/4);
message << methodName << " particleIndices size=" << particleVector.size() << " is too small at constraintIndex=" << (constraintIndex/4);
throw OpenMMException( message.str() );
return ErrorReturnValue;
}
if( atomVector.size() > 4 ){
if( particleVector.size() > 4 ){
std::stringstream message;
message << methodName << " atomIndices size=" << atomVector.size() << " is too large at constraintIndex=" << (constraintIndex/4);
message << methodName << " particleIndices size=" << particleVector.size() << " is too large at constraintIndex=" << (constraintIndex/4);
throw OpenMMException( message.str() );
return ErrorReturnValue;
}
int index = 0;
int atomIndex1 = -1;
int atomIndex2 = -1;
for( std::vector<int>::const_iterator ii = atomVector.begin(); ii != atomVector.end(); ii++, index++ ){
atomIndices[constraintIndex + index] = (BrookOpenMMFloat) *ii;
int particleIndex1 = -1;
int particleIndex2 = -1;
for( std::vector<int>::const_iterator ii = particleVector.begin(); ii != particleVector.end(); ii++, index++ ){
particleIndices[constraintIndex + index] = (BrookOpenMMFloat) *ii;
if( index == 0 ){
atomIndex1 = *ii;
particleIndex1 = *ii;
} else if( index == 1 ){
atomIndex2 = *ii;
particleIndex2 = *ii;
}
}
// skip negative indices
if( atomIndex1 < 0 || atomIndex2 < 0 ){
atomIterator++;
if( particleIndex1 < 0 || particleIndex2 < 0 ){
particleIterator++;
distanceIterator++;
continue;
}
if( atomIndex1 >= (int) masses.size() || atomIndex2 >= (int) masses.size() ){
if( particleIndex1 >= (int) masses.size() || particleIndex2 >= (int) masses.size() ){
std::stringstream message;
message << methodName << " constraint indices=[" << atomIndex1 << ", " << atomIndex2 << "] greater than mass array size=" << masses.size();
message << methodName << " constraint indices=[" << particleIndex1 << ", " << particleIndex2 << "] greater than mass array size=" << masses.size();
throw OpenMMException( message.str() );
return ErrorReturnValue;
}
// insure heavy atom is first
// insure heavy particle is first
if( masses[atomIndex1] < masses[atomIndex2] ){
if( masses[particleIndex1] < masses[particleIndex2] ){
BrookOpenMMFloat swap = atomIndices[constraintIndex];
atomIndices[constraintIndex] = atomIndices[constraintIndex+1];
atomIndices[constraintIndex+1] = swap;
BrookOpenMMFloat swap = particleIndices[constraintIndex];
particleIndices[constraintIndex] = particleIndices[constraintIndex+1];
particleIndices[constraintIndex+1] = swap;
int swapI = atomIndex1;
atomIndex1 = atomIndex2;
atomIndex2 = swapI;
int swapI = particleIndex1;
particleIndex1 = particleIndex2;
particleIndex2 = swapI;
}
// set parameters:
// (1) 1/(heavy atom mass)
// (2) 0.5/(heavy atom mass+hydrogen mass)
// (1) 1/(heavy particle mass)
// (2) 0.5/(heavy particle mass+hydrogen mass)
// (3) constraint distance**2
shakeParameters[constraintIndex] = one/( (BrookOpenMMFloat) masses[atomIndex1] );
shakeParameters[constraintIndex+1] = half/( (BrookOpenMMFloat) (masses[atomIndex1] + masses[atomIndex2]) );
shakeParameters[constraintIndex] = one/( (BrookOpenMMFloat) masses[particleIndex1] );
shakeParameters[constraintIndex+1] = half/( (BrookOpenMMFloat) (masses[particleIndex1] + masses[particleIndex2]) );
shakeParameters[constraintIndex+2] = (BrookOpenMMFloat) ( (*distanceIterator)*(*distanceIterator) );
atomIterator++;
particleIterator++;
distanceIterator++;
constraintIndex += 4;
_numberOfConstraints++;
......@@ -481,15 +483,15 @@ int BrookShakeAlgorithm::_setShakeStreams( const std::vector<double>& masses, co
// write entries to board
_shakeStreams[ShakeAtomIndicesStream]->loadFromArray( atomIndices );
_shakeStreams[ShakeAtomParameterStream]->loadFromArray( shakeParameters );
_shakeStreams[ShakeParticleIndicesStream]->loadFromArray( particleIndices );
_shakeStreams[ShakeParticleParameterStream]->loadFromArray( shakeParameters );
delete[] shakeParameters;
// initialize inverse map
BrookOpenMMFloat* inverseMap = new BrookOpenMMFloat[2*shakeAtomStreamSize];
for( int ii = 0; ii < shakeAtomStreamSize*2; ii++ ){
BrookOpenMMFloat* inverseMap = new BrookOpenMMFloat[2*shakeParticleStreamSize];
for( int ii = 0; ii < shakeParticleStreamSize*2; ii++ ){
inverseMap[ii] = -1;
}
......@@ -498,17 +500,17 @@ int BrookShakeAlgorithm::_setShakeStreams( const std::vector<double>& masses, co
for( int ii = 0; ii < shakeConstraintStreamSize; ii++ ){
int ii4 = ii << 2;
for( int jj = 0; jj < 4; jj++ ){
if( atomIndices[ii4+jj] != -1 ){
int atomIndex = (int) (atomIndices[ii4+jj] + 0.001);
inverseMap[atomIndex*2] = (float) ii;
inverseMap[atomIndex*2+1] = (float) jj;
if( particleIndices[ii4+jj] != -1 ){
int particleIndex = (int) (particleIndices[ii4+jj] + 0.001);
inverseMap[particleIndex*2] = (float) ii;
inverseMap[particleIndex*2+1] = (float) jj;
}
}
}
_shakeStreams[ShakeInverseMapStream]->loadFromArray( inverseMap );
delete[] atomIndices;
delete[] particleIndices;
delete[] inverseMap;
return DefaultReturnValue;
......@@ -519,7 +521,7 @@ int BrookShakeAlgorithm::_setShakeStreams( const std::vector<double>& masses, co
* Setup of Shake parameters
*
* @param masses masses
* @param constraintIndices constraint atom indices
* @param constraintIndices constraint particle indices
* @param constraintLengths constraint lengths
* @param platform Brook platform
*
......@@ -536,12 +538,12 @@ int BrookShakeAlgorithm::setup( const std::vector<double>& masses, const std::ve
// ---------------------------------------------------------------------------------------
int numberOfAtoms = (int) masses.size();
setNumberOfAtoms( numberOfAtoms );
int numberOfParticles = (int) masses.size();
setNumberOfParticles( numberOfParticles );
// set stream sizes and then create streams
_initializeStreamSizes( numberOfAtoms, (int) constraintIndices.size(), platform );
_initializeStreamSizes( numberOfParticles, (int) constraintIndices.size(), platform );
_initializeStreams( platform );
_setShakeStreams( masses, constraintIndices, constraintLengths );
......@@ -580,17 +582,17 @@ std::string BrookShakeAlgorithm::getContentsString( int level ) const {
#define LOCAL_SPRINTF(a,b,c) sprintf( (a), (b), (c) );
#endif
(void) LOCAL_SPRINTF( value, "%d", getNumberOfAtoms() );
message << _getLine( tab, "Number of atoms:", value );
(void) LOCAL_SPRINTF( value, "%d", getNumberOfParticles() );
message << _getLine( tab, "Number of particles:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamWidth() );
message << _getLine( tab, "Atom stream width:", value );
(void) LOCAL_SPRINTF( value, "%d", getParticleStreamWidth() );
message << _getLine( tab, "Particle stream width:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamHeight() );
message << _getLine( tab, "Atom stream height:", value );
(void) LOCAL_SPRINTF( value, "%d", getParticleStreamHeight() );
message << _getLine( tab, "Particle stream height:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamSize() );
message << _getLine( tab, "Atom stream size:", value );
(void) LOCAL_SPRINTF( value, "%d", getParticleStreamSize() );
message << _getLine( tab, "Particle stream size:", value );
(void) LOCAL_SPRINTF( value, "%d", getNumberOfConstraints() );
message << _getLine( tab, "Number of constraints:", value );
......@@ -609,8 +611,8 @@ std::string BrookShakeAlgorithm::getContentsString( int level ) const {
message << _getLine( tab, "Log:", (getLog() ? Set : NotSet) );
message << _getLine( tab, "AtomIndices:", (getShakeAtomIndicesStream() ? Set : NotSet) );
message << _getLine( tab, "AtomParameters:", (getShakeAtomParameterStream() ? Set : NotSet) );
message << _getLine( tab, "ParticleIndices:", (getShakeParticleIndicesStream() ? Set : NotSet) );
message << _getLine( tab, "ParticleParameters:", (getShakeParticleParameterStream() ? Set : NotSet) );
message << _getLine( tab, "XCons0:", (getShakeXCons0Stream() ? Set : NotSet) );
message << _getLine( tab, "XCons1:", (getShakeXCons1Stream() ? Set : NotSet) );
message << _getLine( tab, "XCons2:", (getShakeXCons2Stream() ? Set : NotSet) );
......
platforms/brook/src/BrookShakeAlgorithm.h
View file @ 309008f7
#ifndef OPENMM_BROOK_SHAKE_H_
#define OPENMM_BROOK_SHAKE_H_
#ifndef OPENMM_BROOK_SHAKE_ALGORITHM_H_
#define OPENMM_BROOK_SHAKE_ALGORITHM_H_
/* -------------------------------------------------------------------------- *
* OpenMM *
......@@ -83,28 +83,28 @@ class BrookShakeAlgorithm : public BrookCommon {
BrookOpenMMFloat getInverseHydrogenMass( void ) const;
/**
* Get Shake atom stream width
* Get Shake particle stream width
*
* @return atom stream width
* @return particle stream width
*/
int getShakeAtomStreamWidth( void ) const;
int getShakeParticleStreamWidth( void ) const;
/**
* Get Shake atom stream height
* Get Shake particle stream height
*
* @return atom stream height
* @return particle stream height
*/
int getShakeAtomStreamHeight( void ) const;
int getShakeParticleStreamHeight( void ) const;
/**
* Get Shake atom stream size
* Get Shake particle stream size
*
* @return atom stream size
* @return particle stream size
*/
int getShakeAtomStreamSize( void ) const;
int getShakeParticleStreamSize( void ) const;
/**
* Get Shake constraint stream width
......@@ -143,7 +143,7 @@ class BrookShakeAlgorithm : public BrookCommon {
* Setup of Shake parameters
*
* @param masses masses
* @param constraintIndices constraint atom indices
* @param constraintIndices constraint particle indices
* @param constraintLengths constraint lengths
* @param platform Brook platform
*
......@@ -166,22 +166,22 @@ class BrookShakeAlgorithm : public BrookCommon {
std::string getContentsString( int level = 0 ) const;
/**
* Get Shake atom indices stream
* Get Shake particle indices stream
*
* @return Shake atom indices stream
* @return Shake particle indices stream
*
*/
BrookFloatStreamInternal* getShakeAtomIndicesStream( void ) const;
BrookFloatStreamInternal* getShakeParticleIndicesStream( void ) const;
/**
* Get Shake atom parameter stream
* Get Shake particle parameter stream
*
* @return Shake atom parameter stream
* @return Shake particle parameter stream
*
*/
BrookFloatStreamInternal* getShakeAtomParameterStream( void ) const;
BrookFloatStreamInternal* getShakeParticleParameterStream( void ) const;
/**
* Get XCons0 stream
......@@ -233,8 +233,8 @@ class BrookShakeAlgorithm : public BrookCommon {
// streams indices
enum BrookShakeAlgorithmStreams {
ShakeAtomIndicesStream,
ShakeAtomParameterStream,
ShakeParticleIndicesStream,
ShakeParticleParameterStream,
ShakeXCons0Stream,
ShakeXCons1Stream,
ShakeXCons2Stream,
......@@ -251,11 +251,11 @@ class BrookShakeAlgorithm : public BrookCommon {
BrookOpenMMFloat _inverseHydrogenMass;
// atom stream dimensions
// particle stream dimensions
int _shakeAtomStreamWidth;
int _shakeAtomStreamHeight;
int _shakeAtomStreamSize;
int _shakeParticleStreamWidth;
int _shakeParticleStreamHeight;
int _shakeParticleStreamSize;
// constraint stream dimensions
......@@ -274,19 +274,19 @@ class BrookShakeAlgorithm : public BrookCommon {
/*
* Setup of stream dimensions
*
* @param atomStreamSize atom stream size
* @param atomStreamWidth atom stream width
* @param particleStreamSize particle stream size
* @param particleStreamWidth particle stream width
*
* @return ErrorReturnValue if error, else DefaultReturnValueValue
*
* */
int _initializeStreamSizes( int atomStreamSize, int atomStreamWidth );
int _initializeStreamSizes( int particleStreamSize, int particleStreamWidth );
/**
* Initialize stream dimensions
*
* @param numberOfAtoms number of atoms
* @param numberOfParticles number of particles
* @param numberOfConstraints number of constraints
* @param platform platform
*
......@@ -294,7 +294,7 @@ class BrookShakeAlgorithm : public BrookCommon {
*
*/
int _initializeStreamSizes( int numberOfAtoms, int numberOfConstraints, const Platform& platform );
int _initializeStreamSizes( int numberOfParticles, int numberOfConstraints, const Platform& platform );
/**
* Initialize stream dimensions and streams
......@@ -311,7 +311,7 @@ class BrookShakeAlgorithm : public BrookCommon {
* Set Shake streams
*
* @param masses masses
* @param constraintIndices constraint atom indices
* @param constraintIndices constraint particle indices
* @param constraintLengths constraint lengths
*
* @return ErrorReturnValue if error
......@@ -327,4 +327,4 @@ class BrookShakeAlgorithm : public BrookCommon {
} // namespace OpenMM
#endif /* OPENMM_BROOK_SHAKE_H_ */
#endif /* OPENMM_BROOK_SHAKE_ALGORITHM_H_ */
platforms/brook/src/BrookStreamFactory.cpp
View file @ 309008f7
......@@ -33,14 +33,17 @@
#include "OpenMMException.h"
#include "BrookStreamFactory.h"
#include "BrookStreamImpl.h"
#include "internal/OpenMMContextImpl.h"
#include "OpenMMBrookInterface.h"
using namespace OpenMM;
const std::string BrookStreamFactory::AtomPositions = "atomPositions";
const std::string BrookStreamFactory::AtomVelocities = "atomVelocities";
const std::string BrookStreamFactory::AtomForces = "atomForces";
const std::string BrookStreamFactory::ParticlePositions = "particlePositions";
const std::string BrookStreamFactory::ParticleVelocities = "particleVelocities";
const std::string BrookStreamFactory::ParticleForces = "particleForces";
const double DefaultDangleValue = 1.0e+08;
const double DefaultDangleValue = 1.0e+08;
/**
* BrookStreamFactory constructor
*
......@@ -56,7 +59,7 @@ BrookStreamFactory::BrookStreamFactory( void ){
// ---------------------------------------------------------------------------------------
_defaultDangleValue = 1.0e+08;
_defaultAtomStreamWidth = DefaultStreamAtomWidth;
_defaultParticleStreamWidth = DefaultStreamParticleWidth;
_defaultStreamRandomNumberWidth = DefaultStreamRandomNumberWidth;
_defaultStreamRandomNumberSize = DefaultStreamRandomNumberSize;
......@@ -71,52 +74,52 @@ BrookStreamFactory::~BrookStreamFactory( void ){
}
/**
* Get atom stream width
* Get particle stream width
*
* @return atomStreamWidth
* @return particleStreamWidth
*
*/
int BrookStreamFactory::getDefaultAtomStreamWidth( void ) const {
int BrookStreamFactory::getDefaultParticleStreamWidth( void ) const {
// ---------------------------------------------------------------------------------------
//static const std::string methodName = "BrookStreamFactory::getDefaultAtomStreamWidth";
//static const std::string methodName = "BrookStreamFactory::getDefaultParticleStreamWidth";
// ---------------------------------------------------------------------------------------
return _defaultAtomStreamWidth;
return _defaultParticleStreamWidth;
}
/**
* Set atom stream width
* Set particle stream width
*
* @param atomStreamWidth atom stream width
* @param particleStreamWidth particle stream width
*
* @return DefaultReturnValue
*
* @throw OpenMMException if atomStreamWidth < 1
* @throw OpenMMException if particleStreamWidth < 1
*
*/
int BrookStreamFactory::setDefaultAtomStreamWidth( int atomStreamWidth ){
int BrookStreamFactory::setDefaultParticleStreamWidth( int particleStreamWidth ){
// ---------------------------------------------------------------------------------------
static const std::string methodName = "BrookStreamFactory::setDefaultAtomStreamWidth";
static const std::string methodName = "BrookStreamFactory::setDefaultParticleStreamWidth";
// ---------------------------------------------------------------------------------------
// validate atom stream width
// validate particle stream width
if( atomStreamWidth < 1 ){
if( particleStreamWidth < 1 ){
std::stringstream message;
message << methodName << " atomStreamWidth=" << atomStreamWidth << " is less than 1.";
message << methodName << " particleStreamWidth=" << particleStreamWidth << " is less than 1.";
throw OpenMMException( message.str() );
return ErrorReturnValue;
}
_defaultAtomStreamWidth = atomStreamWidth;
_defaultParticleStreamWidth = particleStreamWidth;
return DefaultReturnValue;
......@@ -289,10 +292,22 @@ StreamImpl* BrookStreamFactory::createStreamImpl( std::string name, int size, St
// ---------------------------------------------------------------------------------------
// stream width hould be based on name & value set in platform; for now only atom stream types
// stream width hould be based on name & value set in platform; for now only particle stream types
int streamWidth = getDefaultParticleStreamWidth();
BrookStreamImpl* brookStreamImpl = new BrookStreamImpl( name, size, streamWidth, type, platform );
int streamWidth = getDefaultAtomStreamWidth();
OpenMMBrookInterface& openMMBrookInterface = *static_cast<OpenMMBrookInterface*>(context.getPlatformData());
if( name == ParticlePositions ){
openMMBrookInterface.setParticlePositions( brookStreamImpl );
} else if( name == ParticleVelocities ){
openMMBrookInterface.setParticleVelocities( brookStreamImpl );
} else if( name == ParticleForces ){
openMMBrookInterface.setParticleForces( brookStreamImpl );
}
return new BrookStreamImpl( name, size, streamWidth, type, platform );
return brookStreamImpl;
}
platforms/brook/src/BrookStreamInternal.h
View file @ 309008f7
......@@ -233,6 +233,19 @@ class BrookStreamInternal {
int printToFile( FILE* log );
/**
* Sum over stream dimensions
*
* @param stopIndex index to stop sum
* @param sum array of size=getWidth()
*
* @return DefaultReturnValue
*
* @throw exception if stopIndex is too large
*/
int sumByDimension( int stopIndex, double* sum );
protected:
std::string _name;
......
platforms/brook/src/BrookVelocityCenterOfMassRemoval.cpp
View file @ 309008f7
......@@ -55,13 +55,13 @@ BrookVelocityCenterOfMassRemoval::BrookVelocityCenterOfMassRemoval( ){
// ---------------------------------------------------------------------------------------
_numberOfAtoms = -1;
_numberOfParticles = -1;
// mark stream dimension variables as unset
_atomStreamWidth = -1;
_atomStreamHeight = -1;
_atomStreamSize = -1;
_particleStreamWidth = -1;
_particleStreamHeight = -1;
_particleStreamSize = -1;
_totalInverseMass = zero;
......@@ -148,9 +148,7 @@ int BrookVelocityCenterOfMassRemoval::removeVelocityCenterOfMass( Stream& veloci
// ---------------------------------------------------------------------------------------
static const char* methodName = "BrookVelocityCenterOfMassRemoval::removeVelocityCenterOfMass";
static int debug = 0;
float zero = 0.0f;
static const int debug = 1;
// ---------------------------------------------------------------------------------------
......@@ -158,6 +156,19 @@ int BrookVelocityCenterOfMassRemoval::removeVelocityCenterOfMass( Stream& veloci
BrookOpenMMFloat com[3];
getVelocityCenterOfMass( velocities, com );
(void) fprintf( getLog(), "\n%s Pre removal com: [%12.5e %12.5e %12.5e]\n", methodName, com[0], com[1], com[2] );
BrookStreamImpl& v1 = dynamic_cast<BrookStreamImpl&> (velocities.getImpl());
BrookStreamInternal* velocityStream = dynamic_cast<BrookStreamInternal*> (v1.getBrookStreamImpl());
void* velV = velocityStream->getData( 1 );
const float* vArray = (float*) velV;
int index = 0;
for( int ii = 0; ii < getNumberOfParticles(); ii++, index += 3 ){
(void) fprintf( getLog(), "V %d [%12.5e %12.5e %12.5e]\n", ii, vArray[index], vArray[index+1], vArray[index+2] );
}
(void) fflush( getLog() );
}
// calculate linear momentum via reduction
......@@ -166,17 +177,20 @@ int BrookVelocityCenterOfMassRemoval::removeVelocityCenterOfMass( Stream& veloci
BrookStreamImpl& velocityStream = dynamic_cast<BrookStreamImpl&> (velocities.getImpl());
kCalculateLinearMomentum( getMassStream()->getBrookStream(), velocityStream.getBrookStream(), getWorkStream()->getBrookStream() );
kSumLinearMomentum( (float) getComAtomStreamWidth(), (float) getNumberOfAtoms(), getWorkStream()->getBrookStream(), getLinearMomentumStream()->getBrookStream() );
kSumLinearMomentum( (float) getComParticleStreamWidth(), (float) getNumberOfParticles(), getWorkStream()->getBrookStream(), getLinearMomentumStream()->getBrookStream() );
kScale( (float) getTotalInverseMass(), getLinearMomentumStream()->getBrookStream(), getLinearMomentumStream()->getBrookStream() );
kRemoveLinearMomentum( getLinearMomentumStream()->getBrookStream(), velocityStream.getBrookStream(), velocityStream.getBrookStream() );
if( (0 || debug) && getLog() ){
BrookOpenMMFloat com[3];
getVelocityCenterOfMass( velocities, com );
(void) fprintf( getLog(), "\n%s strW=%d iatm=%d Post removal com: [%12.5e %12.5e %12.5e]\n", methodName,
getComAtomStreamWidth(), getNumberOfAtoms(), com[0], com[1], com[2] );
/*
(void) fprintf( getLog(), "LM [%12.5e %12.5e %12.5e]\n", com[0], com[1], com[2] );
(void) fprintf( getLog(), "%s strW=%d iatm=%d Post removal com: [%12.5e %12.5e %12.5e]", methodName,
getComParticleStreamWidth(), getNumberOfParticles(), com[0], com[1], com[2] );
void* linMoV = getLinearMomentumStream()->getData( 1 );
float* linMo = (float*) linMoV;
(void) fprintf( getLog(), "LM [%12.5e %12.5e %12.5e]\n", linMo[0], linMo[1], linMo[2] );
BrookStreamImpl& v1 = dynamic_cast<BrookStreamImpl&> (velocities.getImpl());
BrookStreamInternal* velocityStream = dynamic_cast<BrookStreamInternal*> (v1.getBrookStreamImpl());
......@@ -187,12 +201,14 @@ int BrookVelocityCenterOfMassRemoval::removeVelocityCenterOfMass( Stream& veloci
const float* w2 = (float*) w1;
int index = 0;
for( int ii = 0; ii < getNumberOfAtoms(); ii++, index += 3 ){
for( int ii = 0; ii < getNumberOfParticles(); ii++, index += 3 ){
(void) fprintf( getLog(), "V %d [%12.5e %12.5e %12.5e] [%12.5e %12.5e %12.5e]\n", ii,
vArray[index], vArray[index+1], vArray[index+2], w2[index], w2[index+1], w2[index+2] );
}
(void) fflush( getLog() );
*/
//exit(0);
}
......@@ -232,12 +248,12 @@ int BrookVelocityCenterOfMassRemoval::getVelocityCenterOfMass( Stream& velocitie
void* massV = getMassStream()->getData( 1);
const float* mArray = (float*) massV;
int numberOfAtoms = getNumberOfAtoms();
int numberOfParticles = getNumberOfParticles();
int index = 0;
velocityCom[0] = velocityCom[1] = velocityCom[2] = zero;
for( int ii = 0; ii < numberOfAtoms; ii++, index += 3 ){
for( int ii = 0; ii < numberOfParticles; ii++, index += 3 ){
velocityCom[0] += mArray[ii]*vArray[index];
velocityCom[1] += mArray[ii]*vArray[index+1];
velocityCom[2] += mArray[ii]*vArray[index+2];
......@@ -247,48 +263,48 @@ int BrookVelocityCenterOfMassRemoval::getVelocityCenterOfMass( Stream& velocitie
}
/**
* Get Atom stream size
* Get Particle stream size
*
* @return Atom stream size
* @return Particle stream size
*
*/
int BrookVelocityCenterOfMassRemoval::getComAtomStreamSize( void ) const {
return _atomStreamSize;
int BrookVelocityCenterOfMassRemoval::getComParticleStreamSize( void ) const {
return _particleStreamSize;
}
/**
* Get atom stream width
* Get particle stream width
*
* @return atom stream width
* @return particle stream width
*
*/
int BrookVelocityCenterOfMassRemoval::getComAtomStreamWidth( void ) const {
return _atomStreamWidth;
int BrookVelocityCenterOfMassRemoval::getComParticleStreamWidth( void ) const {
return _particleStreamWidth;
}
/**
* Get atom stream height
* Get particle stream height
*
* @return atom stream height
* @return particle stream height
*/
int BrookVelocityCenterOfMassRemoval::getComAtomStreamHeight( void ) const {
return _atomStreamHeight;
int BrookVelocityCenterOfMassRemoval::getComParticleStreamHeight( void ) const {
return _particleStreamHeight;
}
/**
* Initialize stream dimensions
*
* @param numberOfAtoms number of atoms
* @param numberOfParticles number of particles
* @param platform platform
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
*/
int BrookVelocityCenterOfMassRemoval::_initializeStreamSizes( int numberOfAtoms, const Platform& platform ){
int BrookVelocityCenterOfMassRemoval::_initializeStreamSizes( int numberOfParticles, const Platform& platform ){
// ---------------------------------------------------------------------------------------
......@@ -296,9 +312,9 @@ int BrookVelocityCenterOfMassRemoval::_initializeStreamSizes( int numberOfAtoms,
// ---------------------------------------------------------------------------------------
_atomStreamSize = getAtomStreamSize( platform );
_atomStreamWidth = getAtomStreamWidth( platform );
_atomStreamHeight = getAtomStreamHeight( platform );
_particleStreamSize = getParticleStreamSize( platform );
_particleStreamWidth = getParticleStreamWidth( platform );
_particleStreamHeight = getParticleStreamHeight( platform );
return DefaultReturnValue;
}
......@@ -322,16 +338,16 @@ int BrookVelocityCenterOfMassRemoval::_initializeStreams( const Platform& platfo
// ---------------------------------------------------------------------------------------
int atomStreamSize = getComAtomStreamSize();
int atomStreamWidth = getComAtomStreamWidth();
int particleStreamSize = getComParticleStreamSize();
int particleStreamWidth = getComParticleStreamWidth();
_streams[WorkStream] = new BrookFloatStreamInternal( BrookCommon::BrookVelocityCenterOfMassRemovalWorkStream,
atomStreamSize, atomStreamWidth,
particleStreamSize, particleStreamWidth,
BrookStreamInternal::Float3, dangleValue );
_streams[MassStream] = new BrookFloatStreamInternal( BrookCommon::BrookVelocityCenterOfMassRemovalMassStream,
atomStreamSize, atomStreamWidth,
particleStreamSize, particleStreamWidth,
BrookStreamInternal::Float, dangleValue );
......@@ -345,7 +361,7 @@ int BrookVelocityCenterOfMassRemoval::_initializeStreams( const Platform& platfo
/**
* Set masses & _totalInverseMass
*
* @param masses atomic masses
* @param masses particle masses
*
*/
......@@ -362,16 +378,16 @@ int BrookVelocityCenterOfMassRemoval::_setMasses( const std::vector<double>& mas
// check that masses vector is not larger than expected
if( (int) masses.size() > getComAtomStreamSize() ){
if( (int) masses.size() > getComParticleStreamSize() ){
std::stringstream message;
message << methodName << " mass array size=" << masses.size() << " is larger than stream size=" << getComAtomStreamSize();
message << methodName << " mass array size=" << masses.size() << " is larger than stream size=" << getComParticleStreamSize();
throw OpenMMException( message.str() );
}
// setup masses
BrookOpenMMFloat* localMasses = new BrookOpenMMFloat[getComAtomStreamSize()];
memset( localMasses, 0, sizeof( BrookOpenMMFloat )*getComAtomStreamSize() );
BrookOpenMMFloat* localMasses = new BrookOpenMMFloat[getComParticleStreamSize()];
memset( localMasses, 0, sizeof( BrookOpenMMFloat )*getComParticleStreamSize() );
int index = 0;
_totalInverseMass = (BrookOpenMMFloat) 0.0;
......@@ -419,12 +435,12 @@ int BrookVelocityCenterOfMassRemoval::setup( const std::vector<double>& masses,
const BrookPlatform brookPlatform = dynamic_cast<const BrookPlatform&> (platform);
setLog( brookPlatform.getLog() );
int numberOfAtoms = (int) masses.size();
setNumberOfAtoms( numberOfAtoms );
int numberOfParticles = (int) masses.size();
setNumberOfParticles( numberOfParticles );
// set stream sizes and then create streams
_initializeStreamSizes( numberOfAtoms, platform );
_initializeStreamSizes( numberOfParticles, platform );
_initializeStreams( platform );
_setMasses( masses );
......@@ -463,17 +479,17 @@ std::string BrookVelocityCenterOfMassRemoval::getContentsString( int level ) con
#define LOCAL_SPRINTF(a,b,c) sprintf( (a), (b), (c) );
#endif
(void) LOCAL_SPRINTF( value, "%d", getNumberOfAtoms() );
message << _getLine( tab, "Number of atoms:", value );
(void) LOCAL_SPRINTF( value, "%d", getNumberOfParticles() );
message << _getLine( tab, "Number of particles:", value );
(void) LOCAL_SPRINTF( value, "%d", getComAtomStreamWidth() );
message << _getLine( tab, "Atom stream width:", value );
(void) LOCAL_SPRINTF( value, "%d", getComParticleStreamWidth() );
message << _getLine( tab, "Particle stream width:", value );
(void) LOCAL_SPRINTF( value, "%d", getComAtomStreamHeight() );
message << _getLine( tab, "Atom stream height:", value );
(void) LOCAL_SPRINTF( value, "%d", getComParticleStreamHeight() );
message << _getLine( tab, "Particle stream height:", value );
(void) LOCAL_SPRINTF( value, "%d", getComAtomStreamSize() );
message << _getLine( tab, "Atom stream size:", value );
(void) LOCAL_SPRINTF( value, "%d", getComParticleStreamSize() );
message << _getLine( tab, "Particle stream size:", value );
(void) LOCAL_SPRINTF( value, "%.5f", getTotalInverseMass() );
message << _getLine( tab, "TotalInverseMass:", value );
......
platforms/brook/src/BrookVelocityCenterOfMassRemoval.h
View file @ 309008f7
......@@ -66,33 +66,33 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon {
~BrookVelocityCenterOfMassRemoval( );
/**
* Get atom stream width
* Get particle stream width
*
* @return atom stream width
* @return particle stream width
*/
int getComAtomStreamWidth( void ) const;
int getComParticleStreamWidth( void ) const;
/**
* Get atom stream height
* Get particle stream height
*
* @return atom stream height
* @return particle stream height
*/
int getComAtomStreamHeight( void ) const;
int getComParticleStreamHeight( void ) const;
/**
* Get atom stream size
* Get particle stream size
*
* @return atom stream size
* @return particle stream size
*/
int getComAtomStreamSize( void ) const;
int getComParticleStreamSize( void ) const;
/**
* Remove velocity center-of-mass
*
* @param velocities atom velocities
* @param velocities particle velocities
*
* @return DefaultReturnValue
*
......@@ -103,7 +103,7 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon {
/**
* Get velocity center-of-mass
*
* @param velocities atom velocities
* @param velocities particle velocities
* @param velocityCom output velocity com
*
* @return DefaultReturnValue
......@@ -115,7 +115,7 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon {
/*
* Setup of parameters
*
* @param masses atom masses
* @param masses particle masses
* @param platform Brook platform
*
* @return ErrorReturnValue value if error, else DefaultReturnValue
......@@ -184,11 +184,11 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon {
BrookOpenMMFloat _totalInverseMass;
// Atom stream dimensions
// Particle stream dimensions
int _atomStreamWidth;
int _atomStreamHeight;
int _atomStreamSize;
int _particleStreamWidth;
int _particleStreamHeight;
int _particleStreamSize;
// internal streams
......@@ -197,26 +197,26 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon {
/*
* Setup of stream dimensions
*
* @param atomStreamSize atom stream size
* @param atomStreamWidth atom stream width
* @param particleStreamSize particle stream size
* @param particleStreamWidth particle stream width
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
* */
int _initializeStreamSizes( int atomStreamSize, int atomStreamWidth );
int _initializeStreamSizes( int particleStreamSize, int particleStreamWidth );
/**
* Initialize stream dimensions
*
* @param numberOfAtoms number of atoms
* @param numberOfParticles number of particles
* @param platform platform
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
*/
int _initializeStreamSizes( int numberOfAtoms, const Platform& platform );
int _initializeStreamSizes( int numberOfParticles, const Platform& platform );
/**
* Initialize stream dimensions and streams
......@@ -232,7 +232,7 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon {
/**
* Set inverse masses
*
* @param masses atomic masses
* @param masses particle masses
*
*/
......
platforms/brook/src/BrookVerletDynamics.cpp
View file @ 309008f7
......@@ -63,19 +63,19 @@ BrookVerletDynamics::BrookVerletDynamics( ){
// ---------------------------------------------------------------------------------------
_numberOfAtoms = -1;
_numberOfParticles = -1;
// mark stream dimension variables as unset
_verletAtomStreamWidth = -1;
_verletAtomStreamHeight = -1;
_verletAtomStreamSize = -1;
_verletParticleStreamWidth = -1;
_verletParticleStreamHeight = -1;
_verletParticleStreamSize = -1;
for( int ii = 0; ii < LastStreamIndex; ii++ ){
_verletStreams[ii] = NULL;
}
_stepSize = oneMinus;
_stepSize = oneMinus;
// setup inverse sqrt masses
......@@ -167,9 +167,9 @@ int BrookVerletDynamics::updateParameters( double stepSize ){
/**
* Update
*
* @param positions atom positions
* @param velocities atom velocities
* @param forces atom forces
* @param positions particle positions
* @param velocities particle velocities
* @param forces particle forces
* @param brookShakeAlgorithm BrookShakeAlgorithm reference
* @param brookRandomNumberGenerator BrookRandomNumberGenerator reference
*
......@@ -234,8 +234,8 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities,
// diagnostics
if( PrintOn && getLog() ){
(void) fprintf( getLog(), "\nPost kupdate_md_verlet: atomStrW=%3d step=%.5f",
getVerletDynamicsAtomStreamWidth(), getStepSize() );
(void) fprintf( getLog(), "\nPost kupdate_md_verlet: particleStrW=%3d step=%.5f",
getVerletDynamicsParticleStreamWidth(), getStepSize() );
(void) fprintf( getLog(), "\nInverseMassStream\n" );
getInverseMassStream()->printToFile( getLog() );
......@@ -262,13 +262,13 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities,
kshakeh_fix1(
10.0f,
(float) getVerletDynamicsAtomStreamWidth(),
(float) getVerletDynamicsParticleStreamWidth(),
brookShakeAlgorithm.getInverseHydrogenMass(),
omega,
brookShakeAlgorithm.getShakeAtomIndicesStream()->getBrookStream(),
brookShakeAlgorithm.getShakeParticleIndicesStream()->getBrookStream(),
positionStream.getBrookStream(),
getXPrimeStream()->getBrookStream(),
brookShakeAlgorithm.getShakeAtomParameterStream()->getBrookStream(),
brookShakeAlgorithm.getShakeParticleParameterStream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons0Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons1Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons2Stream()->getBrookStream(),
......@@ -276,11 +276,11 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities,
if( (1|| PrintOn) && getLog() ){
(void) fprintf( getLog(), "\nPost kshakeh_fix1: atomStrW=%3d invMass_H=%.5f",
getVerletDynamicsAtomStreamWidth(), brookShakeAlgorithm.getInverseHydrogenMass() );
(void) fprintf( getLog(), "\nPost kshakeh_fix1: particleStrW=%3d invMass_H=%.5f",
getVerletDynamicsParticleStreamWidth(), brookShakeAlgorithm.getInverseHydrogenMass() );
(void) fprintf( getLog(), "\nShakeAtomIndicesStream\n" );
brookShakeAlgorithm.getShakeAtomIndicesStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeParticleIndicesStream\n" );
brookShakeAlgorithm.getShakeParticleIndicesStream()->printToFile( getLog() );
BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nPositionStream\n" );
......@@ -289,8 +289,8 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities,
(void) fprintf( getLog(), "\nXPrimeStream\n" );
getXPrimeStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeAtomParameterStream\n" );
brookShakeAlgorithm.getShakeAtomParameterStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeParticleParameterStream\n" );
brookShakeAlgorithm.getShakeParticleParameterStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons0\n" );
brookShakeAlgorithm.getShakeXCons0Stream()->printToFile( getLog() );
......@@ -309,7 +309,7 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities,
// second Shake gather
kshakeh_update2_fix1(
(float) getVerletDynamicsAtomStreamWidth(),
(float) getVerletDynamicsParticleStreamWidth(),
brookShakeAlgorithm.getShakeInverseMapStream()->getBrookStream(),
positionStream.getBrookStream(),
getXPrimeStream()->getBrookStream(),
......@@ -321,8 +321,8 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities,
if( ( 1 || PrintOn) && getLog() ){
(void) fprintf( getLog(), "\nPost kshakeh_update2_fix1: atomStrW=%3d",
getVerletDynamicsAtomStreamWidth() );
(void) fprintf( getLog(), "\nPost kshakeh_update2_fix1: particleStrW=%3d",
getVerletDynamicsParticleStreamWidth() );
(void) fprintf( getLog(), "\nShakeInverseMapStream\n" );
brookShakeAlgorithm.getShakeInverseMapStream()->printToFile( getLog() );
......@@ -360,35 +360,35 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities,
};
/**
* Get Atom stream size
* Get Particle stream size
*
* @return Atom stream size
* @return Particle stream size
*
*/
int BrookVerletDynamics::getVerletDynamicsAtomStreamSize( void ) const {
return _verletAtomStreamSize;
int BrookVerletDynamics::getVerletDynamicsParticleStreamSize( void ) const {
return _verletParticleStreamSize;
}
/**
* Get atom stream width
* Get particle stream width
*
* @return atom stream width
* @return particle stream width
*
*/
int BrookVerletDynamics::getVerletDynamicsAtomStreamWidth( void ) const {
return _verletAtomStreamWidth;
int BrookVerletDynamics::getVerletDynamicsParticleStreamWidth( void ) const {
return _verletParticleStreamWidth;
}
/**
* Get atom stream height
* Get particle stream height
*
* @return atom stream height
* @return particle stream height
*/
int BrookVerletDynamics::getVerletDynamicsAtomStreamHeight( void ) const {
return _verletAtomStreamHeight;
int BrookVerletDynamics::getVerletDynamicsParticleStreamHeight( void ) const {
return _verletParticleStreamHeight;
}
/**
......@@ -427,14 +427,14 @@ BrookFloatStreamInternal* BrookVerletDynamics::getInverseMassStream( void ) cons
/**
* Initialize stream dimensions
*
* @param numberOfAtoms number of atoms
* @param numberOfParticles number of particles
* @param platform platform
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
*/
int BrookVerletDynamics::_initializeStreamSizes( int numberOfAtoms, const Platform& platform ){
int BrookVerletDynamics::_initializeStreamSizes( int numberOfParticles, const Platform& platform ){
// ---------------------------------------------------------------------------------------
......@@ -442,9 +442,9 @@ int BrookVerletDynamics::_initializeStreamSizes( int numberOfAtoms, const Platfo
// ---------------------------------------------------------------------------------------
_verletAtomStreamSize = getAtomStreamSize( platform );
_verletAtomStreamWidth = getAtomStreamWidth( platform );
_verletAtomStreamHeight = getAtomStreamHeight( platform );
_verletParticleStreamSize = getParticleStreamSize( platform );
_verletParticleStreamWidth = getParticleStreamWidth( platform );
_verletParticleStreamHeight = getParticleStreamHeight( platform );
return DefaultReturnValue;
}
......@@ -464,24 +464,24 @@ int BrookVerletDynamics::_initializeStreams( const Platform& platform ){
//static const std::string methodName = "BrookVerletDynamics::_initializeStreams";
BrookOpenMMFloat dangleValue = (BrookOpenMMFloat) 0.0;
BrookOpenMMFloat dangleValue = (BrookOpenMMFloat) 0.0;
// ---------------------------------------------------------------------------------------
int sdAtomStreamSize = getVerletDynamicsAtomStreamSize();
int sdAtomStreamWidth = getVerletDynamicsAtomStreamWidth();
int sdParticleStreamSize = getVerletDynamicsParticleStreamSize();
int sdParticleStreamWidth = getVerletDynamicsParticleStreamWidth();
_verletStreams[VPrimeStream] = new BrookFloatStreamInternal( BrookCommon::VPrimeStream,
sdAtomStreamSize, sdAtomStreamWidth,
BrookStreamInternal::Float3, dangleValue );
sdParticleStreamSize, sdParticleStreamWidth,
BrookStreamInternal::Float3, dangleValue );
_verletStreams[XPrimeStream] = new BrookFloatStreamInternal( BrookCommon::XPrimeStream,
sdAtomStreamSize, sdAtomStreamWidth,
BrookStreamInternal::Float3, dangleValue );
sdParticleStreamSize, sdParticleStreamWidth,
BrookStreamInternal::Float3, dangleValue );
_verletStreams[InverseMassStream] = new BrookFloatStreamInternal( BrookCommon::InverseMassStream,
sdAtomStreamSize, sdAtomStreamWidth,
BrookStreamInternal::Float, dangleValue );
sdParticleStreamSize, sdParticleStreamWidth,
BrookStreamInternal::Float, dangleValue );
return DefaultReturnValue;
}
......@@ -501,13 +501,13 @@ int BrookVerletDynamics::_updateVerletStreams( void ){
// ---------------------------------------------------------------------------------------
int atomStreamSize = getVerletDynamicsAtomStreamSize();
int particleStreamSize = getVerletDynamicsParticleStreamSize();
BrookOpenMMFloat* inverseMass = new BrookOpenMMFloat[atomStreamSize];
memset( inverseMass, 0, atomStreamSize*sizeof( BrookOpenMMFloat ) );
BrookOpenMMFloat* inverseMass = new BrookOpenMMFloat[particleStreamSize];
memset( inverseMass, 0, particleStreamSize*sizeof( BrookOpenMMFloat ) );
int numberOfAtoms = getNumberOfAtoms();
for( int ii = 0; ii < numberOfAtoms; ii++ ){
int numberOfParticles = getNumberOfParticles();
for( int ii = 0; ii < numberOfParticles; ii++ ){
inverseMass[ii] = _inverseMasses[ii];
}
......@@ -522,7 +522,7 @@ int BrookVerletDynamics::_updateVerletStreams( void ){
/**
* Set masses
*
* @param masses atomic masses
* @param masses particle masses
*
*/
......@@ -574,12 +574,12 @@ int BrookVerletDynamics::setup( const std::vector<double>& masses, const Platfor
const BrookPlatform brookPlatform = dynamic_cast<const BrookPlatform&> (platform);
setLog( brookPlatform.getLog() );
int numberOfAtoms = (int) masses.size();
setNumberOfAtoms( numberOfAtoms );
int numberOfParticles = (int) masses.size();
setNumberOfParticles( numberOfParticles );
// set stream sizes and then create streams
_initializeStreamSizes( numberOfAtoms, platform );
_initializeStreamSizes( numberOfParticles, platform );
_initializeStreams( platform );
_setInverseMasses( masses );
......@@ -618,17 +618,17 @@ std::string BrookVerletDynamics::getContentsString( int level ) const {
#define LOCAL_SPRINTF(a,b,c) sprintf( (a), (b), (c) );
#endif
(void) LOCAL_SPRINTF( value, "%d", getNumberOfAtoms() );
message << _getLine( tab, "Number of atoms:", value );
(void) LOCAL_SPRINTF( value, "%d", getNumberOfParticles() );
message << _getLine( tab, "Number of particles:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamWidth() );
message << _getLine( tab, "Atom stream width:", value );
(void) LOCAL_SPRINTF( value, "%d", getParticleStreamWidth() );
message << _getLine( tab, "Particle stream width:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamHeight() );
message << _getLine( tab, "Atom stream height:", value );
(void) LOCAL_SPRINTF( value, "%d", getParticleStreamHeight() );
message << _getLine( tab, "Particle stream height:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamSize() );
message << _getLine( tab, "Atom stream size:", value );
(void) LOCAL_SPRINTF( value, "%d", getParticleStreamSize() );
message << _getLine( tab, "Particle stream size:", value );
(void) LOCAL_SPRINTF( value, "%.5f", getStepSize() );
message << _getLine( tab, "Step size:", value );
......
platforms/brook/src/BrookVerletDynamics.h
View file @ 309008f7
......@@ -85,28 +85,28 @@ class BrookVerletDynamics : public BrookCommon {
const BrookOpenMMFloat* getDerivedParameters( void ) const;
/**
* Get VerletDynamics atom stream width
* Get VerletDynamics particle stream width
*
* @return atom stream width
* @return particle stream width
*/
int getVerletDynamicsAtomStreamWidth( void ) const;
int getVerletDynamicsParticleStreamWidth( void ) const;
/**
* Get VerletDynamics atom stream height
* Get VerletDynamics particle stream height
*
* @return atom stream height
* @return particle stream height
*/
int getVerletDynamicsAtomStreamHeight( void ) const;
int getVerletDynamicsParticleStreamHeight( void ) const;
/**
* Get VerletDynamics atom stream size
* Get VerletDynamics particle stream size
*
* @return atom stream size
* @return particle stream size
*/
int getVerletDynamicsAtomStreamSize( void ) const;
int getVerletDynamicsParticleStreamSize( void ) const;
/**
* Update parameters
......@@ -122,9 +122,9 @@ class BrookVerletDynamics : public BrookCommon {
/**
* Update
*
* @param positions atom positions
* @param velocities atom velocities
* @param forces atom forces
* @param positions particle positions
* @param velocities particle velocities
* @param forces particle forces
* @param brookShakeAlgorithm BrookShakeAlgorithm reference
*
* @return DefaultReturnValue
......@@ -146,7 +146,7 @@ class BrookVerletDynamics : public BrookCommon {
/*
* Setup of VerletDynamics parameters
*
* @param masses atom masses
* @param masses particle masses
* @param platform Brook platform
*
* @return ErrorReturnValue value if error, else DefaultReturnValue
......@@ -206,11 +206,11 @@ class BrookVerletDynamics : public BrookCommon {
BrookOpenMMFloat _stepSize;
// Atom stream dimensions
// Particle stream dimensions
int _verletAtomStreamWidth;
int _verletAtomStreamHeight;
int _verletAtomStreamSize;
int _verletParticleStreamWidth;
int _verletParticleStreamHeight;
int _verletParticleStreamSize;
/*
* Update streams
......@@ -243,26 +243,26 @@ class BrookVerletDynamics : public BrookCommon {
/*
* Setup of stream dimensions
*
* @param atomStreamSize atom stream size
* @param atomStreamWidth atom stream width
* @param particleStreamSize particle stream size
* @param particleStreamWidth particle stream width
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
* */
int _initializeStreamSizes( int atomStreamSize, int atomStreamWidth );
int _initializeStreamSizes( int particleStreamSize, int particleStreamWidth );
/**
* Initialize stream dimensions
*
* @param numberOfAtoms number of atoms
* @param numberOfParticles number of particles
* @param platform platform
*
* @return ErrorReturnValue if error, else DefaultReturnValue
*
*/
int _initializeStreamSizes( int numberOfAtoms, const Platform& platform );
int _initializeStreamSizes( int numberOfParticles, const Platform& platform );
/**
* Initialize stream dimensions and streams
......@@ -278,7 +278,7 @@ class BrookVerletDynamics : public BrookCommon {
/**
* Set masses
*
* @param masses atomic masses
* @param masses particle masses
*
*/
......
platforms/brook/src/OpenMMBrookInterface.cpp
View file @ 309008f7
......@@ -56,9 +56,16 @@ OpenMMBrookInterface::OpenMMBrookInterface( void ){
// ---------------------------------------------------------------------------------------
_numberOfAtoms = 0;
_numberOfParticles = 0;
_brookBonded = NULL;
_brookNonBonded = NULL;
_brookGbsa = NULL;
_positions = NULL;
_velocities = NULL;
_forces = NULL;
_refForceField = NULL;
_log = NULL;
......@@ -198,215 +205,98 @@ int OpenMMBrookInterface::setRBTorsionForceParameters( BrookBondParameters* broo
*
*/
int OpenMMBrookInterface::setLJ14( BrookBondParameters* brookBondParameters ){
int OpenMMBrookInterface::setNonBonded14ForceParameters( BrookBondParameters* brookBondParameters ){
return _setBondParameters( LJ14Index, brookBondParameters );
}
/**
* Initialize the kernel, setting up the values of all the force field parameters.
* Get positions stream
*
* @param bondIndices the two atoms connected by each bond term
* @param bondParameters the force parameters (length, k) for each bond term
* @param angleIndices the three atoms connected by each angle term
* @param angleParameters the force parameters (angle, k) for each angle term
* @param periodicTorsionIndices the four atoms connected by each periodic torsion term
* @param periodicTorsionParameters the force parameters (k, phase, periodicity) for each periodic torsion term
* @param rbTorsionIndices the four atoms connected by each Ryckaert-Bellemans torsion term
* @param rbTorsionParameters the coefficients (in order of increasing powers) for each Ryckaert-Bellemans torsion term
* @param bonded14Indices each element contains the indices of two atoms whose nonbonded interactions should be reduced since
* they form a bonded 1-4 pair
* @param lj14Scale the factor by which van der Waals interactions should be reduced for bonded 1-4 pairs
* @param coulomb14Scale the factor by which Coulomb interactions should be reduced for bonded 1-4 pairs
* @param exclusions the i'th element lists the indices of all atoms with which the i'th atom should not interact through
* nonbonded forces. Bonded 1-4 pairs are also included in this list, since they should be omitted from
* the standard nonbonded calculation.
* @param nonbondedParameters the nonbonded force parameters (charge, sigma, epsilon) for each atom
* @param nonbondedMethod the method to use for handling long range nonbonded interactions
* @param nonbondedCutoff the cutoff distance for nonbonded interactions (if nonbondedMethod involves a cutoff)
* @param periodicBoxSize the size of the periodic box (if nonbondedMethod involves a periodic boundary conditions)
* @return particle positions
*
*/
void OpenMMBrookInterface::initialize(
const vector<vector<int> >& bondIndices, const vector<vector<double> >& bondParameters,
const vector<vector<int> >& angleIndices, const vector<vector<double> >& angleParameters,
const vector<vector<int> >& periodicTorsionIndices, const vector<vector<double> >& periodicTorsionParameters,
const vector<vector<int> >& rbTorsionIndices, const vector<vector<double> >& rbTorsionParameters,
const vector<vector<int> >& bonded14Indices, double lj14Scale, double coulomb14Scale,
const vector<set<int> >& exclusions, const vector<vector<double> >& nonbondedParameters,
//NonbondedMethod nonbondedMethod,
double nonbondedCutoff, double periodicBoxSize[3] ){
// ---------------------------------------------------------------------------------------
static const std::string methodName = "OpenMMBrookInterface::initialize";
// ---------------------------------------------------------------------------------------
FILE* log = getLog();
/*
_numberOfAtoms = nonbondedParameters.size();
// ---------------------------------------------------------------------------------------
// bonded
if( _brookBonded ){
delete _brookBonded;
}
_brookBonded = new BrookBonded();
_brookBonded->setLog( log );
_brookBonded->setup( _numberOfAtoms,
bondIndices, bondParameters,
angleIndices, angleParameters,
periodicTorsionIndices, periodicTorsionParameters,
rbTorsionIndices, rbTorsionParameters,
bonded14Indices, nonbondedParameters,
lj14Scale, coulomb14Scale, getPlatform() );
// echo contents
if( log ){
std::string contents = _brookBonded->getContentsString( );
(void) fprintf( log, "%s brookBonded::contents\n%s", methodName.c_str(), contents.c_str() );
(void) fflush( log );
}
// ---------------------------------------------------------------------------------------
// nonbonded
if( _brookNonBonded ){
delete _brookNonBonded;
}
_brookNonBonded = new BrookNonBonded();
_brookNonBonded->setLog( log );
_brookNonBonded->setup( _numberOfAtoms, nonbondedParameters, exclusions, getPlatform() );
// echo contents
if( log ){
std::string contents = _brookNonBonded->getContentsString( );
(void) fprintf( log, "%s brookNonBonded::contents\n%s", methodName.c_str(), contents.c_str() );
(void) fflush( log );
}
// ---------------------------------------------------------------------------------------
// used for calculating energy
_referenceCalcNonbondedForceKernel = new ReferenceCalcNonbondedForceKernel( getName(), getPlatform() );
_referenceCalcNonbondedForceKernel->initialize( bondIndices, bondParameters,
angleIndices, angleParameters,
periodicTorsionIndices, periodicTorsionParameters,
rbTorsionIndices, rbTorsionParameters,
bonded14Indices, lj14Scale, coulomb14Scale,
exclusions, nonbondedParameters,
nonbondedMethod, nonbondedCutoff, periodicBoxSize );
_refForceField = new NonbondedForce( _numberOfAtoms, bondIndices.size(), angleIndices.size(),
periodicTorsionIndices.size(), rbTorsionIndices.size() );
// bonds
vector<vector<int> >::const_iterator bondI_it = bondIndices.begin();
vector<vector<double> >::const_iterator bondP_it = bondParameters.begin();
for( unsigned int ii = 0; ii < bondIndices.size(); ii++, bondI_it++, bondP_it++ ){
const vector<int> bondInd = *bondI_it;
const vector<double> bondPrm = *bondP_it;
_refForceField->setBondParameters( ii, bondInd[0], bondInd[1], bondPrm[0], bondPrm[1] );
printf( "%s Bond: [%d %d] [%.5e %.5e ]\n", methodName.c_str(),
bondInd[0], bondInd[1], bondPrm[0], bondPrm[1] ); fflush( stdout );
}
// angles
vector<vector<int> >::const_iterator angleI_it = angleIndices.begin();
vector<vector<double> >::const_iterator angleP_it = angleParameters.begin();
for( unsigned int ii = 0; ii < angleIndices.size(); ii++, angleI_it++, angleP_it++ ){
const vector<int> angleInd = *angleI_it;
const vector<double> anglePrm = *angleP_it;
_refForceField->setAngleParameters( ii, angleInd[0], angleInd[1], angleInd[2], anglePrm[0], anglePrm[1] );
}
// periodicTorsions
vector<vector<int> >::const_iterator periodicTorsionI_it = periodicTorsionIndices.begin();
vector<vector<double> >::const_iterator periodicTorsionP_it = periodicTorsionParameters.begin();
for( unsigned int ii = 0; ii < periodicTorsionIndices.size(); ii++, periodicTorsionI_it++, periodicTorsionP_it++ ){
const vector<int> periodicTorsionInd = *periodicTorsionI_it;
const vector<double> periodicTorsionPrm = *periodicTorsionP_it;
_refForceField->setPeriodicTorsionParameters( ii, periodicTorsionInd[0], periodicTorsionInd[1], periodicTorsionInd[2], periodicTorsionInd[3],
(int) (periodicTorsionPrm[2] + 0.001), periodicTorsionPrm[1], periodicTorsionPrm[0] );
printf( "PeriodicTor: [%d %d %d %d] [%.5e %.5e %.5e]\n", periodicTorsionInd[0], periodicTorsionInd[1], periodicTorsionInd[2], periodicTorsionInd[3],
periodicTorsionPrm[2], periodicTorsionPrm[1], periodicTorsionPrm[0] ); fflush( stdout );
}
// rbTorsions
vector<vector<int> >::const_iterator rbTorsionI_it = rbTorsionIndices.begin();
vector<vector<double> >::const_iterator rbTorsionP_it = rbTorsionParameters.begin();
for( unsigned int ii = 0; ii < rbTorsionIndices.size(); ii++, rbTorsionI_it++, rbTorsionP_it++ ){
const vector<int> rbTorsionInd = *rbTorsionI_it;
const vector<double> rbTorsionPrm = *rbTorsionP_it;
_refForceField->setRBTorsionParameters( ii, rbTorsionInd[0], rbTorsionInd[1], rbTorsionInd[2], rbTorsionInd[3],
rbTorsionPrm[0], rbTorsionPrm[1], rbTorsionPrm[2], rbTorsionPrm[3],
rbTorsionPrm[4], rbTorsionPrm[5] );
*/
/*
printf( "RbTor: [%d %d %d %d] [%.5e %.5e %.5e %.5e %.5e %.5e]\n", rbTorsionInd[0], rbTorsionInd[1], rbTorsionInd[2], rbTorsionInd[3],
rbTorsionPrm[0], rbTorsionPrm[1], rbTorsionPrm[2], rbTorsionPrm[3], rbTorsionPrm[4], rbTorsionPrm[5] ); fflush( stdout );
}
*/
// nonbonded
/*
for( unsigned int ii = 0; ii < nonbondedParameters.size(); ii++ ){
vector<double> nonbondedParameterVector
= nonbondedParameters[ii];
double c6 = nonbondedParameterVector[1];
double c12 = nonbondedParameterVector[2];
double charge = nonbondedParameterVector[0];
BrookStreamImpl* OpenMMBrookInterface::getParticlePositions( void ){
return _positions;
}
// int index, double charge, double radius, double depth
/**
* Set positions stream
*
* @param positions Brook stream containing particle positions
*
* @return DefaultReturnValue
*
*/
int OpenMMBrookInterface::setParticlePositions( BrookStreamImpl* positions ){
_positions = positions;
return DefaultReturnValue;
}
_refForceField->setAtomParameters( ii, charge, c6, c12 );
/**
* Get velocities stream
*
* @return particle velocities
*
*/
BrookStreamImpl* OpenMMBrookInterface::getParticleVelocities( void ){
return _velocities;
}
}
*/
/**
* Set velocities stream
*
* @param velocities Brook stream containing particle velocities
*
* @return DefaultReturnValue
*
*/
int OpenMMBrookInterface::setParticleVelocities( BrookStreamImpl* velocities ){
_velocities = velocities;
return DefaultReturnValue;
}
// ---------------------------------------------------------------------------------------
/**
* Get forces stream
*
* @return ParticleForces
*
*/
BrookStreamImpl* OpenMMBrookInterface::getParticleForces( void ){
return _forces;
}
return;
/**
* Set forces stream
*
* @param forces Brook stream containing particle forces
*
* @return DefaultReturnValue
*
*/
int OpenMMBrookInterface::setParticleForces( BrookStreamImpl* forces ){
_forces = forces;
return DefaultReturnValue;
}
/**
* Execute the kernel to calculate the bonded & nonbonded forces
* Compute forces
*
* @param positions stream of type Double3 containing the position (x, y, z) of each atom
* @param forces stream of type Double3 containing the force (x, y, z) on each atom. On entry, this contains the forces that
* have been calculated so far. The kernel should add its own forces to the values already in the stream.
* @param context context
*
*/
void OpenMMBrookInterface::executeForces( const Stream& positions, Stream& forces ){
void OpenMMBrookInterface::computeForces( OpenMMContextImpl& context ){
// ---------------------------------------------------------------------------------------
static const std::string methodName = "OpenMMBrookInterface::executeForces";
static const int I_Stream = 0;
static const int J_Stream = 1;
static const int K_Stream = 2;
static const int L_Stream = 3;
static const int PrintOn = 0;
static const int MaxErrorMessages = 2;
static int ErrorMessages = 0;
......@@ -417,459 +307,47 @@ void OpenMMBrookInterface::executeForces( const Stream& positions, Stream& force
// ---------------------------------------------------------------------------------------
const BrookStreamImpl& positionStreamC = dynamic_cast<const BrookStreamImpl&> (positions.getImpl());
BrookStreamImpl& positionStream = const_cast<BrookStreamImpl&> (positionStreamC);
BrookStreamImpl& forceStream = dynamic_cast<BrookStreamImpl&> (forces.getImpl());
// nonbonded forces
// added charge stream to knbforce_CDLJ4
// libs generated from ~/src/gmxgpu-nsqOpenMM
BrookFloatStreamInternal** nonbondedForceStreams = _brookNonBonded->getForceStreams();
float epsfac = 138.935485f;
knbforce_CDLJ4(
(float) _brookNonBonded->getNumberOfAtoms(),
(float) _brookNonBonded->getAtomSizeCeiling(),
(float) _brookNonBonded->getDuplicationFactor(),
(float) _brookNonBonded->getAtomStreamHeight( ),
(float) _brookNonBonded->getAtomStreamWidth( ),
(float) _brookNonBonded->getJStreamWidth( ),
(float) _brookNonBonded->getPartialForceStreamWidth( ),
epsfac,
dummyParameters,
positionStream.getBrookStream(),
_brookNonBonded->getChargeStream()->getBrookStream(),
_brookNonBonded->getOuterVdwStream()->getBrookStream(),
_brookNonBonded->getInnerSigmaStream()->getBrookStream(),
_brookNonBonded->getInnerEpsilonStream()->getBrookStream(),
_brookNonBonded->getExclusionStream()->getBrookStream(),
nonbondedForceStreams[0]->getBrookStream(),
nonbondedForceStreams[1]->getBrookStream(),
nonbondedForceStreams[2]->getBrookStream(),
nonbondedForceStreams[3]->getBrookStream()
);
/*
float zerof = 0.0f;
nonbondedForceStreams[0]->fillWithValue( &zerof );
nonbondedForceStreams[1]->fillWithValue( &zerof );
nonbondedForceStreams[2]->fillWithValue( &zerof );
nonbondedForceStreams[3]->fillWithValue( &zerof );
*/
// diagnostics
if( 1 && PrintOn ){
(void) fprintf( getLog(), "\nPost knbforce_CDLJ4: atoms=%6d ceiling=%3d dupFac=%3d", _brookNonBonded->getNumberOfAtoms(),
_brookNonBonded->getAtomSizeCeiling(),
_brookNonBonded->getDuplicationFactor() );
(void) fprintf( getLog(), "\n hght=%6d width=%3d jWid=%3d", _brookNonBonded->getAtomStreamHeight( ),
_brookNonBonded->getAtomStreamWidth( ),
_brookNonBonded->getJStreamWidth( ) );
(void) fprintf( getLog(), "\n pFrc=%6d eps=%12.5e\n", _brookNonBonded->getPartialForceStreamWidth( ), epsfac );
(void) fprintf( getLog(), "\nOuterVdwStreamd\n" );
_brookNonBonded->getOuterVdwStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nInnerSigmaStream\n" );
_brookNonBonded->getInnerSigmaStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nInnerEpsilonStream\n" );
_brookNonBonded->getInnerEpsilonStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nExclusionStream\n" );
_brookNonBonded->getExclusionStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nChargeStream\n" );
_brookNonBonded->getChargeStream()->printToFile( getLog() );
for( int ii = 0; ii < 4; ii++ ){
(void) fprintf( getLog(), "\nForce stream %d\n", ii );
nonbondedForceStreams[ii]->printToFile( getLog() );
}
}
// ---------------------------------------------------------------------------------------
// gather forces
kMergeFloat3_4_nobranch( (float) _brookNonBonded->getDuplicationFactor(),
(float) _brookNonBonded->getAtomStreamWidth(),
(float) _brookNonBonded->getPartialForceStreamWidth(),
(float) _brookNonBonded->getNumberOfAtoms(),
(float) _brookNonBonded->getAtomSizeCeiling(),
(float) _brookNonBonded->getOuterLoopUnroll(),
nonbondedForceStreams[0]->getBrookStream(),
nonbondedForceStreams[1]->getBrookStream(),
nonbondedForceStreams[2]->getBrookStream(),
nonbondedForceStreams[3]->getBrookStream(),
forceStream.getBrookStream() );
// diagnostics
if( 0 && PrintOn ){
(void) fprintf( getLog(), "\nNB forces" );
BrookStreamInternal* brookStreamInternalF = forceStream.getBrookStreamImpl();
brookStreamInternalF->printToFile( getLog() );
BrookStreamImpl* positions = getParticlePositions();
BrookStreamImpl* forces = getParticleForces();
if( _brookNonBonded ){
_brookNonBonded->computeForces( *positions, *forces );
}
// ---------------------------------------------------------------------------------------
// bonded
epsfac = (float) (_brookBonded->getLJ_14Scale()*_brookBonded->getCoulombFactor());
float width = (float) (_brookBonded->getInverseMapStreamWidth());
// bonded forces
BrookFloatStreamInternal** bondedParameters = _brookBonded->getBondedParameterStreams();
BrookFloatStreamInternal** bondedForceStreams = _brookBonded->getBondedForceStreams();
BrookFloatStreamInternal** inverseStreamMaps[4];
inverseStreamMaps[0] = _brookBonded->getInverseStreamMapsStreams( 0 );
inverseStreamMaps[1] = _brookBonded->getInverseStreamMapsStreams( 1 );
inverseStreamMaps[2] = _brookBonded->getInverseStreamMapsStreams( 2 );
inverseStreamMaps[3] = _brookBonded->getInverseStreamMapsStreams( 3 );
kbonded_CDLJ( epsfac,
(float) bondedForceStreams[0]->getStreamWidth(),
dummyParameters,
positionStream.getBrookStream(),
_brookBonded->getChargeStream()->getBrookStream(),
_brookBonded->getAtomIndicesStream()->getBrookStream(),
bondedParameters[0]->getBrookStream(),
bondedParameters[1]->getBrookStream(),
bondedParameters[2]->getBrookStream(),
bondedParameters[3]->getBrookStream(),
bondedParameters[4]->getBrookStream(),
bondedForceStreams[0]->getBrookStream(),
bondedForceStreams[1]->getBrookStream(),
bondedForceStreams[2]->getBrookStream(),
bondedForceStreams[3]->getBrookStream() );
// diagnostics
if( 1 && PrintOn ){
int countPrintInvMap[4] = { 3, 5, 2, 4 };
(void) fprintf( getLog(), "\nPost kbonded_CDLJ: epsFac=%.6f %.6f %.6f", epsfac, _brookBonded->getLJ_14Scale(), _brookBonded->getCoulombFactor());
(void) fprintf( getLog(), "\nAtom indices stream\n" );
_brookBonded->getAtomIndicesStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nCharge stream\n" );
_brookBonded->getChargeStream()->printToFile( getLog() );
for( int ii = 0; ii < 5; ii++ ){
(void) fprintf( getLog(), "\nParam stream %d\n", ii );
bondedParameters[ii]->printToFile( getLog() );
}
for( int ii = 0; ii < 4; ii++ ){
(void) fprintf( getLog(), "\nForce stream %d\n", ii );
bondedForceStreams[ii]->printToFile( getLog() );
}
/*
(void) fprintf( getLog(), "\nNB1 forces" );
BrookStreamInternal* brookStreamInternalF = forceStream.getBrookStreamImpl();
brookStreamInternalF->printToFile( getLog() );
*/
if( _brookBonded ){
(void) fprintf( getLog(), "\nInverse map streams -- K_Stream cnt=%d\n", _brookBonded->getInverseMapStreamCount( K_Stream ) );
for( int ii = 0; ii < 4; ii++ ){
for( int jj = 0; jj < countPrintInvMap[ii]; jj++ ){
(void) fprintf( getLog(), "\n Inverse map streams index=%d %d\n", ii, jj );
inverseStreamMaps[ii][jj]->printToFile( getLog() );
_brookBonded->computeForces( *positions, *forces );
// diagnostics
if( 1 && PrintOn ){
/*
(void) fprintf( getLog(), "\nFinal NB & bonded forces" );
BrookStreamInternal* brookStreamInternalF = forceStream.getBrookStreamImpl();
brookStreamInternalF->printToFile( getLog() );
void* dataV = brookStreamInternalF->getData(1);
float* data = (float*) dataV;
(void) fprintf( getLog(), "\nFinal NB & bonded forces RAW\n" );
for( int ii = 0; ii < _brookNonBonded->getNumberOfParticles()*3; ii += 3 ){
(void) fprintf( getLog(), "%d [%.6e %.6e %.6e]\n", ii, data[ii], data[ii+1], data[ii+2] );
}
}
}
// gather forces
if( _brookBonded->getInverseMapStreamCount( I_Stream ) == 3 && _brookBonded->getInverseMapStreamCount( K_Stream ) == 3 ){
kinvmap_gather3_3( width,
inverseStreamMaps[I_Stream][0]->getBrookStream(),
inverseStreamMaps[I_Stream][1]->getBrookStream(),
inverseStreamMaps[I_Stream][2]->getBrookStream(),
bondedForceStreams[I_Stream]->getBrookStream(),
inverseStreamMaps[K_Stream][0]->getBrookStream(),
inverseStreamMaps[K_Stream][1]->getBrookStream(),
inverseStreamMaps[K_Stream][2]->getBrookStream(),
bondedForceStreams[K_Stream]->getBrookStream(),
forceStream.getBrookStream(), forceStream.getBrookStream() );
} else if( _brookBonded->getInverseMapStreamCount( I_Stream ) == 3 && _brookBonded->getInverseMapStreamCount( K_Stream ) == 4 ){
kinvmap_gather3_4( width,
inverseStreamMaps[I_Stream][0]->getBrookStream(),
inverseStreamMaps[I_Stream][1]->getBrookStream(),
inverseStreamMaps[I_Stream][2]->getBrookStream(),
bondedForceStreams[I_Stream]->getBrookStream(),
inverseStreamMaps[K_Stream][0]->getBrookStream(),
inverseStreamMaps[K_Stream][1]->getBrookStream(),
inverseStreamMaps[K_Stream][2]->getBrookStream(),
inverseStreamMaps[K_Stream][3]->getBrookStream(),
bondedForceStreams[K_Stream]->getBrookStream(),
forceStream.getBrookStream(), forceStream.getBrookStream() );
} else if( _brookBonded->getInverseMapStreamCount( I_Stream ) == 3 && _brookBonded->getInverseMapStreamCount( K_Stream ) == 5 ){
kinvmap_gather3_5( width,
inverseStreamMaps[I_Stream][0]->getBrookStream(),
inverseStreamMaps[I_Stream][1]->getBrookStream(),
inverseStreamMaps[I_Stream][2]->getBrookStream(),
bondedForceStreams[I_Stream]->getBrookStream(),
inverseStreamMaps[K_Stream][0]->getBrookStream(),
inverseStreamMaps[K_Stream][1]->getBrookStream(),
inverseStreamMaps[K_Stream][2]->getBrookStream(),
inverseStreamMaps[K_Stream][3]->getBrookStream(),
inverseStreamMaps[K_Stream][4]->getBrookStream(),
bondedForceStreams[K_Stream]->getBrookStream(),
forceStream.getBrookStream(), forceStream.getBrookStream() );
} else {
// case not handled -- throw an exception
if( _brookBonded->getLog() && ErrorMessages++ < MaxErrorMessages ){
(void) fprintf( _brookBonded->getLog(), "%s case: I-map=%d K-map=%d -- not handled.\n",
methodName.c_str(), _brookBonded->getInverseMapStreamCount( I_Stream ),
_brookBonded->getInverseMapStreamCount( K_Stream ) );
(void) fflush( _brookBonded->getLog() );
}
kinvmap_gather3_3( width,
inverseStreamMaps[I_Stream][0]->getBrookStream(),
inverseStreamMaps[I_Stream][1]->getBrookStream(),
inverseStreamMaps[I_Stream][2]->getBrookStream(),
bondedForceStreams[I_Stream]->getBrookStream(),
inverseStreamMaps[K_Stream][0]->getBrookStream(),
inverseStreamMaps[K_Stream][1]->getBrookStream(),
inverseStreamMaps[K_Stream][2]->getBrookStream(),
bondedForceStreams[K_Stream]->getBrookStream(),
forceStream.getBrookStream(), forceStream.getBrookStream() );
/*
std::stringstream message;
message << methodName << "I-maps=" << _brookBonded->getInverseMapStreamCount( I_Stream ) << " and " <<
"K-maps=" << _brookBonded->getInverseMapStreamCount( K_Stream ) << " not handled.";
throw OpenMMException( message.str() );
*/
}
// diagnostics
if( 0 && PrintOn ){
(void) fprintf( getLog(), "\nPost 3_4/3_5 && NB forces" );
BrookStreamInternal* brookStreamInternalF = forceStream.getBrookStreamImpl();
brookStreamInternalF->printToFile( getLog() );
}
if( _brookBonded->getInverseMapStreamCount( J_Stream ) == 5 && _brookBonded->getInverseMapStreamCount( L_Stream ) == 2 ){
kinvmap_gather5_2( width,
inverseStreamMaps[J_Stream][0]->getBrookStream(),
inverseStreamMaps[J_Stream][1]->getBrookStream(),
inverseStreamMaps[J_Stream][2]->getBrookStream(),
inverseStreamMaps[J_Stream][3]->getBrookStream(),
inverseStreamMaps[J_Stream][4]->getBrookStream(),
bondedForceStreams[J_Stream]->getBrookStream(),
inverseStreamMaps[L_Stream][0]->getBrookStream(),
inverseStreamMaps[L_Stream][1]->getBrookStream(),
bondedForceStreams[L_Stream]->getBrookStream(),
forceStream.getBrookStream(), forceStream.getBrookStream() );
*/
} else {
// case not handled -- throw an exception
if( _brookBonded->getLog() && ErrorMessages++ < MaxErrorMessages ){
(void) fprintf( _brookBonded->getLog(), "%s case: J-map=%d L-map=%d -- not handled.\n",
methodName.c_str(), _brookBonded->getInverseMapStreamCount( J_Stream ),
_brookBonded->getInverseMapStreamCount( L_Stream ) );
(void) fflush( _brookBonded->getLog() );
}
kinvmap_gather5_2( width,
inverseStreamMaps[J_Stream][0]->getBrookStream(),
inverseStreamMaps[J_Stream][1]->getBrookStream(),
inverseStreamMaps[J_Stream][2]->getBrookStream(),
inverseStreamMaps[J_Stream][3]->getBrookStream(),
inverseStreamMaps[J_Stream][4]->getBrookStream(),
bondedForceStreams[J_Stream]->getBrookStream(),
inverseStreamMaps[L_Stream][0]->getBrookStream(),
inverseStreamMaps[L_Stream][1]->getBrookStream(),
bondedForceStreams[L_Stream]->getBrookStream(),
forceStream.getBrookStream(), forceStream.getBrookStream() );
/*
std::stringstream message;
message << methodName << "J-maps=" << _brookBonded->getInverseMapStreamCount( J_Stream ) << " and " <<
"L-maps=" << _brookBonded->getInverseMapStreamCount( L_Stream ) << " not handled.";
throw OpenMMException( message.str() );
*/
}
// diagnostics
if( 1 && PrintOn ){
(void) fprintf( getLog(), "\nFinal NB & bonded forces" );
BrookStreamInternal* brookStreamInternalF = forceStream.getBrookStreamImpl();
brookStreamInternalF->printToFile( getLog() );
/*
void* dataV = brookStreamInternalF->getData(1);
float* data = (float*) dataV;
(void) fprintf( getLog(), "\nFinal NB & bonded forces RAW\n" );
for( int ii = 0; ii < _brookNonBonded->getNumberOfAtoms()*3; ii += 3 ){
(void) fprintf( getLog(), "%d [%.6e %.6e %.6e]\n", ii, data[ii], data[ii+1], data[ii+2] );
}
*/
// GBSA OBC forces
if( _brookGbsa ){
_brookGbsa->computeForces( *positions, *forces );
}
// ---------------------------------------------------------------------------------------
}
/**
* Execute the kernel to calculate the energy.
*
* @param positions atom positions
*
* @return potential energy due to the NonbondedForce
* Currently always return 0.0 since energies not calculated on gpu
*
*/
double OpenMMBrookInterface::executeEnergy( const Stream& atomPositions ){
// ---------------------------------------------------------------------------------------
//static const std::string methodName = "OpenMMBrookInterface::executeEnergy";
// ---------------------------------------------------------------------------------------
const BrookStreamImpl& positionStreamC = dynamic_cast<const BrookStreamImpl&> (atomPositions.getImpl());
BrookStreamImpl& positionStream = const_cast<BrookStreamImpl&> (positionStreamC);
BrookOpenMMFloat* positionsF = (BrookOpenMMFloat*) positionStream.getData();
OpenMMContext* context = getReferenceOpenMMContext( atomPositions.getSize() );
vector<Vec3> positions( positionStream.getSize() );
int index = 0;
for( int ii = 0; ii < positionStream.getSize(); ii++, index += 3 ){
positions[ii] = Vec3( positionsF[index], positionsF[index+1], positionsF[index+2] );
}
context->setPositions(positions);
State state = context->getState( State::Energy );
double energy = state.getPotentialEnergy();
(void) fprintf( stdout, "BrookCalcStandardMMForceFieldKernel::executeEnergy E=%.5e\n", energy );
for( int ii = 0; ii < positionStream.getSize(); ii++, index += 3 ){
(void) fprintf( stdout, " %5d Pos[%.5f %.5f %.5f]\n", ii, positions[ii][0], positions[ii][1], positions[ii][2] );
}
fflush( stdout );
return energy;
}
/**
* Get reference Context
*
* @param numberOfAtoms number of atoms
*
* @return OpenMMContext
*
*/
OpenMMContext* OpenMMBrookInterface::getReferenceOpenMMContext( int numberOfAtoms ){
// ---------------------------------------------------------------------------------------
//static const std::string methodName = "OpenMMBrookInterface::getReferenceOpenMMContext";
// ---------------------------------------------------------------------------------------
if( _refOpenMMContext == NULL ){
_referencePlatform = new ReferencePlatform();
_refSystem = new System( numberOfAtoms, 0 );
_refVerletIntegrator = new VerletIntegrator( 0.01 );
_refSystem->addForce( _refForceField );
_refOpenMMContext = new OpenMMContext( *_refSystem, *_refVerletIntegrator, *_referencePlatform );
}
return _refOpenMMContext;
}
/**
* Execute the kernel to calculate the energy.
*
* @param positions atom positions
*
* @return potential energy due to the NonbondedForce
* Currently always return 0.0 since energies not calculated on gpu
*
*/
double OpenMMBrookInterface::executeEnergyOld( const Stream& atomPositions ){
// ---------------------------------------------------------------------------------------
//static const std::string methodName = "OpenMMBrookInterface::executeEnergy";
// ---------------------------------------------------------------------------------------
const BrookStreamImpl& positionStreamC = dynamic_cast<const BrookStreamImpl&> (atomPositions.getImpl());
BrookStreamImpl& positionStream = const_cast<BrookStreamImpl&> (positionStreamC);
BrookOpenMMFloat* positionsF = (BrookOpenMMFloat*) positionStream.getData();
ReferencePlatform refPlatform;
System system( atomPositions.getSize(), 0);
VerletIntegrator integrator( 0.01 );
system.addForce( _refForceField );
OpenMMContext context( system, integrator, refPlatform );
vector<Vec3> positions( positionStream.getSize() );
int index = 0;
for( int ii = 0; ii < positionStream.getSize(); ii++, index += 3 ){
positions[ii] = Vec3( positionsF[index], positionsF[index+1], positionsF[index+2] );
}
context.setPositions(positions);
State state = context.getState( State::Energy );
double energy = state.getPotentialEnergy();
//delete forceField;
// (void) fprintf( stdout, "OpenMMBrookInterface::executeEnergy E=%.5e\n", energy ); fflush( stdout );
return energy;
}
platforms/brook/src/OpenMMBrookInterface.h
View file @ 309008f7
......@@ -34,16 +34,16 @@
#include "kernels.h"
#include "../../reference/src/SimTKUtilities/SimTKOpenMMRealType.h"
#include "BrookBondParameters.h"
#include "BrookBonded.h"
#include "BrookNonBonded.h"
#include "BrookGbsa.h"
#include "NonbondedForce.h"
#include "OpenMMContext.h"
#include "System.h"
#include "ReferencePlatform.h"
#include "VerletIntegrator.h"
class BrookBondParameters;
namespace OpenMM {
/**
......@@ -57,76 +57,16 @@ class OpenMMBrookInterface {
~OpenMMBrookInterface();
/**
* Initialize the kernel, setting up the values of all the force field parameters.
*
* @param bondIndices the two atoms connected by each bond term
* @param bondParameters the force parameters (length, k) for each bond term
* @param angleIndices the three atoms connected by each angle term
* @param angleParameters the force parameters (angle, k) for each angle term
* @param periodicTorsionIndices the four atoms connected by each periodic torsion term
* @param periodicTorsionParameters the force parameters (k, phase, periodicity) for each periodic torsion term
* @param rbTorsionIndices the four atoms connected by each Ryckaert-Bellemans torsion term
* @param rbTorsionParameters the coefficients (in order of increasing powers) for each Ryckaert-Bellemans torsion term
* @param bonded14Indices each element contains the indices of two atoms whose nonbonded interactions should be reduced since
* they form a bonded 1-4 pair
* @param lj14Scale the factor by which van der Waals interactions should be reduced for bonded 1-4 pairs
* @param coulomb14Scale the factor by which Coulomb interactions should be reduced for bonded 1-4 pairs
* @param exclusions the i'th element lists the indices of all atoms with which the i'th atom should not interact through
* nonbonded forces. Bonded 1-4 pairs are also included in this list, since they should be omitted from
* the standard nonbonded calculation.
* @param nonbondedParameters the nonbonded force parameters (charge, sigma, epsilon) for each atom
* @param nonbondedMethod the method to use for handling long range nonbonded interactions
* @param nonbondedCutoff the cutoff distance for nonbonded interactions (if nonbondedMethod involves a cutoff)
* @param periodicBoxSize the size of the periodic box (if nonbondedMethod involves a periodic boundary conditions)
*
*/
void initialize( const std::vector<std::vector<int> >& bondIndices, const std::vector<std::vector<double> >& bondParameters,
const std::vector<std::vector<int> >& angleIndices, const std::vector<std::vector<double> >& angleParameters,
const std::vector<std::vector<int> >& periodicTorsionIndices, const std::vector<std::vector<double> >& periodicTorsionParameters,
const std::vector<std::vector<int> >& rbTorsionIndices, const std::vector<std::vector<double> >& rbTorsionParameters,
const std::vector<std::vector<int> >& bonded14Indices, double lj14Scale, double coulomb14Scale,
const std::vector<std::set <int> >& exclusions, const std::vector<std::vector<double> >& nonbondedParameters,
//NonbondedMethod nonbondedMethod,
double nonbondedCutoff, double periodicBoxSize[3] );
/**
* Execute the kernel to calculate the forces.
*
* @param positions a Stream of type Double3 containing the position (x, y, z) of each atom
* @param forces a Stream of type Double3 containing the force (x, y, z) on each atom. On entry, this contains the forces that
* have been calculated so far. The kernel should add its own forces to the values already in the stream.
*/
void executeForces( const Stream& positions, Stream& forces );
/**
* Execute the kernel to calculate the energy.
*
* @param positions a Stream of type Double3 containing the position (x, y, z) of each atom
*
* @return the potential energy due to the NonbondedForce
*
* Currently always return 0.0 since energies not calculated on gpu
*/
double executeEnergy( const Stream& positions );
double executeEnergyOld( const Stream& positions );
/**
* Get reference Context
*
* @param numberOfAtoms number of atoms
* @param numberOfParticles number of particles
*
* @return OpenMMContext
*
*/
OpenMMContext* getReferenceOpenMMContext( int numberOfAtoms );
OpenMMContext* getReferenceOpenMMContext( int numberOfParticles );
/**
* Set log file reference
......@@ -266,27 +206,97 @@ class OpenMMBrookInterface {
*
*/
int setLJ14( BrookBondParameters* brookBondParameters );
int setNonBonded14ForceParameters( BrookBondParameters* brookBondParameters );
/**
* Get positions stream
*
* @return particle positions
*
*/
BrookStreamImpl* getParticlePositions( void );
/**
* Set positions stream
*
* @param positions Brook stream containing particle positions
*
* @return DefaultReturnValue
*
*/
int setParticlePositions( BrookStreamImpl* positions );
/**
* Get velocities stream
*
* @return particle velocities
*
*/
BrookStreamImpl* getParticleVelocities( void );
/**
* Set velocities stream
*
* @param velocities Brook stream containing particle velocities
*
* @return DefaultReturnValue
*
*/
int setParticleVelocities( BrookStreamImpl* velocities );
/**
* Get forces stream
*
* @return ParticleForces
*
*/
BrookStreamImpl* getParticleForces( void );
/**
* Set forces stream
*
* @param forces Brook stream containing particle forces
*
* @return DefaultReturnValue
*
*/
int setParticleForces( BrookStreamImpl* forces );
private:
static const int DefaultReturnValue = 0;
static const int ErrorReturnValue = -1;
enum BondParameterIndices { HarmonicBondIndex, HarmonicAngleIndex, PeriodicTorsionForceIndex, RbTorsionForceIndex, LJ14Index, LastBondForce };
// log file reference
FILE* _log;
// number of atoms
// number of particles
int _numberOfAtoms;
int _numberOfParticles;
// Brook bonded & nonbonded
// Brook bonded, nonbonded, Gbsa
BrookBonded* _brookBonded;
BrookNonBonded* _brookNonBonded;
BrookGbsa* _brookGbsa;
BrookBondParameters* _bondParameters[LastBondForce];
// context-related fields
BrookStreamImpl* _positions;
BrookStreamImpl* _velocities;
BrookStreamImpl* _forces;
// used to calculate energy
NonbondedForce* _refForceField;
......
platforms/brook/src/gpu/kObcBaseD2.br
View file @ 309008f7
/* -------------------------------------------------------------------------- *
* OpenMM *
* -------------------------------------------------------------------------- *
* This is part of the OpenMM molecular simulation toolkit originating from *
* Simbios, the NIH National Center for Physics-Based Simulation of *
* Biological Structures at Stanford, funded under the NIH Roadmap for *
* Medical Research, grant U54 GM072970. See https://simtk.org. *
* *
* Portions copyright (c) 2008 Stanford University and the Authors. *
* Authors: Peter Eastman, Mark Friedrichs, Chris Bruns *
* Contributors: *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the "Software"), *
* to deal in the Software without restriction, including without limitation *
* the rights to use, copy, modify, merge, publish, distribute, sublicense, *
* and/or sell copies of the Software, and to permit persons to whom the *
* Software is furnished to do so, subject to the following conditions: *
* *
* The above copyright notice and this permission notice shall be included in *
* all copies or substantial portions of the Software. *
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
* THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE *
* USE OR OTHER DEALINGS IN THE SOFTWARE. *
* -------------------------------------------------------------------------- */
/****************************************************************
* This file is part of the gpu acceleration library for gromacs.
* Author: Mark Friedrichs
*
* This kernel was developed in collaboration with
*
* Copyright (C) Pande Group, Stanford, 2006
*****************************************************************/
//156 FLOPS [172 total]
kernel void loop2Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jAtomicRadiiScaled,
float bornForce, float iAtomicRadii, out float4 de<>, out float4 bornSum<> ){
float bornForce, float iAtomicRadii, out float4 de<> ){
// ---------------------------------------------------------------------------------------
......@@ -57,7 +37,7 @@ kernel void loop2Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jA
iAtomicRadii4 = float4( iAtomicRadii, iAtomicRadii, iAtomicRadii, iAtomicRadii );
r2 = float4( dot(d1, d1), dot( d2, d2 ), dot( d3, d3 ), dot( d4, d4 ) );
r2 = float4( dot(d1, d1), dot( d2, d2 ), dot( d3, d3 ), dot( d4, d4 ) ); //20
// ---------------------------------------------------------------------------------------
......@@ -69,13 +49,13 @@ kernel void loop2Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jA
// ---------------------------------------------------------------------------------------
r = sqrt( r2 );
rInverse = rsqrt( r2 );
r2Inverse = rInverse*rInverse;
r = sqrt( r2 ); //4
rInverse = rsqrt( r2 ); //8
r2Inverse = rInverse*rInverse; //4
rPlusScaledJ = r + jAtomicRadiiScaled;
rMinusScaledJ = r - jAtomicRadiiScaled;
rMinusScaledJAbs = abs( rMinusScaledJ );
rPlusScaledJ = r + jAtomicRadiiScaled; //4
rMinusScaledJ = r - jAtomicRadiiScaled; //4
rMinusScaledJAbs = abs( rMinusScaledJ );
// ---------------------------------------------------------------------------------------
......@@ -84,21 +64,21 @@ kernel void loop2Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jA
// ---------------------------------------------------------------------------------------
l_ij = 1.0f/l_ij;
l_ij2 = l_ij*l_ij;
l_ij = 1.0f/l_ij; //4
l_ij2 = l_ij*l_ij; //4
u_ij = 1.0f/rPlusScaledJ;
u_ij2 = u_ij*u_ij;
diff_u2_l2 = u_ij2 - l_ij2;
u_ij = 1.0f/rPlusScaledJ; //4
u_ij2 = u_ij*u_ij; //4
diff_u2_l2 = u_ij2 - l_ij2; //4
scaledRadiusJ2 = jAtomicRadiiScaled*jAtomicRadiiScaled;
logRatio = log(u_ij/l_ij);
scaledRadiusJ2 = jAtomicRadiiScaled*jAtomicRadiiScaled; //4
logRatio = log(u_ij/l_ij); //4
// terms associated w/ dL/dr & dU/dr are zero and not included
t3 = -0.125f*(1.0f + scaledRadiusJ2*r2Inverse)*diff_u2_l2 + 0.25f*logRatio*r2Inverse;
t3 = -0.125f*(1.0f + scaledRadiusJ2*r2Inverse)*diff_u2_l2 + 0.25f*logRatio*r2Inverse; //7*4
de = mask*bornForce*t3*rInverse;
de = mask*bornForce*t3*rInverse; //12
// de = float4( 1.0f, 1.0f, 1.0f, 1.0f );
// de = scaledRadiusJ2;
......@@ -112,15 +92,16 @@ kernel void loop2Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jA
// Born radius term
// bornSum = l_ij - u_ij + 0.25*r*diff_u2_l2 + 0.5f*rInverse*logRatio - (0.25*jAtomicRadiiScaled*jAtomicRadiiScaled*rInverse)*diff_u2_l2;
bornSum = l_ij - u_ij + 0.5f*rInverse*logRatio + 0.25f*( r - jAtomicRadiiScaled*jAtomicRadiiScaled*rInverse)*diff_u2_l2;
/*
bornSum = l_ij - u_ij + 0.5f*rInverse*logRatio + 0.25f*( r - jAtomicRadiiScaled*jAtomicRadiiScaled*rInverse)*diff_u2_l2; //10*4
t3 = ( iAtomicRadii4 < (jAtomicRadiiScaled - r) ) ? 2.0f*( (1.0f/iAtomicRadii) - l_ij) : zero4;
bornSum += t3;
bornSum *= mask;
t3 = ( iAtomicRadii4 < (jAtomicRadiiScaled - r) ) ? 2.0f*( (1.0f/iAtomicRadii) - l_ij) : zero4; //12 for true, but don't know how to average so saying 0
bornSum += t3; //4
bornSum *= mask; //4
*/
}
/****************************************************************
* This file is part of the gpu acceleration library for gromacs.
* Author: Mark Friedrichs
......@@ -221,6 +202,7 @@ kernel void loop2InternalR2( float4 r2, float4 jAtomicRadiiScaled,
/* This is a copy of loop2Internal(), but w/ the calculation of bornSum removed */
//112 FLOPS
kernel void loop2InternalNoSum( float3 d1, float3 d2, float3 d3, float3 d4, float4 jAtomicRadiiScaled,
float bornForce, float iAtomicRadii, out float4 de<> ){
......@@ -236,19 +218,19 @@ kernel void loop2InternalNoSum( float3 d1, float3 d2, float3 d3, float3 d4, floa
const float bigValue = 1000000.0f;
const float4 bigValue4 = float4( bigValue, bigValue, bigValue, bigValue );
const float smallValue = 0.000001f;
const float4 smallValue4 = float4( smallValue, smallValue, smallValue, smallValue );
const float smallValue = 0.000001f;
const float4 smallValue4 = float4( smallValue, smallValue, smallValue, smallValue );
const float4 zero4 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
const float4 one4 = float4( 1.0f, 1.0f, 1.0f, 1.0f );
float4 mask;
// ---------------------------------------------------------------------------------------
iAtomicRadii4 = float4( iAtomicRadii, iAtomicRadii, iAtomicRadii, iAtomicRadii );
r2 = float4( dot(d1, d1), dot( d2, d2 ), dot( d3, d3 ), dot( d4, d4 ) );
r2 = float4( dot(d1, d1), dot( d2, d2 ), dot( d3, d3 ), dot( d4, d4 ) ); //20
// ---------------------------------------------------------------------------------------
......@@ -259,12 +241,12 @@ kernel void loop2InternalNoSum( float3 d1, float3 d2, float3 d3, float3 d4, floa
// ---------------------------------------------------------------------------------------
r = sqrt( r2 );
rInverse = rsqrt( r2 );
r2Inverse = rInverse*rInverse;
r = sqrt( r2 ); //4
rInverse = rsqrt( r2 ); //8
r2Inverse = rInverse*rInverse; //4
rPlusScaledJ = r + jAtomicRadiiScaled;
rMinusScaledJ = r - jAtomicRadiiScaled;
rPlusScaledJ = r + jAtomicRadiiScaled; //4
rMinusScaledJ = r - jAtomicRadiiScaled; //4
rMinusScaledJAbs = abs( rMinusScaledJ );
// ---------------------------------------------------------------------------------------
......@@ -272,29 +254,105 @@ kernel void loop2InternalNoSum( float3 d1, float3 d2, float3 d3, float3 d4, floa
// mask = iAtomicRadii4 >= rPlusScaledJ ? zero4 : mask;
mask = iAtomicRadii4 >= rPlusScaledJ ? zero4 : one4;
l_ij = iAtomicRadii4 > rMinusScaledJAbs ? iAtomicRadii4 : rMinusScaledJAbs;
// ---------------------------------------------------------------------------------------
l_ij = 1.0f/l_ij; //4
l_ij2 = l_ij*l_ij; //4
u_ij = 1.0f/rPlusScaledJ; //4
u_ij2 = u_ij*u_ij; //4
scaledRadiusJ2 = jAtomicRadiiScaled*jAtomicRadiiScaled; //4
logRatio = log(u_ij/l_ij); //4
// terms associated w/ dL/dr & dU/dr are zero and not included
t3 = 0.125f*(1.0f + scaledRadiusJ2*r2Inverse)*(l_ij2 - u_ij2) + 0.25f*logRatio*r2Inverse; //8*4
de = mask*bornForce*t3*rInverse; //12
}
//124 FLOPS [??? total]
kernel void bornSumInternal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jAtomicRadiiScaled,
float iAtomicRadii, out float4 bornSum<> ){
// ---------------------------------------------------------------------------------------
float4 r, rInverse, r2, r2Inverse;
float4 l_ij, l_ij2;
float4 u_ij, u_ij2;
float4 t3;
float4 logRatio, scaledRadiusJ2, rPlusScaledJ, rMinusScaledJ, rMinusScaledJAbs;
float4 iAtomicRadii4;
float4 diff_u2_l2;
const float bigValue = 1000000.0f;
const float4 bigValue4 = float4( bigValue, bigValue, bigValue, bigValue );
const float smallValue = 0.000001f;
const float4 smallValue4 = float4( smallValue, smallValue, smallValue, smallValue );
const float4 zero4 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
const float4 one4 = float4( 1.0f, 1.0f, 1.0f, 1.0f );
float4 mask;
// ---------------------------------------------------------------------------------------
iAtomicRadii4 = float4( iAtomicRadii, iAtomicRadii, iAtomicRadii, iAtomicRadii );
r2 = float4( dot(d1, d1), dot( d2, d2 ), dot( d3, d3 ), dot( d4, d4 ) ); //20
// ---------------------------------------------------------------------------------------
// not needed for force calculation since deltaX = deltaY = deltaZ = 0, if r = 0
// r2 not masked -- assume for i = j, that 0 * infinity i 0; appears to work
mask = r2 < smallValue4 ? zero4 : one4;
// ---------------------------------------------------------------------------------------
r = sqrt( r2 ); //4
rInverse = rsqrt( r2 ); //8
rPlusScaledJ = r + jAtomicRadiiScaled; //4
rMinusScaledJ = r - jAtomicRadiiScaled; //4
rMinusScaledJAbs = abs( rMinusScaledJ );
//40
// ---------------------------------------------------------------------------------------
mask = iAtomicRadii4 >= rPlusScaledJ ? zero4 : mask;
l_ij = iAtomicRadii4 > rMinusScaledJAbs ? iAtomicRadii4 : rMinusScaledJAbs;
// ---------------------------------------------------------------------------------------
l_ij = 1.0f/l_ij;
l_ij2 = l_ij*l_ij;
l_ij = 1.0f/l_ij; //4
l_ij2 = l_ij*l_ij; //4
u_ij = 1.0f/rPlusScaledJ;
u_ij2 = u_ij*u_ij;
u_ij = 1.0f/rPlusScaledJ; //4
u_ij2 = u_ij*u_ij; //4
diff_u2_l2 = u_ij2 - l_ij2; //4
scaledRadiusJ2 = jAtomicRadiiScaled*jAtomicRadiiScaled;
logRatio = log(u_ij/l_ij);
logRatio = log(u_ij/l_ij); //4
//24
// ---------------------------------------------------------------------------------------
// terms associated w/ dL/dr & dU/dr are zero and not included
t3 = 0.125f*(1.0f + scaledRadiusJ2*r2Inverse)*(l_ij2 - u_ij2) + 0.25f*logRatio*r2Inverse;
// Born radius term
de = mask*bornForce*t3*rInverse;
// de = rInverse;
// de = float4( 1.0f, 1.0f, 1.0f, 1.0f );
// de = bornForce;
bornSum = l_ij - u_ij + 0.5f*rInverse*logRatio + 0.25f*( r - jAtomicRadiiScaled*jAtomicRadiiScaled*rInverse)*diff_u2_l2; //10*4
t3 = ( iAtomicRadii4 < (jAtomicRadiiScaled - r) ) ? 2.0f*( (1.0f/iAtomicRadii) - l_ij) : zero4; //12 for true, but don't know how to average so saying 0
bornSum += t3; //4
bornSum *= mask; //4
//60
}
// This kernel includes terms dL/dr & dU/dr from paper
......@@ -415,9 +473,9 @@ kernel void loop2InternalNoSumX( float3 d1, float3 d2, float3 d3, float3 d4, flo
const float bigValue = 1000000.0f;
const float4 bigValue4 = float4( bigValue, bigValue, bigValue, bigValue );
const float smallValue = 0.000001f;
const float4 smallValue4 = float4( smallValue, smallValue, smallValue, smallValue );
const float smallValue = 0.000001f;
const float4 smallValue4 = float4( smallValue, smallValue, smallValue, smallValue );
const float4 zero4 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
const float4 one4 = float4( 1.0f, 1.0f, 1.0f, 1.0f );
......@@ -509,9 +567,10 @@ kernel void loop2InternalNoSumX( float3 d1, float3 d2, float3 d3, float3 d4, flo
--------------------------------------------------------------------------------------- */
//1376 FLOPS
kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicationFactor,
float streamWidth, float fstreamWidth, float3 posq[][],
float2 scaledAtomicRadii[][],
float streamWidth, float fstreamWidth, float4 posq[][],
float atomicRadii[][], float scaledAtomicRadii[][],
float bornForceFactor[][],
out float4 bornForce1<>, out float4 bornForce2<>,
out float4 bornForce3<>, out float4 bornForce4<> ){
......@@ -562,6 +621,8 @@ kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicat
float jEnd, jStart, jBlock;
float whichRep;
float tmp;
float tmp2;
// ---------------------------------------------------------------------------------------
......@@ -589,42 +650,38 @@ kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicat
// etch i1 position, Born prefactor, atomic radius
i1pos = posq[ iAtom ];
i1pos = posq[ iAtom ].xyz;
i1BornForceFactor = bornForceFactor[ iAtom ];
i1AtomicRadii = scaledAtomicRadii[ iAtom ].y;
i1ScaledAtomicRadii = scaledAtomicRadii[ iAtom ].x;
i1AtomicRadii = atomicRadii[ iAtom ];
i1ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
bornForce1 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
//bornForce1.xyz = float3( i1BornForceFactor, i1ScaledAtomicRadii, i1AtomicRadii );
// etch i2 position, Born prefactor, atomic radius
iAtom.x += 1;
i2pos = posq[ iAtom ];
i2pos = posq[ iAtom ].xyz;
i2BornForceFactor = bornForceFactor[ iAtom ];
i2AtomicRadii = scaledAtomicRadii[ iAtom ].y;
i2ScaledAtomicRadii = scaledAtomicRadii[ iAtom ].x;
i2AtomicRadii = atomicRadii[ iAtom ];
i2ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
bornForce2 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
//bornForce2.xyz = float3( i2BornForceFactor, i2ScaledAtomicRadii, i2AtomicRadii );
// etch i3 position, Born prefactor, atomic radius
iAtom.x += 1;
i3pos = posq[ iAtom ];
i3pos = posq[ iAtom ].xyz;
i3BornForceFactor = bornForceFactor[ iAtom ];
i3AtomicRadii = scaledAtomicRadii[ iAtom ].y;
i3ScaledAtomicRadii = scaledAtomicRadii[ iAtom ].x;
i3AtomicRadii = atomicRadii[ iAtom ];
i3ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
bornForce3 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
//bornForce3.xyz = float3( i3BornForceFactor, i3ScaledAtomicRadii, i3AtomicRadii );
// etch i4 position, Born prefactor, atomic radius
iAtom.x += 1;
i4pos = posq[ iAtom ];
i4pos = posq[ iAtom ].xyz;
i4BornForceFactor = bornForceFactor[ iAtom ];
i4AtomicRadii = scaledAtomicRadii[ iAtom ].y;
i4ScaledAtomicRadii = scaledAtomicRadii[ iAtom ].x;
i4AtomicRadii = atomicRadii[ iAtom ];
i4ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
bornForce4 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
//bornForce4.xyz = float3( i4BornForceFactor, i4ScaledAtomicRadii, i4AtomicRadii );
// create float4 for main vars
......@@ -635,9 +692,12 @@ kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicat
// inner loop indices setup
//changed the following instruction for rounding issues on some ASICs
//whichRep = floor( forceIndex / roundedUpAtoms );
tmp = fmod(forceIndex, roundedUpAtoms);
tmp = fmod(forceIndex, roundedUpAtoms);
whichRep = round((forceIndex - tmp)/roundedUpAtoms);
jBlock = 1 + floor( numberOfAtoms/(duplicationFactor*streamWidth ) );
//jBlock = 1 + floor( numberOfAtoms/(duplicationFactor*streamWidth ) );
jBlock = 1 + round( (numberOfAtoms-fmod( numberOfAtoms, (duplicationFactor*streamWidth) )) / (duplicationFactor*streamWidth) );
jStart = whichRep*jBlock;
jEnd = ( whichRep > duplicationFactor - 1.5f ) ? 999999.0f : (jStart + jBlock);
......@@ -654,30 +714,32 @@ kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicat
// ---------------------------------------------------------------------------------------
// gather required values
j1BornForceFactor = bornForceFactor[ jAtom ];
j1AtomicRadii = scaledAtomicRadii[ jAtom ].y;
j1ScaledAtomicRadii = scaledAtomicRadii[ jAtom ].x;
j1pos = posq[ jAtom ];
j1AtomicRadii = atomicRadii[ jAtom ];
j1ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j1pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f;
j2BornForceFactor = bornForceFactor[ jAtom ];
j2AtomicRadii = scaledAtomicRadii[ jAtom ].y;
j2ScaledAtomicRadii = scaledAtomicRadii[ jAtom ].x;
j2pos = posq[ jAtom ];
j2AtomicRadii = atomicRadii[ jAtom ];
j2ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j2pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f;
j3BornForceFactor = bornForceFactor[ jAtom ];
j3AtomicRadii = scaledAtomicRadii[ jAtom ].y;
j3ScaledAtomicRadii = scaledAtomicRadii[ jAtom ].x;
j3pos = posq[ jAtom ];
j3AtomicRadii = atomicRadii[ jAtom ];
j3ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j3pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f;
j4BornForceFactor = bornForceFactor[ jAtom ];
j4AtomicRadii = scaledAtomicRadii[ jAtom ].y;
j4ScaledAtomicRadii = scaledAtomicRadii[ jAtom ].x;
j4pos = posq[ jAtom ];
j4AtomicRadii = atomicRadii[ jAtom ];
j4ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j4pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f;
//jBornForceFactor = float4( j1BornForceFactor, j2BornForceFactor, j3BornForceFactor, j4BornForceFactor );
jAtomicRadii = float4( j1AtomicRadii, j2AtomicRadii, j3AtomicRadii, j4AtomicRadii );
......@@ -687,143 +749,141 @@ kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicat
// First set of 4 -- i == 1
d1 = j1pos - i1pos;
d2 = j2pos - i1pos;
d3 = j3pos - i1pos;
d4 = j4pos - i1pos;
d1 = j1pos - i1pos; //3
d2 = j2pos - i1pos; //3
d3 = j3pos - i1pos; //3
d4 = j4pos - i1pos; //3
// i = 1
loop2Internal( d1, d2, d3, d4, jScaledAtomicRadii, i1BornForceFactor, i1AtomicRadii, de, bornSum );
//loop2Internal( d1, d2, d3, d4, jScaledAtomicRadii, i1BornForceFactor, i1AtomicRadii, de, bornSum ); //156 : 368
loop2Internal( d1, d2, d3, d4, jScaledAtomicRadii, i1BornForceFactor, i1AtomicRadii, de ); //156 : 368
bornForce1.xyz += de.x*d1;
bornForce1.xyz += de.y*d2;
bornForce1.xyz += de.z*d3;
bornForce1.xyz += de.w*d4;
bornForce1.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w;
bornForce1.xyz += de.x*d1; //3*2=6
bornForce1.xyz += de.y*d2; //3*2=6
bornForce1.xyz += de.z*d3; //3*2=6
bornForce1.xyz += de.w*d4; //3*2=6
//bornForce1.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// ---------------------------------------------------------------------------------------
// i = 2
d1 = j1pos - i2pos;
d2 = j2pos - i2pos;
d3 = j3pos - i2pos;
d4 = j4pos - i2pos;
d1 = j1pos - i2pos; //3
d2 = j2pos - i2pos; //3
d3 = j3pos - i2pos; //3
d4 = j4pos - i2pos; //3
loop2Internal( d1, d2, d3, d4, jScaledAtomicRadii, i2BornForceFactor, i2AtomicRadii, de, bornSum );
//loop2Internal( d1, d2, d3, d4, jScaledAtomicRadii, i2BornForceFactor, i2AtomicRadii, de, bornSum );//156 : 368
loop2Internal( d1, d2, d3, d4, jScaledAtomicRadii, i2BornForceFactor, i2AtomicRadii, de );//156 : 368
bornForce2.xyz += de.x*d1;
bornForce2.xyz += de.y*d2;
bornForce2.xyz += de.z*d3;
bornForce2.xyz += de.w*d4;
bornForce2.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w;
bornForce2.xyz += de.x*d1; //3*2=6
bornForce2.xyz += de.y*d2; //3*2=6
bornForce2.xyz += de.z*d3; //3*2=6
bornForce2.xyz += de.w*d4; //3*2=6
//bornForce2.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// ---------------------------------------------------------------------------------------
// i = 3
d1 = j1pos - i3pos;
d2 = j2pos - i3pos;
d3 = j3pos - i3pos;
d4 = j4pos - i3pos;
d1 = j1pos - i3pos; //3
d2 = j2pos - i3pos; //3
d3 = j3pos - i3pos; //3
d4 = j4pos - i3pos; //3
loop2Internal( d1, d2, d3, d4, jScaledAtomicRadii, i3BornForceFactor, i3AtomicRadii, de, bornSum );
loop2Internal( d1, d2, d3, d4, jScaledAtomicRadii, i3BornForceFactor, i3AtomicRadii, de );//156 : 368
bornForce3.xyz += de.x*d1;
bornForce3.xyz += de.y*d2;
bornForce3.xyz += de.z*d3;
bornForce3.xyz += de.w*d4;
bornForce3.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w;
bornForce3.xyz += de.x*d1; //3*2=6
bornForce3.xyz += de.y*d2; //3*2=6
bornForce3.xyz += de.z*d3; //3*2=6
bornForce3.xyz += de.w*d4; //3*2=6
//bornForce3.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// ---------------------------------------------------------------------------------------
// i = 4
d1 = j1pos - i4pos;
d2 = j2pos - i4pos;
d3 = j3pos - i4pos;
d4 = j4pos - i4pos;
d1 = j1pos - i4pos; //3
d2 = j2pos - i4pos; //3
d3 = j3pos - i4pos; //3
d4 = j4pos - i4pos; //3
loop2Internal( d1, d2, d3, d4, jScaledAtomicRadii, i4BornForceFactor, i4AtomicRadii, de, bornSum );
loop2Internal( d1, d2, d3, d4, jScaledAtomicRadii, i4BornForceFactor, i4AtomicRadii, de );//156 : 366
bornForce4.xyz += de.x*d1;
bornForce4.xyz += de.y*d2;
bornForce4.xyz += de.z*d3;
bornForce4.xyz += de.w*d4;
bornForce4.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w;
bornForce4.xyz += de.x*d1; //3*2=6
bornForce4.xyz += de.y*d2; //3*2=6
bornForce4.xyz += de.z*d3; //3*2=6
bornForce4.xyz += de.w*d4; //3*2=6
//bornForce4.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// ---------------------------------------------------------------------------------------
// j = 1
d1 = j1pos - i1pos;
d2 = j1pos - i2pos;
d3 = j1pos - i3pos;
d4 = j1pos - i4pos;
d1 = j1pos - i1pos; //3
d2 = j1pos - i2pos; //3
d3 = j1pos - i3pos; //3
d4 = j1pos - i4pos; //3
// loop2Internal( d1, d2, d3, d4, iScaledAtomicRadii, j1BornForceFactor, j1AtomicRadii, de, bornSum );
loop2InternalNoSum( d1, d2, d3, d4, iScaledAtomicRadii, j1BornForceFactor, j1AtomicRadii, de );
loop2InternalNoSum( d1, d2, d3, d4, iScaledAtomicRadii, j1BornForceFactor, j1AtomicRadii, de ); //112 : 304
bornForce1.xyz += de.x*d1;
bornForce2.xyz += de.y*d2;
bornForce3.xyz += de.z*d3;
bornForce4.xyz += de.w*d4;
bornForce1.xyz += de.x*d1; //3*2=6
bornForce2.xyz += de.y*d2; //3*2=6
bornForce3.xyz += de.z*d3; //3*2=6
bornForce4.xyz += de.w*d4; //3*2=6
// ---------------------------------------------------------------------------------------
// j = 2
d1 = j2pos - i1pos;
d2 = j2pos - i2pos;
d3 = j2pos - i3pos;
d4 = j2pos - i4pos;
d1 = j2pos - i1pos; //3
d2 = j2pos - i2pos; //3
d3 = j2pos - i3pos; //3
d4 = j2pos - i4pos; //3
// loop2Internal( d1, d2, d3, d4, iScaledAtomicRadii, j2BornForceFactor, j2AtomicRadii, de, bornSum );
loop2InternalNoSum( d1, d2, d3, d4, iScaledAtomicRadii, j2BornForceFactor, j2AtomicRadii, de );
bornForce1.xyz += de.x*d1;
bornForce2.xyz += de.y*d2;
bornForce3.xyz += de.z*d3;
bornForce4.xyz += de.w*d4;
loop2InternalNoSum( d1, d2, d3, d4, iScaledAtomicRadii, j2BornForceFactor, j2AtomicRadii, de ); //112 : 304
bornForce1.xyz += de.x*d1; //3*2=6
bornForce2.xyz += de.y*d2; //3*2=6
bornForce3.xyz += de.z*d3; //3*2=6
bornForce4.xyz += de.w*d4; //3*2=6
// ---------------------------------------------------------------------------------------
// j = 3
d1 = j3pos - i1pos;
d2 = j3pos - i2pos;
d3 = j3pos - i3pos;
d4 = j3pos - i4pos;
d1 = j3pos - i1pos; //3
d2 = j3pos - i2pos; //3
d3 = j3pos - i3pos; //3
d4 = j3pos - i4pos; //3
// loop2Internal( d1, d2, d3, d4, iScaledAtomicRadii, j3BornForceFactor, j3AtomicRadii, de, bornSum );
loop2InternalNoSum( d1, d2, d3, d4, iScaledAtomicRadii, j3BornForceFactor, j3AtomicRadii, de );
loop2InternalNoSum( d1, d2, d3, d4, iScaledAtomicRadii, j3BornForceFactor, j3AtomicRadii, de ); //112 : 304
bornForce1.xyz += de.x*d1;
bornForce2.xyz += de.y*d2;
bornForce3.xyz += de.z*d3;
bornForce4.xyz += de.w*d4;
bornForce1.xyz += de.x*d1; //3*2=6
bornForce2.xyz += de.y*d2; //3*2=6
bornForce3.xyz += de.z*d3; //3*2=6
bornForce4.xyz += de.w*d4; //3*2=6
// ---------------------------------------------------------------------------------------
// j = 4
d1 = j4pos - i1pos;
d2 = j4pos - i2pos;
d3 = j4pos - i3pos;
d4 = j4pos - i4pos;
d1 = j4pos - i1pos; //3
d2 = j4pos - i2pos; //3
d3 = j4pos - i3pos; //3
d4 = j4pos - i4pos; //3
// loop2Internal( d1, d2, d3, d4, iScaledAtomicRadii, j4BornForceFactor, j4AtomicRadii, de, bornSum );
loop2InternalNoSum( d1, d2, d3, d4, iScaledAtomicRadii, j4BornForceFactor, j4AtomicRadii, de );
loop2InternalNoSum( d1, d2, d3, d4, iScaledAtomicRadii, j4BornForceFactor, j4AtomicRadii, de ); //112 : 304
bornForce1.xyz += de.x*d1;
bornForce2.xyz += de.y*d2;
bornForce3.xyz += de.z*d3;
bornForce4.xyz += de.w*d4;
bornForce1.xyz += de.x*d1; //3*2=6
bornForce2.xyz += de.y*d2; //3*2=6
bornForce3.xyz += de.z*d3; //3*2=6
bornForce4.xyz += de.w*d4; //3*2=6
// ---------------------------------------------------------------------------------------
......@@ -909,6 +969,471 @@ kernel float4 scalar_force_CDLJMerge( float4 qq, float epsfac, float4 sig, float
return f;
}
//???? FLOPS
kernel void kCalculateBornRadii( float numberOfAtoms, float roundedUpAtoms, float duplicationFactor,
float streamWidth, float fstreamWidth, float4 posq[][],
float atomicRadii[][], float scaledAtomicRadii[][],
out float4 bornForce<> ){
// ---------------------------------------------------------------------------------------
// atomic radii: radius - dielectric offset
float i1AtomicRadii, i2AtomicRadii, i3AtomicRadii, i4AtomicRadii;
float j1AtomicRadii, j2AtomicRadii, j3AtomicRadii, j4AtomicRadii;
float4 iAtomicRadii, jAtomicRadii;
// scaled atomic radii: scaleFactor*( radius - dielectric offset )
float i1ScaledAtomicRadii, i2ScaledAtomicRadii, i3ScaledAtomicRadii, i4ScaledAtomicRadii;
float j1ScaledAtomicRadii, j2ScaledAtomicRadii, j3ScaledAtomicRadii, j4ScaledAtomicRadii;
float4 iScaledAtomicRadii, jScaledAtomicRadii;
// (Born radii**2)*BornForce*ObcChainForce
// i,j coordinates
float3 i1pos, i2pos, i3pos, i4pos;
float3 j1pos, j2pos, j3pos, j4pos;
// delta coordinates
float3 d1, d2, d3, d4;
// indices
float2 iAtom;
float forceIndex;
//This is forceIndex mod numberOfAtoms, the true i index
float4 de, bornSum;
float iAtomLinearIndex, jLinind;
float2 jAtom;
float jEnd, jStart, jBlock;
float whichRep;
float tmp;
float tmp2;
// ---------------------------------------------------------------------------------------
// constants
const float I_Unroll = 4.0f;
// ---------------------------------------------------------------------------------------
// set linear index
iAtom = indexof( bornForce );
forceIndex = I_Unroll*( iAtom.x + iAtom.y*fstreamWidth );
iAtomLinearIndex = fmod( forceIndex, roundedUpAtoms );
// ---------------------------------------------------------------------------------------
// set gather coordinates
iAtom.x = fmod( iAtomLinearIndex, streamWidth );
iAtom.y = round( (iAtomLinearIndex - iAtom.x)/streamWidth );
// ---------------------------------------------------------------------------------------
// etch i1 position, Born prefactor, atomic radius
i1pos = posq[ iAtom ].xyz;
i1AtomicRadii = atomicRadii[ iAtom ];
i1ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
bornForce = float4( 0.0f, 0.0f, 0.0f, 0.0f );
// etch i2 position, Born prefactor, atomic radius
iAtom.x += 1;
i2pos = posq[ iAtom ].xyz;
i2AtomicRadii = atomicRadii[ iAtom ];
i2ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
// etch i3 position, Born prefactor, atomic radius
iAtom.x += 1;
i3pos = posq[ iAtom ].xyz;
i3AtomicRadii = atomicRadii[ iAtom ];
i3ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
// etch i4 position, Born prefactor, atomic radius
iAtom.x += 1;
i4pos = posq[ iAtom ].xyz;
i4AtomicRadii = atomicRadii[ iAtom ];
i4ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
// create float4 for main vars
iAtomicRadii = float4( i1AtomicRadii, i2AtomicRadii, i3AtomicRadii, i4AtomicRadii );
iScaledAtomicRadii = float4( i1ScaledAtomicRadii, i2ScaledAtomicRadii, i3ScaledAtomicRadii, i4ScaledAtomicRadii );
// inner loop indices setup
//changed the following instruction for rounding issues on some ASICs
//whichRep = floor( forceIndex / roundedUpAtoms );
tmp = fmod(forceIndex, roundedUpAtoms);
whichRep = round((forceIndex - tmp)/roundedUpAtoms);
jBlock = 1 + round( (numberOfAtoms-fmod( numberOfAtoms, (duplicationFactor*streamWidth) )) / (duplicationFactor*streamWidth) );
jStart = whichRep*jBlock;
jEnd = ( whichRep > duplicationFactor - 1.5f ) ? 999999.0f : (jStart + jBlock);
jAtom.y = jStart;
jLinind = jAtom.y*streamWidth;
// ---------------------------------------------------------------------------------------
while ( jAtom.y < jEnd && ( numberOfAtoms - jLinind ) > 0.9f ){
jAtom.x = 0.0f;
while ( jAtom.x < streamWidth && ( numberOfAtoms - jLinind ) > 0.9f ){
// ---------------------------------------------------------------------------------------
// gather required values
j1AtomicRadii = atomicRadii[ jAtom ];
j1ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j1pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f;
j2AtomicRadii = atomicRadii[ jAtom ];
j2ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j2pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f;
j3AtomicRadii = atomicRadii[ jAtom ];
j3ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j3pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f;
j4AtomicRadii = atomicRadii[ jAtom ];
j4ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j4pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f;
jAtomicRadii = float4( j1AtomicRadii, j2AtomicRadii, j3AtomicRadii, j4AtomicRadii );
jScaledAtomicRadii = float4( j1ScaledAtomicRadii, j2ScaledAtomicRadii, j3ScaledAtomicRadii, j4ScaledAtomicRadii );
// ---------------------------------------------------------------------------------------
// First set of 4 -- i == 1
d1 = j1pos - i1pos; //3
d2 = j2pos - i1pos; //3
d3 = j3pos - i1pos; //3
d4 = j4pos - i1pos; //3
// i = 1
bornSumInternal( d1, d2, d3, d4, jScaledAtomicRadii, i1AtomicRadii, bornSum ); //112 : 368(?)
bornForce.x += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// ---------------------------------------------------------------------------------------
// i = 2
d1 = j1pos - i2pos; //3
d2 = j2pos - i2pos; //3
d3 = j3pos - i2pos; //3
d4 = j4pos - i2pos; //3
bornSumInternal( d1, d2, d3, d4, jScaledAtomicRadii, i2AtomicRadii, bornSum );//112 : 368(?)
bornForce.y += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// ---------------------------------------------------------------------------------------
// i = 3
d1 = j1pos - i3pos; //3
d2 = j2pos - i3pos; //3
d3 = j3pos - i3pos; //3
d4 = j4pos - i3pos; //3
bornSumInternal( d1, d2, d3, d4, jScaledAtomicRadii, i3AtomicRadii, bornSum );//112 : 368(?)
bornForce.z += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// ---------------------------------------------------------------------------------------
// i = 4
d1 = j1pos - i4pos; //3
d2 = j2pos - i4pos; //3
d3 = j3pos - i4pos; //3
d4 = j4pos - i4pos; //3
bornSumInternal( d1, d2, d3, d4, jScaledAtomicRadii, i4AtomicRadii, bornSum );//112 : 368(?)
bornForce.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// ---------------------------------------------------------------------------------------
// increment linear index by 4
jLinind += 4.0f;
}
jAtom.y += 1.0f;
}
}
//???? FLOPS
kernel void kCalculateBornRadiiOk( float numberOfAtoms, float roundedUpAtoms, float duplicationFactor,
float streamWidth, float fstreamWidth, float4 posq[][],
float atomicRadii[][], float scaledAtomicRadii[][],
float bornForceFactor[][],
out float4 bornForce1<>, out float4 bornForce2<>,
out float4 bornForce3<>, out float4 bornForce4<> ){
// ---------------------------------------------------------------------------------------
// atomic radii: radius - dielectric offset
float i1AtomicRadii, i2AtomicRadii, i3AtomicRadii, i4AtomicRadii;
float j1AtomicRadii, j2AtomicRadii, j3AtomicRadii, j4AtomicRadii;
float4 iAtomicRadii, jAtomicRadii;
// scaled atomic radii: scaleFactor*( radius - dielectric offset )
float i1ScaledAtomicRadii, i2ScaledAtomicRadii, i3ScaledAtomicRadii, i4ScaledAtomicRadii;
float j1ScaledAtomicRadii, j2ScaledAtomicRadii, j3ScaledAtomicRadii, j4ScaledAtomicRadii;
float4 iScaledAtomicRadii, jScaledAtomicRadii;
// (Born radii**2)*BornForce*ObcChainForce
float i1BornForceFactor, i2BornForceFactor, i3BornForceFactor, i4BornForceFactor;
float j1BornForceFactor, j2BornForceFactor, j3BornForceFactor, j4BornForceFactor;
//float4 iBornForceFactor;
//float4 jBornForceFactor;
// i,j coordinates
float3 i1pos, i2pos, i3pos, i4pos;
float3 j1pos, j2pos, j3pos, j4pos;
// delta coordinates
float3 d1, d2, d3, d4;
// indices
float2 iAtom;
float forceIndex;
//This is forceIndex mod numberOfAtoms, the true i index
float4 de, bornSum;
float iAtomLinearIndex, jLinind;
float2 jAtom;
float jEnd, jStart, jBlock;
float whichRep;
float tmp;
float tmp2;
// ---------------------------------------------------------------------------------------
// constants
const float I_Unroll = 4.0f;
// ---------------------------------------------------------------------------------------
// set linear index
iAtom = indexof( bornForce1 );
forceIndex = I_Unroll*( iAtom.x + iAtom.y*fstreamWidth );
iAtomLinearIndex = fmod( forceIndex, roundedUpAtoms );
// ---------------------------------------------------------------------------------------
// set gather coordinates
iAtom.x = fmod( iAtomLinearIndex, streamWidth );
iAtom.y = round( (iAtomLinearIndex - iAtom.x)/streamWidth );
// ---------------------------------------------------------------------------------------
// etch i1 position, Born prefactor, atomic radius
i1pos = posq[ iAtom ].xyz;
i1BornForceFactor = bornForceFactor[ iAtom ];
i1AtomicRadii = atomicRadii[ iAtom ];
i1ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
bornForce1 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
// etch i2 position, Born prefactor, atomic radius
iAtom.x += 1;
i2pos = posq[ iAtom ].xyz;
i2BornForceFactor = bornForceFactor[ iAtom ];
i2AtomicRadii = atomicRadii[ iAtom ];
i2ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
bornForce2 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
// etch i3 position, Born prefactor, atomic radius
iAtom.x += 1;
i3pos = posq[ iAtom ].xyz;
i3BornForceFactor = bornForceFactor[ iAtom ];
i3AtomicRadii = atomicRadii[ iAtom ];
i3ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
bornForce3 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
// etch i4 position, Born prefactor, atomic radius
iAtom.x += 1;
i4pos = posq[ iAtom ].xyz;
i4BornForceFactor = bornForceFactor[ iAtom ];
i4AtomicRadii = atomicRadii[ iAtom ];
i4ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
bornForce4 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
// create float4 for main vars
//iBornForceFactor = float4( i1BornForceFactor, i2BornForceFactor, i3BornForceFactor, i4BornForceFactor );
iAtomicRadii = float4( i1AtomicRadii, i2AtomicRadii, i3AtomicRadii, i4AtomicRadii );
iScaledAtomicRadii = float4( i1ScaledAtomicRadii, i2ScaledAtomicRadii, i3ScaledAtomicRadii, i4ScaledAtomicRadii );
// inner loop indices setup
//changed the following instruction for rounding issues on some ASICs
//whichRep = floor( forceIndex / roundedUpAtoms );
tmp = fmod(forceIndex, roundedUpAtoms);
whichRep = round((forceIndex - tmp)/roundedUpAtoms);
//jBlock = 1 + floor( numberOfAtoms/(duplicationFactor*streamWidth ) );
jBlock = 1 + round( (numberOfAtoms-fmod( numberOfAtoms, (duplicationFactor*streamWidth) )) / (duplicationFactor*streamWidth) );
jStart = whichRep*jBlock;
jEnd = ( whichRep > duplicationFactor - 1.5f ) ? 999999.0f : (jStart + jBlock);
jAtom.y = jStart;
jLinind = jAtom.y*streamWidth;
// ---------------------------------------------------------------------------------------
while ( jAtom.y < jEnd && ( numberOfAtoms - jLinind ) > 0.9f ){
jAtom.x = 0.0f;
while ( jAtom.x < streamWidth && ( numberOfAtoms - jLinind ) > 0.9f ){
// ---------------------------------------------------------------------------------------
// gather required values
j1BornForceFactor = bornForceFactor[ jAtom ];
j1AtomicRadii = atomicRadii[ jAtom ];
j1ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j1pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f;
j2BornForceFactor = bornForceFactor[ jAtom ];
j2AtomicRadii = atomicRadii[ jAtom ];
j2ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j2pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f;
j3BornForceFactor = bornForceFactor[ jAtom ];
j3AtomicRadii = atomicRadii[ jAtom ];
j3ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j3pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f;
j4BornForceFactor = bornForceFactor[ jAtom ];
j4AtomicRadii = atomicRadii[ jAtom ];
j4ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j4pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f;
//jBornForceFactor = float4( j1BornForceFactor, j2BornForceFactor, j3BornForceFactor, j4BornForceFactor );
jAtomicRadii = float4( j1AtomicRadii, j2AtomicRadii, j3AtomicRadii, j4AtomicRadii );
jScaledAtomicRadii = float4( j1ScaledAtomicRadii, j2ScaledAtomicRadii, j3ScaledAtomicRadii, j4ScaledAtomicRadii );
// ---------------------------------------------------------------------------------------
// First set of 4 -- i == 1
d1 = j1pos - i1pos; //3
d2 = j2pos - i1pos; //3
d3 = j3pos - i1pos; //3
d4 = j4pos - i1pos; //3
// i = 1
// bornSumInternal( d1, d2, d3, d4, jScaledAtomicRadii, i1BornForceFactor, i1AtomicRadii, bornSum ); //156 : 368
bornForce1.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// ---------------------------------------------------------------------------------------
// i = 2
d1 = j1pos - i2pos; //3
d2 = j2pos - i2pos; //3
d3 = j3pos - i2pos; //3
d4 = j4pos - i2pos; //3
// bornSumInternal( d1, d2, d3, d4, jScaledAtomicRadii, i2BornForceFactor, i2AtomicRadii, bornSum );//156 : 368
bornForce2.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// ---------------------------------------------------------------------------------------
// i = 3
d1 = j1pos - i3pos; //3
d2 = j2pos - i3pos; //3
d3 = j3pos - i3pos; //3
d4 = j4pos - i3pos; //3
// bornSumInternal( d1, d2, d3, d4, jScaledAtomicRadii, i3BornForceFactor, i3AtomicRadii, bornSum );//156 : 368
bornForce3.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// ---------------------------------------------------------------------------------------
// i = 4
d1 = j1pos - i4pos; //3
d2 = j2pos - i4pos; //3
d3 = j3pos - i4pos; //3
d4 = j4pos - i4pos; //3
// bornSumInternal( d1, d2, d3, d4, jScaledAtomicRadii, i4BornForceFactor, i4AtomicRadii, bornSum );//156 : 366
bornForce4.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// ---------------------------------------------------------------------------------------
// increment linear index by 4
jLinind += 4.0f;
}
jAtom.y += 1.0f;
}
}
/* ---------------------------------------------------------------------------------------
Calculate Loop 2 OBC forces (Simbios)
......
platforms/brook/src/gpu/kgbsa.h
View file @ 309008f7
#ifndef __KGBSA_H__
#define __KGBSA_H__
/* -------------------------------------------------------------------------- *
* OpenMM *
* -------------------------------------------------------------------------- *
* This is part of the OpenMM molecular simulation toolkit originating from *
* Simbios, the NIH National Center for Physics-Based Simulation of *
* Biological Structures at Stanford, funded under the NIH Roadmap for *
* Medical Research, grant U54 GM072970. See https://simtk.org. *
* *
* Portions copyright (c) 2008 Stanford University and the Authors. *
* Authors: Peter Eastman, Mark Friedrichs, Chris Bruns *
* Contributors: *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the "Software"), *
* to deal in the Software without restriction, including without limitation *
* the rights to use, copy, modify, merge, publish, distribute, sublicense, *
* and/or sell copies of the Software, and to permit persons to whom the *
* Software is furnished to do so, subject to the following conditions: *
* *
* The above copyright notice and this permission notice shall be included in *
* all copies or substantial portions of the Software. *
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
* THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE *
* USE OR OTHER DEALINGS IN THE SOFTWARE. *
* -------------------------------------------------------------------------- */
void kMergeFloat4(
const float repfac,
const float atomStrWidth,
......@@ -108,6 +75,28 @@ void kAddAndMergeFloat4_4(
::brook::stream outputStream
);
void kPostObcLoop2(
const float repfac,
const float atomStrWidth,
const float pforceStrWidth,
const float natoms,
const float roundNatoms,
const float iUnroll,
const float conversion,
const float mergeNonObcForces,
::brook::stream inObcForces,
::brook::stream nonObcForces,
::brook::stream stream1,
::brook::stream stream2,
::brook::stream stream3,
::brook::stream stream4,
::brook::stream atomicRadii,
::brook::stream bornRadii,
::brook::stream obcChain,
::brook::stream outputStream
);
void kPostObcLoop2_nobranch(
const float repfac,
const float atomStrWidth,
......@@ -129,6 +118,21 @@ void kPostObcLoop2_nobranch(
::brook::stream outputStream
);
void kPostCalculateBornRadii_nobranch(
const float repfac,
const float atomStrWidth,
const float pforceStrWidth,
const float natoms,
const float roundNatoms,
const float iUnroll,
const float conversion,
const float mergeNonObcForces,
::brook::stream stream1,
::brook::stream atomicRadii,
::brook::stream bornRadii,
::brook::stream obcChain
);
void kPreGbsaForce2(
::brook::stream intermediateForceIn,
::brook::stream bornRadii,
......@@ -483,6 +487,7 @@ void kObcLoop2(
float fstreamWidth,
::brook::stream posq,
::brook::stream atomicRadii,
::brook::stream scaledAtomicRadii,
::brook::stream bornForceFactor,
::brook::stream bornForce1,
::brook::stream bornForce2,
......@@ -490,6 +495,18 @@ void kObcLoop2(
::brook::stream bornForce4
);
void kCalculateBornRadii(
float numberOfAtoms,
float roundNatoms,
float duplicationFactor,
float streamWidth,
float fstreamWidth,
::brook::stream posq,
::brook::stream atomicRadii,
::brook::stream scaledAtomicRadii,
::brook::stream bornForce1
);
void kObcBornRadii(
float numberOfAtoms,
float streamWidth,
......@@ -508,6 +525,22 @@ void kAceNonPolar(
::brook::stream bornForce
);
void kCalculateBornRadii(
float numberOfAtoms,
float roundNatoms,
float duplicationFactor,
float streamWidth,
float fstreamWidth,
::brook::stream posq,
::brook::stream atomicRadii,
::brook::stream scaledAtomicRadii,
::brook::stream bornForceFactor,
::brook::stream bornForce1,
::brook::stream bornForce2,
::brook::stream bornForce3,
::brook::stream bornForce4
);
void kZeroFloat4( ::brook::stream bornForce );
void kSetValue4( float value, ::brook::stream bornForce );
void kSetValue3( float value, ::brook::stream bornForce );
......
platforms/brook/src/gpu/kgbsa1.br
View file @ 309008f7
/* -------------------------------------------------------------------------- *
* OpenMM *
* -------------------------------------------------------------------------- *
* This is part of the OpenMM molecular simulation toolkit originating from *
* Simbios, the NIH National Center for Physics-Based Simulation of *
* Biological Structures at Stanford, funded under the NIH Roadmap for *
* Medical Research, grant U54 GM072970. See https://simtk.org. *
* *
* Portions copyright (c) 2008 Stanford University and the Authors. *
* Authors: Peter Eastman, Mark Friedrichs, Chris Bruns *
* Contributors: *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the "Software"), *
* to deal in the Software without restriction, including without limitation *
* the rights to use, copy, modify, merge, publish, distribute, sublicense, *
* and/or sell copies of the Software, and to permit persons to whom the *
* Software is furnished to do so, subject to the following conditions: *
* *
* The above copyright notice and this permission notice shall be included in *
* all copies or substantial portions of the Software. *
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
* THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE *
* USE OR OTHER DEALINGS IN THE SOFTWARE. *
* -------------------------------------------------------------------------- */
/****************************************************************
* This file is part of the gpu acceleration library for gromacs.
* Author: Mark Friedrichs
*
* This kernel was developed in collaboration with
*
* Copyright (C) Pande Group, Stanford, 2006
*****************************************************************/
//96 : 228 Flops
kernel void loop1Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jBornR,
float4 jQ, float iBornR, float iQ, out float4 dGpol_dr<>,
out float4 dGpol_dalpha2_ij<> ){
......@@ -40,16 +18,16 @@ kernel void loop1Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jB
// ---------------------------------------------------------------------------------------
r2 = float4( dot(d1, d1), dot( d2, d2 ), dot( d3, d3 ), dot( d4, d4 ) );
alpha2_ij = jBornR*iBornR;
D_ij = r2/(4.0f*alpha2_ij);
expTerm = exp( -D_ij );
denominator2 = r2 + alpha2_ij*expTerm;
denominator = sqrt( denominator2 );
Gpol = jQ/denominator;
Gpol *= iQ;
dGpol_dr = -Gpol*( 1.0f - 0.25f*expTerm )/denominator2;
dGpol_dalpha2_ij = -0.5f*Gpol*expTerm*( 1.0f + D_ij )*jBornR/denominator2;
r2 = float4( dot(d1, d1), dot( d2, d2 ), dot( d3, d3 ), dot( d4, d4 ) ); //20
alpha2_ij = jBornR*iBornR; //4
D_ij = r2/(4.0f*alpha2_ij); //8
expTerm = exp( -D_ij ); //4 : 80
denominator2 = r2 + alpha2_ij*expTerm; //8
denominator = sqrt( denominator2 ); //4 : 60
Gpol = jQ/denominator; //4
Gpol *= iQ;//4
dGpol_dr = -Gpol*( 1.0f - 0.25f*expTerm )/denominator2; //16
dGpol_dalpha2_ij = -0.5f*Gpol*expTerm*( 1.0f + D_ij )*jBornR/denominator2; //24
}
......@@ -82,9 +60,9 @@ kernel void kAceNonPolarLoop1( float iBornRadius, float iVdwRadius, float duplic
const float probeRadius = 0.14f;
// PI*4*6*0.0054*1000 (0.0054=asolv from Tinker)
// PI*24*0.0f049 (0.0f054=asolv from Tinker)
//const float PI_24_aI = -0.3694512961;
const float PI_24_aI = -407.1504079f;
const float PI_24_aI = -400.71504079f;
// ---------------------------------------------------------------------------------------
......@@ -129,11 +107,11 @@ kernel void kAceNonPolarLoop1( float iBornRadius, float iVdwRadius, float duplic
bornForce4: i-unroll second force component, including dBornR/dr in .w
--------------------------------------------------------------------------------------- */
//FLOPS = 544
kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicationFactor,
float streamWidth, float fstreamWidth, float soluteDielectric,
float solventDielectric, float includeAce,
float3 posq[][], float bornRadii[][], float2 atomicRadii[][],
float4 posq[][], float bornRadii[][], float atomicRadii[][],
out float4 bornForce1<>, out float4 bornForce2<>,
out float4 bornForce3<>, out float4 bornForce4<> ){
......@@ -214,11 +192,11 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat
// etch i1 position and partial charge
jQ = posq[ iAtom ];
i1BornR = bornRadii[ iAtom ];
i1AtomicR = atomicRadii[ iAtom ];
i1Pos = jQ.xyz;
i1Q = atomicRadii[ iAtom ].y;
i1Q = jQ.w;
i1Q *= preFactor;
i1BornR = bornRadii[ iAtom ];
i1AtomicR = atomicRadii[ iAtom ].x;
kAceNonPolarLoop1( i1BornR, i1AtomicR, duplicationFactor, aceForce );
bornForce1.xyz = zero3;
bornForce1.w = includeAce > 0.5f ? aceForce : 0.0f;
......@@ -229,11 +207,11 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat
iAtom.x += 1;
jQ = posq[ iAtom ];
i2BornR = bornRadii[ iAtom ];
i2AtomicR = atomicRadii[ iAtom ];
i2Pos = jQ.xyz;
i2Q = atomicRadii[ iAtom ].y;
i2Q = jQ.w;
i2Q *= preFactor;
i2BornR = bornRadii[ iAtom ];
i2AtomicR = atomicRadii[ iAtom ].x;
kAceNonPolarLoop1( i2BornR, i2AtomicR, duplicationFactor, aceForce );
bornForce2.xyz = zero3;
bornForce2.w = includeAce > 0.5f ? aceForce : 0.0f;
......@@ -244,11 +222,11 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat
iAtom.x += 1;
jQ = posq[ iAtom ];
i3BornR = bornRadii[ iAtom ];
i3AtomicR = atomicRadii[ iAtom ];
i3Pos = jQ.xyz;
i3Q = atomicRadii[ iAtom ].y;
i3Q = jQ.w;
i3Q *= preFactor;
i3BornR = bornRadii[ iAtom ];
i3AtomicR = atomicRadii[ iAtom ].x;
kAceNonPolarLoop1( i3BornR, i3AtomicR, duplicationFactor, aceForce );
bornForce3.xyz = zero3;
bornForce3.w = includeAce > 0.5f ? aceForce : 0.0f;
......@@ -260,11 +238,11 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat
iAtom.x += 1;
jQ = posq[ iAtom ];
i4BornR = bornRadii[ iAtom ];
i4AtomicR = atomicRadii[ iAtom ];
i4Pos = jQ.xyz;
i4Q = atomicRadii[ iAtom ].y;
i4Q = jQ.w;
i4Q *= preFactor;
i4BornR = bornRadii[ iAtom ];
i4AtomicR = atomicRadii[ iAtom ].x;
kAceNonPolarLoop1( i4BornR, i4AtomicR, duplicationFactor, aceForce );
bornForce4.xyz = zero3;
bornForce4.w = includeAce > 0.5f ? aceForce : 0.0f;
......@@ -286,8 +264,11 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat
tmp = fmod(forceIndex, roundedUpAtoms);
whichRep = round((forceIndex - tmp)/roundedUpAtoms);
//jBlock = 1 + floor( numberOfAtoms/(duplicationFactor*streamWidth ) );
tmp = fmod( numberOfAtoms, (duplicationFactor*streamWidth ) );
jBlock = 1 + round( (numberOfAtoms-tmp)/(duplicationFactor*streamWidth ));
jBlock = 1 + floor( numberOfAtoms/(duplicationFactor*streamWidth ) );
jStart = whichRep*jBlock;
jEnd = ( whichRep > duplicationFactor - 1.5f ) ? 999999.0f : (jStart + jBlock);
......@@ -305,23 +286,27 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat
// gather required values
j1Pos = posq[ jAtom ];
j1Q = atomicRadii[ jAtom ].y;
j1PosQ = posq[ jAtom ];
j1Pos = j1PosQ.xyz;
j1Q = j1PosQ.w;
j1BornR = bornRadii[ jAtom ];
jAtom.x += 1.0f;
j2Pos = posq[ jAtom ];
j2Q = atomicRadii[ jAtom ].y;
j2PosQ = posq[ jAtom ];
j2Pos = j2PosQ.xyz;
j2Q = j2PosQ.w;
j2BornR = bornRadii[ jAtom ];
jAtom.x += 1.0f;
j3Pos = posq[ jAtom ];
j3Q = atomicRadii[ jAtom ].y;
j3PosQ = posq[ jAtom ];
j3Pos = j3PosQ.xyz;
j3Q = j3PosQ.w;
j3BornR = bornRadii[ jAtom ];
jAtom.x += 1.0f;
j4Pos = posq[ jAtom ];
j4Q = atomicRadii[ jAtom ].y;
j4PosQ = posq[ jAtom ];
j4Pos = j4PosQ.xyz;
j4Q = j4PosQ.w;
j4BornR = bornRadii[ jAtom ];
jAtom.x += 1.0f;
......@@ -332,73 +317,73 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat
// i == 1
d1 = i1Pos - j1Pos;
d2 = i1Pos - j2Pos;
d3 = i1Pos - j3Pos;
d4 = i1Pos - j4Pos;
d1 = i1Pos - j1Pos; //3
d2 = i1Pos - j2Pos; //3
d3 = i1Pos - j3Pos; //3
d4 = i1Pos - j4Pos; //3
loop1Internal( d1, d2, d3, d4, jBornR, jQ, i1BornR, i1Q, dGpol_dr, dGpol_dalpha2_ij );
loop1Internal( d1, d2, d3, d4, jBornR, jQ, i1BornR, i1Q, dGpol_dr, dGpol_dalpha2_ij ); //96 : 228
bornForce1.xyz += dGpol_dr.x*d1;
bornForce1.xyz += dGpol_dr.y*d2;
bornForce1.xyz += dGpol_dr.z*d3;
bornForce1.xyz += dGpol_dr.w*d4;
bornForce1.xyz += dGpol_dr.x*d1; //6
bornForce1.xyz += dGpol_dr.y*d2; //6
bornForce1.xyz += dGpol_dr.z*d3; //6
bornForce1.xyz += dGpol_dr.w*d4; //6
bornForce1.w += dGpol_dalpha2_ij.x + dGpol_dalpha2_ij.y + dGpol_dalpha2_ij.z + dGpol_dalpha2_ij.w;
bornForce1.w += dGpol_dalpha2_ij.x + dGpol_dalpha2_ij.y + dGpol_dalpha2_ij.z + dGpol_dalpha2_ij.w; //4
// ---------------------------------------------------------------------------------------
// i == 2
d1 = i2Pos - j1Pos;
d2 = i2Pos - j2Pos;
d3 = i2Pos - j3Pos;
d4 = i2Pos - j4Pos;
d1 = i2Pos - j1Pos; //3
d2 = i2Pos - j2Pos; //3
d3 = i2Pos - j3Pos; //3
d4 = i2Pos - j4Pos; //3
loop1Internal( d1, d2, d3, d4, jBornR, jQ, i2BornR, i2Q, dGpol_dr, dGpol_dalpha2_ij );
loop1Internal( d1, d2, d3, d4, jBornR, jQ, i2BornR, i2Q, dGpol_dr, dGpol_dalpha2_ij ); //96 : 228
bornForce2.xyz += dGpol_dr.x*d1;
bornForce2.xyz += dGpol_dr.y*d2;
bornForce2.xyz += dGpol_dr.z*d3;
bornForce2.xyz += dGpol_dr.w*d4;
bornForce2.xyz += dGpol_dr.x*d1; //6
bornForce2.xyz += dGpol_dr.y*d2; //6
bornForce2.xyz += dGpol_dr.z*d3; //6
bornForce2.xyz += dGpol_dr.w*d4; //6
bornForce2.w += dGpol_dalpha2_ij.x + dGpol_dalpha2_ij.y + dGpol_dalpha2_ij.z + dGpol_dalpha2_ij.w;
bornForce2.w += dGpol_dalpha2_ij.x + dGpol_dalpha2_ij.y + dGpol_dalpha2_ij.z + dGpol_dalpha2_ij.w; //4
// ---------------------------------------------------------------------------------------
// i == 3
d1 = i3Pos - j1Pos;
d2 = i3Pos - j2Pos;
d3 = i3Pos - j3Pos;
d4 = i3Pos - j4Pos;
d1 = i3Pos - j1Pos; //3
d2 = i3Pos - j2Pos; //3
d3 = i3Pos - j3Pos; //3
d4 = i3Pos - j4Pos; //3
loop1Internal( d1, d2, d3, d4, jBornR, jQ, i3BornR, i3Q, dGpol_dr, dGpol_dalpha2_ij );
loop1Internal( d1, d2, d3, d4, jBornR, jQ, i3BornR, i3Q, dGpol_dr, dGpol_dalpha2_ij ); //96 : 228
bornForce3.xyz += dGpol_dr.x*d1;
bornForce3.xyz += dGpol_dr.y*d2;
bornForce3.xyz += dGpol_dr.z*d3;
bornForce3.xyz += dGpol_dr.w*d4;
bornForce3.xyz += dGpol_dr.x*d1; //6
bornForce3.xyz += dGpol_dr.y*d2; //6
bornForce3.xyz += dGpol_dr.z*d3; //6
bornForce3.xyz += dGpol_dr.w*d4; //6
bornForce3.w += dGpol_dalpha2_ij.x + dGpol_dalpha2_ij.y + dGpol_dalpha2_ij.z + dGpol_dalpha2_ij.w;
bornForce3.w += dGpol_dalpha2_ij.x + dGpol_dalpha2_ij.y + dGpol_dalpha2_ij.z + dGpol_dalpha2_ij.w; //4
// ---------------------------------------------------------------------------------------
// i == 4
d1 = i4Pos - j1Pos;
d2 = i4Pos - j2Pos;
d3 = i4Pos - j3Pos;
d4 = i4Pos - j4Pos;
d1 = i4Pos - j1Pos; //3
d2 = i4Pos - j2Pos; //3
d3 = i4Pos - j3Pos; //3
d4 = i4Pos - j4Pos; //3
loop1Internal( d1, d2, d3, d4, jBornR, jQ, i4BornR, i4Q, dGpol_dr, dGpol_dalpha2_ij );
loop1Internal( d1, d2, d3, d4, jBornR, jQ, i4BornR, i4Q, dGpol_dr, dGpol_dalpha2_ij ); //96 : 228
bornForce4.xyz += dGpol_dr.x*d1;
bornForce4.xyz += dGpol_dr.y*d2;
bornForce4.xyz += dGpol_dr.z*d3;
bornForce4.xyz += dGpol_dr.w*d4;
bornForce4.xyz += dGpol_dr.x*d1; //6
bornForce4.xyz += dGpol_dr.y*d2; //6
bornForce4.xyz += dGpol_dr.z*d3; //6
bornForce4.xyz += dGpol_dr.w*d4; //6
bornForce4.w += dGpol_dalpha2_ij.x + dGpol_dalpha2_ij.y + dGpol_dalpha2_ij.z + dGpol_dalpha2_ij.w;
bornForce4.w += dGpol_dalpha2_ij.x + dGpol_dalpha2_ij.y + dGpol_dalpha2_ij.z + dGpol_dalpha2_ij.w; //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