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( ){ ...@@ -53,7 +53,7 @@ BrookNonBonded::BrookNonBonded( ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
_atomSizeCeiling = -1; _particleSizeCeiling = -1;
_outerUnroll = 4; _outerUnroll = 4;
_innerUnroll = 4; _innerUnroll = 4;
...@@ -149,37 +149,37 @@ int BrookNonBonded::getOuterLoopUnroll( void ) const { ...@@ -149,37 +149,37 @@ int BrookNonBonded::getOuterLoopUnroll( void ) const {
int BrookNonBonded::setOuterLoopUnroll( int outerUnroll ){ int BrookNonBonded::setOuterLoopUnroll( int outerUnroll ){
if( outerUnroll != _outerUnroll ){ if( outerUnroll != _outerUnroll ){
_atomSizeCeiling = -1; _particleSizeCeiling = -1;
} }
_outerUnroll = _outerUnroll; _outerUnroll = _outerUnroll;
return _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); BrookNonBonded* localThis = const_cast<BrookNonBonded* const>(this);
localThis->_atomSizeCeiling = localThis->getNumberOfAtoms() % localThis->getOuterLoopUnroll(); localThis->_particleSizeCeiling = localThis->getNumberOfParticles() % localThis->getOuterLoopUnroll();
if( localThis->_atomSizeCeiling ){ if( localThis->_particleSizeCeiling ){
localThis->_atomSizeCeiling = localThis->getOuterLoopUnroll() - localThis->_atomSizeCeiling; 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 { ...@@ -465,14 +465,14 @@ int BrookNonBonded::isForceStreamSet( int index ) const {
/** /**
* Initialize stream dimensions * Initialize stream dimensions
* *
* @param numberOfAtoms number of atoms * @param numberOfParticles number of particles
* @param platform platform * @param platform platform
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @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 ...@@ -481,13 +481,13 @@ int BrookNonBonded::_initializeStreamSizes( int numberOfAtoms, const Platform& p
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
int atomStreamSize = getAtomStreamSize( platform ); int particleStreamSize = getParticleStreamSize( platform );
int atomStreamWidth = getAtomStreamWidth( platform ); int particleStreamWidth = getParticleStreamWidth( platform );
_initializeExclusionStreamSize( atomStreamSize, atomStreamWidth ); _initializeExclusionStreamSize( particleStreamSize, particleStreamWidth );
_initializeJStreamSize( atomStreamSize, atomStreamWidth ); _initializeJStreamSize( particleStreamSize, particleStreamWidth );
_initializeOuterVdwStreamSize( atomStreamSize, atomStreamWidth ); _initializeOuterVdwStreamSize( particleStreamSize, particleStreamWidth );
_initializePartialForceStreamSize( atomStreamSize, atomStreamWidth ); _initializePartialForceStreamSize( particleStreamSize, particleStreamWidth );
return DefaultReturnValue; return DefaultReturnValue;
} }
...@@ -521,8 +521,8 @@ int BrookNonBonded::_initializeStreams( const Platform& platform ){ ...@@ -521,8 +521,8 @@ int BrookNonBonded::_initializeStreams( const Platform& platform ){
// outer vdw // outer vdw
_nonbondedStreams[OuterVdwStream] = new BrookFloatStreamInternal( BrookCommon::OuterVdwStream, getAtomStreamSize(), _nonbondedStreams[OuterVdwStream] = new BrookFloatStreamInternal( BrookCommon::OuterVdwStream, getParticleStreamSize(),
getAtomStreamWidth(), BrookStreamInternal::Float2, dangleValue ); getParticleStreamWidth(), BrookStreamInternal::Float2, dangleValue );
// inner sigma & epsilon // inner sigma & epsilon
...@@ -534,8 +534,8 @@ int BrookNonBonded::_initializeStreams( const Platform& platform ){ ...@@ -534,8 +534,8 @@ int BrookNonBonded::_initializeStreams( const Platform& platform ){
// charge stream // charge stream
_nonbondedStreams[ChargeStream] = new BrookFloatStreamInternal( BrookCommon::NonBondedChargeStream, getAtomStreamSize(), _nonbondedStreams[ChargeStream] = new BrookFloatStreamInternal( BrookCommon::NonBondedChargeStream, getParticleStreamSize(),
getAtomStreamWidth(), BrookStreamInternal::Float, dangleValue ); getParticleStreamWidth(), BrookStreamInternal::Float, dangleValue );
// partial force streams // partial force streams
...@@ -554,8 +554,8 @@ int BrookNonBonded::_initializeStreams( const Platform& platform ){ ...@@ -554,8 +554,8 @@ int BrookNonBonded::_initializeStreams( const Platform& platform ){
/** /**
* Set exclusion (4x4) * Set exclusion (4x4)
* *
* @param i atom i index * @param i particle i index
* @param j atom j index * @param j particle j index
* @param exclusionStreamWidth exclusion stream width * @param exclusionStreamWidth exclusion stream width
* @param exclusion array of packed exclusions * @param exclusion array of packed exclusions
* *
...@@ -603,7 +603,7 @@ int BrookNonBonded::_setExclusion( int i, int j, int exclusionStreamWidth, Brook ...@@ -603,7 +603,7 @@ int BrookNonBonded::_setExclusion( int i, int j, int exclusionStreamWidth, Brook
/** /**
* Initialize exclusions * 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 platform Brook platform
* @param log optional Log file reference * @param log optional Log file reference
* *
...@@ -642,17 +642,17 @@ int BrookNonBonded::_initializeExclusions( const std::vector<std::set<int> >& ex ...@@ -642,17 +642,17 @@ int BrookNonBonded::_initializeExclusions( const std::vector<std::set<int> >& ex
// pack in values // pack in values
int exclusionStreamWidth = getExclusionStreamWidth(); int exclusionStreamWidth = getExclusionStreamWidth();
int numberOfAtoms = getNumberOfAtoms(); int numberOfParticles = getNumberOfParticles();
int atomStreamSize = getAtomStreamSize(); int particleStreamSize = getParticleStreamSize();
for( unsigned int ii = 0; ii < exclusionsVector.size(); ii++ ){ for( unsigned int ii = 0; ii < exclusionsVector.size(); ii++ ){
set<int> exclusionIndices = exclusionsVector[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; int hitII = 0;
for( set<int>::const_iterator jj = exclusionIndices.begin(); jj != exclusionIndices.end(); jj++ ){ 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 ); _setExclusion( ii, *jj, exclusionStreamWidth, exclusions );
if( *jj == ii )hitII = 1; if( *jj == ii )hitII = 1;
} }
...@@ -660,16 +660,16 @@ int BrookNonBonded::_initializeExclusions( const std::vector<std::set<int> >& ex ...@@ -660,16 +660,16 @@ int BrookNonBonded::_initializeExclusions( const std::vector<std::set<int> >& ex
_setExclusion( ii, ii, exclusionStreamWidth, exclusions ); _setExclusion( ii, ii, exclusionStreamWidth, exclusions );
} }
// explicitly exclude junk atoms from interacting w/ atom ii // explicitly exclude junk particles from interacting w/ particle ii
for( int jj = numberOfAtoms; jj < atomStreamSize; jj++ ){ for( int jj = numberOfParticles; jj < particleStreamSize; jj++ ){
_setExclusion( ii, jj, exclusionStreamWidth, exclusions ); _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 ii = numberOfParticles; ii < particleStreamSize; ii++ ){
for( int jj = 0; jj < atomStreamSize; jj++ ){ for( int jj = 0; jj < particleStreamSize; jj++ ){
_setExclusion( ii, jj, exclusionStreamWidth, exclusions ); _setExclusion( ii, jj, exclusionStreamWidth, exclusions );
} }
} }
...@@ -678,8 +678,8 @@ int BrookNonBonded::_initializeExclusions( const std::vector<std::set<int> >& ex ...@@ -678,8 +678,8 @@ int BrookNonBonded::_initializeExclusions( const std::vector<std::set<int> >& ex
if( 1 && debug && getLog() ){ if( 1 && debug && getLog() ){
FILE* log = 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(), (void) fprintf( log, "%s particles=%d excl=%d exStrSz=%d w=%d atmStrSz=%d\n", methodName.c_str(), numberOfParticles, exclusionsVector.size(),
exclusionStreamSize, exclusionStreamWidth, atomStreamSize ); exclusionStreamSize, exclusionStreamWidth, particleStreamSize );
/* /*
for( int ii = 0; ii < exclusionStreamSize; ii++ ){ for( int ii = 0; ii < exclusionStreamSize; ii++ ){
int index = ii/exclusionStreamWidth; int index = ii/exclusionStreamWidth;
...@@ -688,17 +688,17 @@ int offset = ii - index*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 ); (void) fprintf( log, "%6d ", ii );
int count = 0; int count = 0;
for( int jj = 0; jj <= numberOfAtoms/4; jj++ ){ for( int jj = 0; jj <= numberOfParticles/4; jj++ ){
int index = jj*exclusionStreamWidth + ii; int index = jj*exclusionStreamWidth + ii;
(void) fprintf( log, " [%4d %4d] %5.1f", jj*4, jj*4+3, exclusions[index] ); (void) fprintf( log, " [%4d %4d] %5.1f", jj*4, jj*4+3, exclusions[index] );
int excludeValue = (int) (exclusions[index] + 0.01); int excludeValue = (int) (exclusions[index] + 0.01);
if( (excludeValue % 2) )count++; if( (excludeValue % 2) )count++;
if( (jj*4+1) < numberOfAtoms && (excludeValue % 3) )count++; if( (jj*4+1) < numberOfParticles && (excludeValue % 3) )count++;
if( (jj*4+2) < numberOfAtoms && (excludeValue % 5) )count++; if( (jj*4+2) < numberOfParticles && (excludeValue % 5) )count++;
if( (jj*4+3) < numberOfAtoms && (excludeValue % 7) )count++; if( (jj*4+3) < numberOfParticles && (excludeValue % 7) )count++;
} }
(void) fprintf( log, " TtlExcl=%d\n", count ); (void) fprintf( log, " TtlExcl=%d\n", count );
} }
...@@ -750,7 +750,7 @@ int BrookNonBonded::_setSigmaEpsilon( double c6, double c12, double* sigma , dou ...@@ -750,7 +750,7 @@ int BrookNonBonded::_setSigmaEpsilon( double c6, double c12, double* sigma , dou
/** /**
* Initialize vdw & charge * 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 * @param platform platform
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @return ErrorReturnValue if error, else DefaultReturnValue
...@@ -770,22 +770,22 @@ int BrookNonBonded::_initializeVdwAndCharge( const vector<vector<double> >& nonb ...@@ -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() ); (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 // allocate and initialize vdw & charge array
unsigned int vdwParametersSize = 2*atomStreamSize; unsigned int vdwParametersSize = 2*particleStreamSize;
BrookOpenMMFloat* vdwParameters = new BrookOpenMMFloat[vdwParametersSize]; BrookOpenMMFloat* vdwParameters = new BrookOpenMMFloat[vdwParametersSize];
memset( vdwParameters, 0, sizeof( BrookOpenMMFloat )*vdwParametersSize ); memset( vdwParameters, 0, sizeof( BrookOpenMMFloat )*vdwParametersSize );
BrookOpenMMFloat* charges = new BrookOpenMMFloat[atomStreamSize]; BrookOpenMMFloat* charges = new BrookOpenMMFloat[particleStreamSize];
memset( charges, 0, sizeof( BrookOpenMMFloat )*atomStreamSize ); memset( charges, 0, sizeof( BrookOpenMMFloat )*particleStreamSize );
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// pack in values // pack in values
int numberOfAtoms = getNumberOfAtoms(); int numberOfParticles = getNumberOfParticles();
int trackingIndex = 0; int trackingIndex = 0;
double sigma, epsilon; double sigma, epsilon;
for( unsigned int ii = 0; ii < nonbondedParameters.size(); ii++ ){ for( unsigned int ii = 0; ii < nonbondedParameters.size(); ii++ ){
...@@ -813,9 +813,9 @@ int BrookNonBonded::_initializeVdwAndCharge( const vector<vector<double> >& nonb ...@@ -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) 1.0;
vdwParameters[trackingIndex++] = (BrookOpenMMFloat) 0.0; vdwParameters[trackingIndex++] = (BrookOpenMMFloat) 0.0;
} }
...@@ -832,8 +832,8 @@ int BrookNonBonded::_initializeVdwAndCharge( const vector<vector<double> >& nonb ...@@ -832,8 +832,8 @@ int BrookNonBonded::_initializeVdwAndCharge( const vector<vector<double> >& nonb
if( 1 && debug && getLog() ){ if( 1 && debug && getLog() ){
FILE* log = getLog(); FILE* log = getLog();
int trackingIndex = 0; int trackingIndex = 0;
(void) fprintf( log, "%s atoms=%d strSz=%d\n vdw[Sig Eps] Q\n", methodName.c_str(), numberOfAtoms, atomStreamSize ); (void) fprintf( log, "%s particles=%d strSz=%d\n vdw[Sig Eps] Q\n", methodName.c_str(), numberOfParticles, particleStreamSize );
for( int ii = 0; ii < atomStreamSize; ii++, trackingIndex += 2 ){ 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) fprintf( log, " %d %10.3f %10.3f %10.3f\n", ii, vdwParameters[trackingIndex], vdwParameters[trackingIndex+1], charges[ii] );
} }
(void) fflush( log ); (void) fflush( log );
...@@ -849,7 +849,7 @@ int BrookNonBonded::_initializeVdwAndCharge( const vector<vector<double> >& nonb ...@@ -849,7 +849,7 @@ int BrookNonBonded::_initializeVdwAndCharge( const vector<vector<double> >& nonb
/** /**
* Initialize vdw & charge * 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 * @param platform platform
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @return ErrorReturnValue if error, else DefaultReturnValue
...@@ -885,7 +885,7 @@ int BrookNonBonded::_initializeJStreamVdw( const vector<vector<double> >& nonbon ...@@ -885,7 +885,7 @@ int BrookNonBonded::_initializeJStreamVdw( const vector<vector<double> >& nonbon
// pack in values // pack in values
int numberOfAtoms = getNumberOfAtoms(); int numberOfParticles = getNumberOfParticles();
int trackingIndex = 0; int trackingIndex = 0;
double sigma, epsilon; double sigma, epsilon;
for( unsigned int ii = 0; ii < nonbondedParameters.size(); ii++ ){ for( unsigned int ii = 0; ii < nonbondedParameters.size(); ii++ ){
...@@ -908,7 +908,7 @@ int BrookNonBonded::_initializeJStreamVdw( const vector<vector<double> >& nonbon ...@@ -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++ ){ for( unsigned int ii = nonbondedParameters.size(); ii < (unsigned int) jParametersSize; ii++ ){
sigmaParameters[ii] = (BrookOpenMMFloat) 1.0; sigmaParameters[ii] = (BrookOpenMMFloat) 1.0;
...@@ -927,7 +927,7 @@ int BrookNonBonded::_initializeJStreamVdw( const vector<vector<double> >& nonbon ...@@ -927,7 +927,7 @@ int BrookNonBonded::_initializeJStreamVdw( const vector<vector<double> >& nonbon
if( 1 && debug && getLog() ){ if( 1 && debug && getLog() ){
FILE* log = getLog(); FILE* log = getLog();
int trackingIndex = 0; 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++ ){ for( unsigned int ii = 0; ii < jParametersSize; ii++ ){
(void) fprintf( log, " %d %10.3f %10.3f\n", ii, sigmaParameters[ii], epsilonParameters[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 ...@@ -943,17 +943,17 @@ int BrookNonBonded::_initializeJStreamVdw( const vector<vector<double> >& nonbon
/* /*
* Setup of nonbonded ixns * Setup of nonbonded ixns
* *
* @param numberOfAtoms number of atoms * @param numberOfParticles number of particles
* @param nonbondedParameters vector of nonbonded parameters [atomI][0=c6] * @param nonbondedParameters vector of nonbonded parameters [particleI][0=c6]
* [atomI][1=c12] * [particleI][1=c12]
* [atomI][2=charge] * [particleI][2=charge]
* @param platform Brook platform * @param platform Brook platform
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @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 ){ 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 ...@@ -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 ); _initializeStreams( platform );
_initializeExclusions( exclusions, platform ); _initializeExclusions( exclusions, platform );
...@@ -978,14 +978,14 @@ int BrookNonBonded::setup( int numberOfAtoms, const std::vector<std::vector<doub ...@@ -978,14 +978,14 @@ int BrookNonBonded::setup( int numberOfAtoms, const std::vector<std::vector<doub
/* /*
* Setup of stream dimensions for exclusion stream * Setup of stream dimensions for exclusion stream
* *
* @param atomStreamSize atom stream size * @param particleStreamSize particle stream size
* @param atomStreamWidth atom stream width * @param particleStreamWidth particle stream width
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @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 ...@@ -994,7 +994,7 @@ int BrookNonBonded::_initializeExclusionStreamSize( int atomStreamSize, int atom
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
_exclusionStreamWidth = atomStreamSize; _exclusionStreamWidth = particleStreamSize;
int innerUnroll = getInnerLoopUnroll(); int innerUnroll = getInnerLoopUnroll();
if( innerUnroll < 1 ){ if( innerUnroll < 1 ){
std::stringstream message; std::stringstream message;
...@@ -1012,8 +1012,8 @@ int BrookNonBonded::_initializeExclusionStreamSize( int atomStreamSize, int atom ...@@ -1012,8 +1012,8 @@ int BrookNonBonded::_initializeExclusionStreamSize( int atomStreamSize, int atom
/* /*
* Setup of j-stream dimensions * Setup of j-stream dimensions
* *
* @param atomStreamSize atom stream size * @param particleStreamSize particle stream size
* @param atomStreamWidth atom stream width * @param particleStreamWidth particle stream width
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @return ErrorReturnValue if error, else DefaultReturnValue
* *
...@@ -1021,7 +1021,7 @@ int BrookNonBonded::_initializeExclusionStreamSize( int atomStreamSize, int atom ...@@ -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 ...@@ -1049,7 +1049,7 @@ int BrookNonBonded::_initializeJStreamSize( int atomStreamSize, int atomStreamWi
// set dimesnions // set dimesnions
_jStreamSize = atomStreamSize/innerUnroll; _jStreamSize = particleStreamSize/innerUnroll;
_jStreamHeight = _jStreamSize/jStreamWidth; _jStreamHeight = _jStreamSize/jStreamWidth;
_jStreamHeight += ( (_jStreamSize % _jStreamWidth) ? 1 : 0 ); _jStreamHeight += ( (_jStreamSize % _jStreamWidth) ? 1 : 0 );
_jStreamSize = jStreamWidth*_jStreamHeight; _jStreamSize = jStreamWidth*_jStreamHeight;
...@@ -1060,8 +1060,8 @@ int BrookNonBonded::_initializeJStreamSize( int atomStreamSize, int atomStreamWi ...@@ -1060,8 +1060,8 @@ int BrookNonBonded::_initializeJStreamSize( int atomStreamSize, int atomStreamWi
/* /*
* Setup of outer vdw stream size * Setup of outer vdw stream size
* *
* @param atomStreamSize atom stream size * @param particleStreamSize particle stream size
* @param atomStreamWidth atom stream width * @param particleStreamWidth particle stream width
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @return ErrorReturnValue if error, else DefaultReturnValue
* *
...@@ -1069,7 +1069,7 @@ int BrookNonBonded::_initializeJStreamSize( int atomStreamSize, int atomStreamWi ...@@ -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 ...@@ -1097,7 +1097,7 @@ int BrookNonBonded::_initializeOuterVdwStreamSize( int atomStreamSize, int atomS
// set dimesnions // set dimesnions
_jStreamSize = atomStreamSize/innerUnroll; _jStreamSize = particleStreamSize/innerUnroll;
_jStreamHeight = _jStreamSize/jStreamWidth; _jStreamHeight = _jStreamSize/jStreamWidth;
_jStreamHeight += ( (_jStreamSize % _jStreamWidth) ? 1 : 0 ); _jStreamHeight += ( (_jStreamSize % _jStreamWidth) ? 1 : 0 );
_jStreamSize = jStreamWidth*_jStreamHeight; _jStreamSize = jStreamWidth*_jStreamHeight;
...@@ -1109,14 +1109,14 @@ int BrookNonBonded::_initializeOuterVdwStreamSize( int atomStreamSize, int atomS ...@@ -1109,14 +1109,14 @@ int BrookNonBonded::_initializeOuterVdwStreamSize( int atomStreamSize, int atomS
/* /*
* Setup of stream dimensions for partial force streams * Setup of stream dimensions for partial force streams
* *
* @param atomStreamSize atom stream size * @param particleStreamSize particle stream size
* @param atomStreamWidth atom stream width * @param particleStreamWidth particle stream width
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @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 ...@@ -1139,7 +1139,7 @@ int BrookNonBonded::_initializePartialForceStreamSize( int atomStreamSize, int a
return ErrorReturnValue; return ErrorReturnValue;
} }
_partialForceStreamSize = atomStreamSize*getDuplicationFactor()/innerUnroll; _partialForceStreamSize = particleStreamSize*getDuplicationFactor()/innerUnroll;
_partialForceStreamHeight = _partialForceStreamSize/_partialForceStreamWidth; _partialForceStreamHeight = _partialForceStreamSize/_partialForceStreamWidth;
_partialForceStreamHeight += ( (_partialForceStreamSize % _partialForceStreamWidth) ? 1 : 0); _partialForceStreamHeight += ( (_partialForceStreamSize % _partialForceStreamWidth) ? 1 : 0);
...@@ -1177,8 +1177,8 @@ std::string BrookNonBonded::getContentsString( int level ) const { ...@@ -1177,8 +1177,8 @@ std::string BrookNonBonded::getContentsString( int level ) const {
#define LOCAL_SPRINTF(a,b,c) sprintf( (a), (b), (c) ); #define LOCAL_SPRINTF(a,b,c) sprintf( (a), (b), (c) );
#endif #endif
(void) LOCAL_SPRINTF( value, "%d", getNumberOfAtoms() ); (void) LOCAL_SPRINTF( value, "%d", getNumberOfParticles() );
message << _getLine( tab, "Number of atoms:", value ); message << _getLine( tab, "Number of particles:", value );
(void) LOCAL_SPRINTF( value, "%d", getNumberOfForceStreams() ); (void) LOCAL_SPRINTF( value, "%d", getNumberOfForceStreams() );
message << _getLine( tab, "Number of force streams:", value ); message << _getLine( tab, "Number of force streams:", value );
...@@ -1192,17 +1192,17 @@ std::string BrookNonBonded::getContentsString( int level ) const { ...@@ -1192,17 +1192,17 @@ std::string BrookNonBonded::getContentsString( int level ) const {
(void) LOCAL_SPRINTF( value, "%d", getOuterLoopUnroll() ) (void) LOCAL_SPRINTF( value, "%d", getOuterLoopUnroll() )
message << _getLine( tab, "Outer loop unroll:", value ); message << _getLine( tab, "Outer loop unroll:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomSizeCeiling() ); (void) LOCAL_SPRINTF( value, "%d", getParticleSizeCeiling() );
message << _getLine( tab, "Atom ceiling:", value ); message << _getLine( tab, "Particle ceiling:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamWidth() ); (void) LOCAL_SPRINTF( value, "%d", getParticleStreamWidth() );
message << _getLine( tab, "Atom stream width:", value ); message << _getLine( tab, "Particle stream width:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamHeight() ); (void) LOCAL_SPRINTF( value, "%d", getParticleStreamHeight() );
message << _getLine( tab, "Atom stream height:", value ); message << _getLine( tab, "Particle stream height:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamSize() ); (void) LOCAL_SPRINTF( value, "%d", getParticleStreamSize() );
message << _getLine( tab, "Atom stream size:", value ); message << _getLine( tab, "Particle stream size:", value );
(void) LOCAL_SPRINTF( value, "%d", getJStreamWidth() ); (void) LOCAL_SPRINTF( value, "%d", getJStreamWidth() );
message << _getLine( tab, "J-stream width:", value ); message << _getLine( tab, "J-stream width:", value );
...@@ -1264,3 +1264,123 @@ std::string BrookNonBonded::getContentsString( int level ) const { ...@@ -1264,3 +1264,123 @@ std::string BrookNonBonded::getContentsString( int level ) const {
return message.str(); 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 @@ ...@@ -35,8 +35,7 @@
#include <vector> #include <vector>
#include <set> #include <set>
#include "BrookFloatStreamInternal.h" #include "BrookStreamImpl.h"
#include "BrookIntStreamInternal.h"
#include "BrookPlatform.h" #include "BrookPlatform.h"
#include "BrookCommon.h" #include "BrookCommon.h"
...@@ -72,13 +71,13 @@ class BrookNonBonded : public BrookCommon { ...@@ -72,13 +71,13 @@ class BrookNonBonded : public BrookCommon {
int getDuplicationFactor( void ) const; 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 * Get outer loop unroll
...@@ -292,6 +291,13 @@ class BrookNonBonded : public BrookCommon { ...@@ -292,6 +291,13 @@ class BrookNonBonded : public BrookCommon {
BrookFloatStreamInternal** getForceStreams( void ); BrookFloatStreamInternal** getForceStreams( void );
/**
* Compute forces
*
*/
void computeForces( BrookStreamImpl& positionStream, BrookStreamImpl& forceStream );
/** /**
* Return true if force[index] stream is set * Return true if force[index] stream is set
* *
...@@ -304,17 +310,17 @@ class BrookNonBonded : public BrookCommon { ...@@ -304,17 +310,17 @@ class BrookNonBonded : public BrookCommon {
/* /*
* Setup of nonbonded ixns * Setup of nonbonded ixns
* *
* @param numberOfAtoms number of atoms * @param numberOfParticles number of particles
* @param nonbondedParameters vector of nonbonded parameters [atomI][0=c6] * @param nonbondedParameters vector of nonbonded parameters [particleI][0=c6]
* [atomI][1=c12] * [particleI][1=c12]
* [atomI][2=charge] * [particleI][2=charge]
* @param platform Brook platform * @param platform Brook platform
* @param log optional Log file reference * @param log optional Log file reference
* *
* @return nonzero value if error * @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 ); const std::vector<std::set<int> >& exclusions, const Platform& platform );
/* /*
...@@ -345,9 +351,9 @@ class BrookNonBonded : public BrookCommon { ...@@ -345,9 +351,9 @@ class BrookNonBonded : public BrookCommon {
LastStreamIndex LastStreamIndex
}; };
// atom ceiling // particle ceiling
int _atomSizeCeiling; int _particleSizeCeiling;
// unroll in i/j dimensions // unroll in i/j dimensions
...@@ -384,14 +390,14 @@ class BrookNonBonded : public BrookCommon { ...@@ -384,14 +390,14 @@ class BrookNonBonded : public BrookCommon {
/* /*
* Setup of stream dimensions for exclusion stream * Setup of stream dimensions for exclusion stream
* *
* @param atomStreamSize atom stream size * @param particleStreamSize particle stream size
* @param atomStreamWidth atom stream width * @param particleStreamWidth particle stream width
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @return ErrorReturnValue if error, else DefaultReturnValue
* *
* */ * */
int _initializeExclusionStreamSize( int atomStreamSize, int atomStreamWidth ); int _initializeExclusionStreamSize( int particleStreamSize, int particleStreamWidth );
/** /**
* Initialize exclusion stream dimensions and stream * Initialize exclusion stream dimensions and stream
...@@ -407,8 +413,8 @@ class BrookNonBonded : public BrookCommon { ...@@ -407,8 +413,8 @@ class BrookNonBonded : public BrookCommon {
/** /**
* Set exclusion (4x4) * Set exclusion (4x4)
* *
* @param i atom i index * @param i particle i index
* @param j atom j index * @param j particle j index
* @param exclusionStreamWidth exclusion stream width * @param exclusionStreamWidth exclusion stream width
* @param exclusion array of packed exclusions * @param exclusion array of packed exclusions
* *
...@@ -421,7 +427,7 @@ class BrookNonBonded : public BrookCommon { ...@@ -421,7 +427,7 @@ class BrookNonBonded : public BrookCommon {
/** /**
* Initialize exclusions * 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 * @param platform platform
* *
* @return nonzero value if error * @return nonzero value if error
...@@ -433,14 +439,14 @@ class BrookNonBonded : public BrookCommon { ...@@ -433,14 +439,14 @@ class BrookNonBonded : public BrookCommon {
/** /**
* Initialize stream dimensions * Initialize stream dimensions
* *
* @param numberOfAtoms number of atoms * @param numberOfParticles number of particles
* @param platform platform * @param platform platform
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @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 * Initialize stream dimensions and streams
...@@ -456,8 +462,8 @@ class BrookNonBonded : public BrookCommon { ...@@ -456,8 +462,8 @@ class BrookNonBonded : public BrookCommon {
/* /*
* Setup of j-stream dimensions * Setup of j-stream dimensions
* *
* @param atomStreamSize atom stream size * @param particleStreamSize particle stream size
* @param atomStreamWidth atom stream width * @param particleStreamWidth particle stream width
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @return ErrorReturnValue if error, else DefaultReturnValue
* *
...@@ -465,13 +471,13 @@ class BrookNonBonded : public BrookCommon { ...@@ -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 * Setup of outer vdw stream size
* *
* @param atomStreamSize atom stream size * @param particleStreamSize particle stream size
* @param atomStreamWidth atom stream width * @param particleStreamWidth particle stream width
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @return ErrorReturnValue if error, else DefaultReturnValue
* *
...@@ -479,7 +485,7 @@ class BrookNonBonded : public BrookCommon { ...@@ -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) * Set sigma & epsilon given c6 & c12 (geometric rule)
...@@ -498,7 +504,7 @@ class BrookNonBonded : public BrookCommon { ...@@ -498,7 +504,7 @@ class BrookNonBonded : public BrookCommon {
/** /**
* Initialize vdw & charge * 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 * @param platform platform
* *
* @return nonzero value if error * @return nonzero value if error
...@@ -510,7 +516,7 @@ class BrookNonBonded : public BrookCommon { ...@@ -510,7 +516,7 @@ class BrookNonBonded : public BrookCommon {
/** /**
* Initialize vdw & charge * 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 * @param platform platform
* *
* @return nonzero value if error * @return nonzero value if error
...@@ -522,14 +528,14 @@ class BrookNonBonded : public BrookCommon { ...@@ -522,14 +528,14 @@ class BrookNonBonded : public BrookCommon {
/* /*
* Setup of stream dimensions for partial force streams * Setup of stream dimensions for partial force streams
* *
* @param atomStreamSize atom stream size * @param particleStreamSize particle stream size
* @param atomStreamWidth atom stream width * @param particleStreamWidth particle stream width
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @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 @@ ...@@ -31,6 +31,8 @@
#include "BrookPlatform.h" #include "BrookPlatform.h"
#include "BrookKernelFactory.h" #include "BrookKernelFactory.h"
#include "OpenMMBrookInterface.h"
#include "internal/OpenMMContextImpl.h"
#include "OpenMMException.h" #include "OpenMMException.h"
#include "kernels.h" #include "kernels.h"
#include "../../reference/src/SimTKUtilities/SimTKOpenMMRealType.h" #include "../../reference/src/SimTKUtilities/SimTKOpenMMRealType.h"
...@@ -42,6 +44,121 @@ ...@@ -42,6 +44,121 @@
using namespace OpenMM; 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 * Register BrookPlatform
* *
...@@ -78,8 +195,9 @@ BrookPlatform::BrookPlatform( ){ ...@@ -78,8 +195,9 @@ BrookPlatform::BrookPlatform( ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
_atomStreamWidth = DefaultAtomStreamWidth; _particleStreamWidth = DefaultParticleStreamWidth;
_log = NULL; _log = NULL;
_openMMBrookInterface = NULL;
// get Brook runtime // get Brook runtime
...@@ -102,13 +220,13 @@ BrookPlatform::BrookPlatform( ){ ...@@ -102,13 +220,13 @@ BrookPlatform::BrookPlatform( ){
/** /**
* BrookPlatform constructor * BrookPlatform constructor
* *
* @param defaultAtomStreamWidth stream width * @param defaultParticleStreamWidth stream width
* @param runtime Brook runtime (cal/cpu) * @param runtime Brook runtime (cal/cpu)
* @param log log file reference * @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 ...@@ -116,8 +234,8 @@ BrookPlatform::BrookPlatform( int atomStreamWidth, const std::string& runtime, F
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
_log = log; _openMMBrookInterface = NULL;
_atomStreamWidth = atomStreamWidth;
_initializeKernelFactory( ); _initializeKernelFactory( );
_setBrookRuntime( runtime ); _setBrookRuntime( runtime );
...@@ -153,8 +271,8 @@ void BrookPlatform::_initializeKernelFactory( void ){ ...@@ -153,8 +271,8 @@ void BrookPlatform::_initializeKernelFactory( void ){
BrookKernelFactory* factory = new BrookKernelFactory(); BrookKernelFactory* factory = new BrookKernelFactory();
registerKernelFactory( CalcNonbondedForceKernel::Name(), factory); registerKernelFactory( CalcNonbondedForceKernel::Name(), factory);
registerKernelFactory( CalcGBSAOBCForceKernel::Name(), factory); registerKernelFactory( CalcGBSAOBCForceKernel::Name(), factory);
registerKernelFactory( IntegrateVerletStepKernel::Name(), factory); registerKernelFactory( IntegrateVerletStepKernel::Name(), factory);
registerKernelFactory( IntegrateLangevinStepKernel::Name(), factory); registerKernelFactory( IntegrateLangevinStepKernel::Name(), factory);
registerKernelFactory( IntegrateBrownianStepKernel::Name(), factory); registerKernelFactory( IntegrateBrownianStepKernel::Name(), factory);
...@@ -183,7 +301,10 @@ void BrookPlatform::_setBrookRuntime( const std::string& runtime ){ ...@@ -183,7 +301,10 @@ void BrookPlatform::_setBrookRuntime( const std::string& runtime ){
// set & validate runtime // set & validate runtime
_runtime = 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" ){ if( _runtime != "cal" && _runtime != "cpu" ){
std::stringstream message; std::stringstream message;
message << methodName << " Brook runtime=" << _runtime << " not recognized."; message << methodName << " Brook runtime=" << _runtime << " not recognized.";
...@@ -306,3 +427,38 @@ int BrookPlatform::setLog( FILE* log ){ ...@@ -306,3 +427,38 @@ int BrookPlatform::setLog( FILE* log ){
return BrookPlatform::DefaultErrorValue; 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( ){ ...@@ -65,7 +65,8 @@ BrookRandomNumberGenerator::BrookRandomNumberGenerator( ){
_rvStreamIndex = 0; _rvStreamIndex = 0;
_rvStreamOffset = 0; _rvStreamOffset = 0;
_numberOfShuffles = 0; _numberOfShuffles = 0;
_maxShuffles = 100; _maxShuffles = 3;
//_maxShuffles = 100;
_loadBuffer = NULL; _loadBuffer = NULL;
_shuffleIndices = NULL; _shuffleIndices = NULL;
...@@ -617,7 +618,7 @@ int BrookRandomNumberGenerator::_shuffleGVStreams( void ){ ...@@ -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 * If we run out of rand numbers, we shuffle and
* reuse a few times before reloading from the cpu * reuse a few times before reloading from the cpu
* *
...@@ -630,7 +631,9 @@ int BrookRandomNumberGenerator::advanceGVCursor( int numberOfRandomValuesConsume ...@@ -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 ...@@ -644,12 +647,15 @@ int BrookRandomNumberGenerator::advanceGVCursor( int numberOfRandomValuesConsume
if ( _rvStreamOffset > rvStreamSize - numberOfRandomValuesConsumedPerIteration ){ if ( _rvStreamOffset > rvStreamSize - numberOfRandomValuesConsumedPerIteration ){
char* action;
// next one if available // next one if available
_rvStreamOffset = 0; _rvStreamOffset = 0;
if ( _rvStreamIndex < _numberOfRandomNumberStreams - 1 ){ if ( _rvStreamIndex < _numberOfRandomNumberStreams - 1 ){
_rvStreamIndex++; _rvStreamIndex++;
action = "incremented stream index";
} else { } else {
//No more textures, need to shuffle //No more textures, need to shuffle
...@@ -658,18 +664,26 @@ int BrookRandomNumberGenerator::advanceGVCursor( int numberOfRandomValuesConsume ...@@ -658,18 +664,26 @@ int BrookRandomNumberGenerator::advanceGVCursor( int numberOfRandomValuesConsume
_shuffleGVStreams( ); _shuffleGVStreams( );
_numberOfShuffles++; _numberOfShuffles++;
action = "shuffled streams";
} else { //Need to refresh random numbers from cpu } else { //Need to refresh random numbers from cpu
if( UseOriginalRng ){ if( UseOriginalRng ){
action = "loaded new values from GPU using original rng";
_loadGVStreamsOriginal( ); _loadGVStreamsOriginal( );
} else { } else {
_loadRandomNumberStreamsKiss( ); _loadRandomNumberStreamsKiss( );
action = "loaded new values from GPU using KISS rng";
} }
_numberOfShuffles = 0; _numberOfShuffles = 0;
} }
_rvStreamIndex = 0; _rvStreamIndex = 0;
} }
if( PrintOn && getLog() ){
(void) fprintf( getLog(), "%s StrmIdx=%d action=%s", methodName, _rvStreamIndex, action );
(void) fflush( getLog() );
}
} }
return DefaultReturnValue; return DefaultReturnValue;
...@@ -700,7 +714,7 @@ BrookFloatStreamInternal* BrookRandomNumberGenerator::_getShuffleStream( void ) ...@@ -700,7 +714,7 @@ BrookFloatStreamInternal* BrookRandomNumberGenerator::_getShuffleStream( void )
/** /**
* Get random number stream * Get random number stream
* *
* @param index random number stream index * @param index random number stream index
* *
* @return random number stream * @return random number stream
* *
...@@ -780,14 +794,14 @@ int BrookRandomNumberGenerator::_getNumberOfShuffles( void ) const { ...@@ -780,14 +794,14 @@ int BrookRandomNumberGenerator::_getNumberOfShuffles( void ) const {
/** /**
* Initialize stream dimensions * Initialize stream dimensions
* *
* @param numberOfAtoms number of atoms * @param numberOfParticles number of particles
* @param platform platform * @param platform platform
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @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 ...@@ -795,7 +809,7 @@ int BrookRandomNumberGenerator::_initializeStreamSizes( int numberOfAtoms, const
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
setNumberOfAtoms( numberOfAtoms ); setNumberOfParticles( numberOfParticles );
// get randomNumber stream dimensions // get randomNumber stream dimensions
...@@ -862,14 +876,14 @@ int BrookRandomNumberGenerator::_initializeStreams( const Platform& platform ){ ...@@ -862,14 +876,14 @@ int BrookRandomNumberGenerator::_initializeStreams( const Platform& platform ){
/* /*
* Setup of StochasticDynamics parameters * Setup of StochasticDynamics parameters
* *
* @param numberOfAtoms number of atoms * @param numberOfParticles number of particles
* @param platform Brook platform * @param platform Brook platform
* *
* @return nonzero value if error * @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 ...@@ -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 // set stream sizes and then create streams
_initializeStreamSizes( numberOfAtoms, platform ); _initializeStreamSizes( numberOfParticles, platform );
_initializeStreams( platform ); _initializeStreams( platform );
if( UseOriginalRng ){ if( UseOriginalRng ){
_loadGVStreamsOriginal( ); _loadGVStreamsOriginal( );
......
platforms/brook/src/BrookRandomNumberGenerator.h
View file @ 309008f7
...@@ -109,14 +109,14 @@ class BrookRandomNumberGenerator : public BrookCommon { ...@@ -109,14 +109,14 @@ class BrookRandomNumberGenerator : public BrookCommon {
/* /*
* Setup of RNG parameters * Setup of RNG parameters
* *
* @param numberOfAtoms number of atoms * @param numberOfParticles number of particles
* @param platform Brook platform * @param platform Brook platform
* *
* @return ErrorReturnValue value if error, else DefaultReturnValue * @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 * Get contents of object
...@@ -266,26 +266,26 @@ class BrookRandomNumberGenerator : public BrookCommon { ...@@ -266,26 +266,26 @@ class BrookRandomNumberGenerator : public BrookCommon {
/* /*
* Setup of stream dimensions * Setup of stream dimensions
* *
* @param atomStreamSize atom stream size * @param particleStreamSize particle stream size
* @param atomStreamWidth atom stream width * @param particleStreamWidth particle stream width
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @return ErrorReturnValue if error, else DefaultReturnValue
* *
* */ * */
int _initializeStreamSizes( int atomStreamSize, int atomStreamWidth ); int _initializeStreamSizes( int particleStreamSize, int particleStreamWidth );
/** /**
* Initialize stream dimensions * Initialize stream dimensions
* *
* @param numberOfAtoms number of atoms * @param numberOfParticles number of particles
* @param platform platform * @param platform platform
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @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 * Initialize stream dimensions and streams
......
platforms/brook/src/BrookRemoveCMMotionKernel.cpp
View file @ 309008f7
...@@ -75,7 +75,7 @@ BrookRemoveCMMotionKernel::~BrookRemoveCMMotionKernel( ){ ...@@ -75,7 +75,7 @@ BrookRemoveCMMotionKernel::~BrookRemoveCMMotionKernel( ){
/** /**
* Initialize the kernel * 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 ){ ...@@ -97,7 +97,7 @@ void BrookRemoveCMMotionKernel::initialize( const vector<double>& masses ){
/** /**
* Execute kernel * 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 { ...@@ -65,7 +65,7 @@ class BrookRemoveCMMotionKernel : public RemoveCMMotionKernel {
/** /**
* Initialize the kernel * Initialize the kernel
* *
* @param masses mass of each atom * @param masses mass of each particle
* *
*/ */
void initialize( const std::vector<double>& masses ); void initialize( const std::vector<double>& masses );
...@@ -73,7 +73,7 @@ class BrookRemoveCMMotionKernel : public RemoveCMMotionKernel { ...@@ -73,7 +73,7 @@ class BrookRemoveCMMotionKernel : public RemoveCMMotionKernel {
/** /**
* Execute the kernel. * 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( ){ ...@@ -55,14 +55,14 @@ BrookShakeAlgorithm::BrookShakeAlgorithm( ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
_numberOfAtoms = -1; _numberOfParticles = -1;
_numberOfConstraints = -1; _numberOfConstraints = -1;
// mark stream dimension variables as unset // mark stream dimension variables as unset
_shakeAtomStreamWidth = -1; _shakeParticleStreamWidth = -1;
_shakeAtomStreamHeight = -1; _shakeParticleStreamHeight = -1;
_shakeAtomStreamSize = -1; _shakeParticleStreamSize = -1;
_shakeConstraintStreamSize = -1; _shakeConstraintStreamSize = -1;
_shakeConstraintStreamWidth = -1; _shakeConstraintStreamWidth = -1;
...@@ -124,35 +124,35 @@ BrookOpenMMFloat BrookShakeAlgorithm::getInverseHydrogenMass( void ) const { ...@@ -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 { int BrookShakeAlgorithm::getShakeParticleStreamSize( void ) const {
return _shakeAtomStreamSize; return _shakeParticleStreamSize;
} }
/** /**
* Get atom stream width * Get particle stream width
* *
* @return atom stream width * @return particle stream width
* *
*/ */
int BrookShakeAlgorithm::getShakeAtomStreamWidth( void ) const { int BrookShakeAlgorithm::getShakeParticleStreamWidth( void ) const {
return _shakeAtomStreamWidth; return _shakeParticleStreamWidth;
} }
/** /**
* Get atom stream height * Get particle stream height
* *
* @return atom stream height * @return particle stream height
*/ */
int BrookShakeAlgorithm::getShakeAtomStreamHeight( void ) const { int BrookShakeAlgorithm::getShakeParticleStreamHeight( void ) const {
return _shakeAtomStreamHeight; return _shakeParticleStreamHeight;
} }
/** /**
...@@ -188,25 +188,25 @@ int BrookShakeAlgorithm::getShakeConstraintStreamHeight( void ) const { ...@@ -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 { BrookFloatStreamInternal* BrookShakeAlgorithm::getShakeParticleIndicesStream( void ) const {
return _shakeStreams[ShakeAtomIndicesStream]; 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 { BrookFloatStreamInternal* BrookShakeAlgorithm::getShakeParticleParameterStream( void ) const {
return _shakeStreams[ShakeAtomParameterStream]; return _shakeStreams[ShakeParticleParameterStream];
} }
/** /**
...@@ -267,7 +267,7 @@ BrookFloatStreamInternal* BrookShakeAlgorithm::getShakeInverseMapStream( void ) ...@@ -267,7 +267,7 @@ BrookFloatStreamInternal* BrookShakeAlgorithm::getShakeInverseMapStream( void )
/** /**
* Initialize stream dimensions * Initialize stream dimensions
* *
* @param numberOfAtoms number of atoms * @param numberOfParticles number of particles
* @param numberOfConstraints number of constraints * @param numberOfConstraints number of constraints
* @param platform platform * @param platform platform
* *
...@@ -275,7 +275,7 @@ BrookFloatStreamInternal* BrookShakeAlgorithm::getShakeInverseMapStream( void ) ...@@ -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 ){ const Platform& platform ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -284,9 +284,9 @@ int BrookShakeAlgorithm::_initializeStreamSizes( int numberOfAtoms, int numberOf ...@@ -284,9 +284,9 @@ int BrookShakeAlgorithm::_initializeStreamSizes( int numberOfAtoms, int numberOf
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
_shakeAtomStreamSize = getAtomStreamSize( platform ); _shakeParticleStreamSize = getParticleStreamSize( platform );
_shakeAtomStreamWidth = getAtomStreamWidth( platform ); _shakeParticleStreamWidth = getParticleStreamWidth( platform );
_shakeAtomStreamHeight = getAtomStreamHeight( platform ); _shakeParticleStreamHeight = getParticleStreamHeight( platform );
// get constraint stream width & height, and then set stream size to the product // get constraint stream width & height, and then set stream size to the product
...@@ -315,17 +315,19 @@ int BrookShakeAlgorithm::_initializeStreams( const Platform& platform ){ ...@@ -315,17 +315,19 @@ int BrookShakeAlgorithm::_initializeStreams( const Platform& platform ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
int shakeAtomStreamSize = getShakeAtomStreamSize(); int shakeParticleStreamSize = getShakeParticleStreamSize();
int shakeAtomStreamWidth = getShakeAtomStreamWidth(); int shakeParticleStreamWidth = getShakeParticleStreamWidth();
int shakeConstraintStreamSize = getShakeConstraintStreamSize(); int shakeConstraintStreamSize = getShakeConstraintStreamSize();
int shakeConstraintStreamWidth = getShakeConstraintStreamWidth(); int shakeConstraintStreamWidth = getShakeConstraintStreamWidth();
_shakeStreams[ShakeAtomIndicesStream] = new BrookFloatStreamInternal( BrookCommon::ShakeAtomIndicesStream, _shakeStreams[ShakeParticleIndicesStream]
= new BrookFloatStreamInternal( BrookCommon::ShakeParticleIndicesStream,
shakeConstraintStreamSize, shakeConstraintStreamWidth, shakeConstraintStreamSize, shakeConstraintStreamWidth,
BrookStreamInternal::Float4, dangleValue ); BrookStreamInternal::Float4, dangleValue );
_shakeStreams[ShakeAtomParameterStream] = new BrookFloatStreamInternal( BrookCommon::ShakeAtomParameterStream, _shakeStreams[ShakeParticleParameterStream]
= new BrookFloatStreamInternal( BrookCommon::ShakeParticleParameterStream,
shakeConstraintStreamSize, shakeConstraintStreamWidth, shakeConstraintStreamSize, shakeConstraintStreamWidth,
BrookStreamInternal::Float4, dangleValue ); BrookStreamInternal::Float4, dangleValue );
...@@ -346,7 +348,7 @@ int BrookShakeAlgorithm::_initializeStreams( const Platform& platform ){ ...@@ -346,7 +348,7 @@ int BrookShakeAlgorithm::_initializeStreams( const Platform& platform ){
BrookStreamInternal::Float3, dangleValue ); BrookStreamInternal::Float3, dangleValue );
_shakeStreams[ShakeInverseMapStream] = new BrookFloatStreamInternal( BrookCommon::ShakeInverseMapStream, _shakeStreams[ShakeInverseMapStream] = new BrookFloatStreamInternal( BrookCommon::ShakeInverseMapStream,
shakeAtomStreamSize, shakeAtomStreamWidth, shakeParticleStreamSize, shakeParticleStreamWidth,
BrookStreamInternal::Float2, dangleValue ); BrookStreamInternal::Float2, dangleValue );
return DefaultReturnValue; return DefaultReturnValue;
...@@ -356,7 +358,7 @@ int BrookShakeAlgorithm::_initializeStreams( const Platform& platform ){ ...@@ -356,7 +358,7 @@ int BrookShakeAlgorithm::_initializeStreams( const Platform& platform ){
* Set Shake streams * Set Shake streams
* *
* @param masses masses * @param masses masses
* @param constraintIndices constraint atom indices * @param constraintIndices constraint particle indices
* @param constraintLengths constraint lengths * @param constraintLengths constraint lengths
* *
* @return ErrorReturnValue if error * @return ErrorReturnValue if error
...@@ -377,7 +379,7 @@ int BrookShakeAlgorithm::_setShakeStreams( const std::vector<double>& masses, co ...@@ -377,7 +379,7 @@ int BrookShakeAlgorithm::_setShakeStreams( const std::vector<double>& masses, co
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
int shakeAtomStreamSize = getShakeAtomStreamSize(); int shakeParticleStreamSize = getShakeParticleStreamSize();
int shakeConstraintStreamSize = getShakeConstraintStreamSize(); int shakeConstraintStreamSize = getShakeConstraintStreamSize();
// check that number of constraints for two input vectors is consistent // check that number of constraints for two input vectors is consistent
...@@ -391,89 +393,89 @@ int BrookShakeAlgorithm::_setShakeStreams( const std::vector<double>& masses, co ...@@ -391,89 +393,89 @@ int BrookShakeAlgorithm::_setShakeStreams( const std::vector<double>& masses, co
// allocate arrays to be read down to board // 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]; BrookOpenMMFloat* shakeParameters = new BrookOpenMMFloat[4*shakeConstraintStreamSize];
for( int ii = 0; ii < 4*shakeConstraintStreamSize; ii++ ){ for( int ii = 0; ii < 4*shakeConstraintStreamSize; ii++ ){
atomIndices[ii] = (BrookOpenMMFloat) -1; particleIndices[ii] = (BrookOpenMMFloat) -1;
} }
memset( shakeParameters, 0, 4*shakeConstraintStreamSize*sizeof( BrookOpenMMFloat ) ); memset( shakeParameters, 0, 4*shakeConstraintStreamSize*sizeof( BrookOpenMMFloat ) );
std::vector< std::vector<int> >::const_iterator atomIterator = constraintIndices.begin(); std::vector< std::vector<int> >::const_iterator particleIterator = constraintIndices.begin();
std::vector<double>::const_iterator distanceIterator = constraintLengths.begin(); std::vector<double>::const_iterator distanceIterator = constraintLengths.begin();
int constraintIndex = 0; int constraintIndex = 0;
_numberOfConstraints = 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 // check that array of indices is not too small or large
if( atomVector.size() < 2 ){ if( particleVector.size() < 2 ){
std::stringstream message; 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() ); throw OpenMMException( message.str() );
return ErrorReturnValue; return ErrorReturnValue;
} }
if( atomVector.size() > 4 ){ if( particleVector.size() > 4 ){
std::stringstream message; 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() ); throw OpenMMException( message.str() );
return ErrorReturnValue; return ErrorReturnValue;
} }
int index = 0; int index = 0;
int atomIndex1 = -1; int particleIndex1 = -1;
int atomIndex2 = -1; int particleIndex2 = -1;
for( std::vector<int>::const_iterator ii = atomVector.begin(); ii != atomVector.end(); ii++, index++ ){ for( std::vector<int>::const_iterator ii = particleVector.begin(); ii != particleVector.end(); ii++, index++ ){
atomIndices[constraintIndex + index] = (BrookOpenMMFloat) *ii; particleIndices[constraintIndex + index] = (BrookOpenMMFloat) *ii;
if( index == 0 ){ if( index == 0 ){
atomIndex1 = *ii; particleIndex1 = *ii;
} else if( index == 1 ){ } else if( index == 1 ){
atomIndex2 = *ii; particleIndex2 = *ii;
} }
} }
// skip negative indices // skip negative indices
if( atomIndex1 < 0 || atomIndex2 < 0 ){ if( particleIndex1 < 0 || particleIndex2 < 0 ){
atomIterator++; particleIterator++;
distanceIterator++; distanceIterator++;
continue; continue;
} }
if( atomIndex1 >= (int) masses.size() || atomIndex2 >= (int) masses.size() ){ if( particleIndex1 >= (int) masses.size() || particleIndex2 >= (int) masses.size() ){
std::stringstream message; 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() ); throw OpenMMException( message.str() );
return ErrorReturnValue; 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]; BrookOpenMMFloat swap = particleIndices[constraintIndex];
atomIndices[constraintIndex] = atomIndices[constraintIndex+1]; particleIndices[constraintIndex] = particleIndices[constraintIndex+1];
atomIndices[constraintIndex+1] = swap; particleIndices[constraintIndex+1] = swap;
int swapI = atomIndex1; int swapI = particleIndex1;
atomIndex1 = atomIndex2; particleIndex1 = particleIndex2;
atomIndex2 = swapI; particleIndex2 = swapI;
} }
// set parameters: // set parameters:
// (1) 1/(heavy atom mass) // (1) 1/(heavy particle mass)
// (2) 0.5/(heavy atom mass+hydrogen mass) // (2) 0.5/(heavy particle mass+hydrogen mass)
// (3) constraint distance**2 // (3) constraint distance**2
shakeParameters[constraintIndex] = one/( (BrookOpenMMFloat) masses[atomIndex1] ); shakeParameters[constraintIndex] = one/( (BrookOpenMMFloat) masses[particleIndex1] );
shakeParameters[constraintIndex+1] = half/( (BrookOpenMMFloat) (masses[atomIndex1] + masses[atomIndex2]) ); shakeParameters[constraintIndex+1] = half/( (BrookOpenMMFloat) (masses[particleIndex1] + masses[particleIndex2]) );
shakeParameters[constraintIndex+2] = (BrookOpenMMFloat) ( (*distanceIterator)*(*distanceIterator) ); shakeParameters[constraintIndex+2] = (BrookOpenMMFloat) ( (*distanceIterator)*(*distanceIterator) );
atomIterator++; particleIterator++;
distanceIterator++; distanceIterator++;
constraintIndex += 4; constraintIndex += 4;
_numberOfConstraints++; _numberOfConstraints++;
...@@ -481,15 +483,15 @@ int BrookShakeAlgorithm::_setShakeStreams( const std::vector<double>& masses, co ...@@ -481,15 +483,15 @@ int BrookShakeAlgorithm::_setShakeStreams( const std::vector<double>& masses, co
// write entries to board // write entries to board
_shakeStreams[ShakeAtomIndicesStream]->loadFromArray( atomIndices ); _shakeStreams[ShakeParticleIndicesStream]->loadFromArray( particleIndices );
_shakeStreams[ShakeAtomParameterStream]->loadFromArray( shakeParameters ); _shakeStreams[ShakeParticleParameterStream]->loadFromArray( shakeParameters );
delete[] shakeParameters; delete[] shakeParameters;
// initialize inverse map // initialize inverse map
BrookOpenMMFloat* inverseMap = new BrookOpenMMFloat[2*shakeAtomStreamSize]; BrookOpenMMFloat* inverseMap = new BrookOpenMMFloat[2*shakeParticleStreamSize];
for( int ii = 0; ii < shakeAtomStreamSize*2; ii++ ){ for( int ii = 0; ii < shakeParticleStreamSize*2; ii++ ){
inverseMap[ii] = -1; inverseMap[ii] = -1;
} }
...@@ -498,17 +500,17 @@ int BrookShakeAlgorithm::_setShakeStreams( const std::vector<double>& masses, co ...@@ -498,17 +500,17 @@ int BrookShakeAlgorithm::_setShakeStreams( const std::vector<double>& masses, co
for( int ii = 0; ii < shakeConstraintStreamSize; ii++ ){ for( int ii = 0; ii < shakeConstraintStreamSize; ii++ ){
int ii4 = ii << 2; int ii4 = ii << 2;
for( int jj = 0; jj < 4; jj++ ){ for( int jj = 0; jj < 4; jj++ ){
if( atomIndices[ii4+jj] != -1 ){ if( particleIndices[ii4+jj] != -1 ){
int atomIndex = (int) (atomIndices[ii4+jj] + 0.001); int particleIndex = (int) (particleIndices[ii4+jj] + 0.001);
inverseMap[atomIndex*2] = (float) ii; inverseMap[particleIndex*2] = (float) ii;
inverseMap[atomIndex*2+1] = (float) jj; inverseMap[particleIndex*2+1] = (float) jj;
} }
} }
} }
_shakeStreams[ShakeInverseMapStream]->loadFromArray( inverseMap ); _shakeStreams[ShakeInverseMapStream]->loadFromArray( inverseMap );
delete[] atomIndices; delete[] particleIndices;
delete[] inverseMap; delete[] inverseMap;
return DefaultReturnValue; return DefaultReturnValue;
...@@ -519,7 +521,7 @@ int BrookShakeAlgorithm::_setShakeStreams( const std::vector<double>& masses, co ...@@ -519,7 +521,7 @@ int BrookShakeAlgorithm::_setShakeStreams( const std::vector<double>& masses, co
* Setup of Shake parameters * Setup of Shake parameters
* *
* @param masses masses * @param masses masses
* @param constraintIndices constraint atom indices * @param constraintIndices constraint particle indices
* @param constraintLengths constraint lengths * @param constraintLengths constraint lengths
* @param platform Brook platform * @param platform Brook platform
* *
...@@ -536,12 +538,12 @@ int BrookShakeAlgorithm::setup( const std::vector<double>& masses, const std::ve ...@@ -536,12 +538,12 @@ int BrookShakeAlgorithm::setup( const std::vector<double>& masses, const std::ve
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
int numberOfAtoms = (int) masses.size(); int numberOfParticles = (int) masses.size();
setNumberOfAtoms( numberOfAtoms ); setNumberOfParticles( numberOfParticles );
// set stream sizes and then create streams // set stream sizes and then create streams
_initializeStreamSizes( numberOfAtoms, (int) constraintIndices.size(), platform ); _initializeStreamSizes( numberOfParticles, (int) constraintIndices.size(), platform );
_initializeStreams( platform ); _initializeStreams( platform );
_setShakeStreams( masses, constraintIndices, constraintLengths ); _setShakeStreams( masses, constraintIndices, constraintLengths );
...@@ -580,17 +582,17 @@ std::string BrookShakeAlgorithm::getContentsString( int level ) const { ...@@ -580,17 +582,17 @@ std::string BrookShakeAlgorithm::getContentsString( int level ) const {
#define LOCAL_SPRINTF(a,b,c) sprintf( (a), (b), (c) ); #define LOCAL_SPRINTF(a,b,c) sprintf( (a), (b), (c) );
#endif #endif
(void) LOCAL_SPRINTF( value, "%d", getNumberOfAtoms() ); (void) LOCAL_SPRINTF( value, "%d", getNumberOfParticles() );
message << _getLine( tab, "Number of atoms:", value ); message << _getLine( tab, "Number of particles:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamWidth() ); (void) LOCAL_SPRINTF( value, "%d", getParticleStreamWidth() );
message << _getLine( tab, "Atom stream width:", value ); message << _getLine( tab, "Particle stream width:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamHeight() ); (void) LOCAL_SPRINTF( value, "%d", getParticleStreamHeight() );
message << _getLine( tab, "Atom stream height:", value ); message << _getLine( tab, "Particle stream height:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamSize() ); (void) LOCAL_SPRINTF( value, "%d", getParticleStreamSize() );
message << _getLine( tab, "Atom stream size:", value ); message << _getLine( tab, "Particle stream size:", value );
(void) LOCAL_SPRINTF( value, "%d", getNumberOfConstraints() ); (void) LOCAL_SPRINTF( value, "%d", getNumberOfConstraints() );
message << _getLine( tab, "Number of constraints:", value ); message << _getLine( tab, "Number of constraints:", value );
...@@ -609,8 +611,8 @@ std::string BrookShakeAlgorithm::getContentsString( int level ) const { ...@@ -609,8 +611,8 @@ std::string BrookShakeAlgorithm::getContentsString( int level ) const {
message << _getLine( tab, "Log:", (getLog() ? Set : NotSet) ); message << _getLine( tab, "Log:", (getLog() ? Set : NotSet) );
message << _getLine( tab, "AtomIndices:", (getShakeAtomIndicesStream() ? Set : NotSet) ); message << _getLine( tab, "ParticleIndices:", (getShakeParticleIndicesStream() ? Set : NotSet) );
message << _getLine( tab, "AtomParameters:", (getShakeAtomParameterStream() ? Set : NotSet) ); message << _getLine( tab, "ParticleParameters:", (getShakeParticleParameterStream() ? Set : NotSet) );
message << _getLine( tab, "XCons0:", (getShakeXCons0Stream() ? Set : NotSet) ); message << _getLine( tab, "XCons0:", (getShakeXCons0Stream() ? Set : NotSet) );
message << _getLine( tab, "XCons1:", (getShakeXCons1Stream() ? Set : NotSet) ); message << _getLine( tab, "XCons1:", (getShakeXCons1Stream() ? Set : NotSet) );
message << _getLine( tab, "XCons2:", (getShakeXCons2Stream() ? Set : NotSet) ); message << _getLine( tab, "XCons2:", (getShakeXCons2Stream() ? Set : NotSet) );
......
platforms/brook/src/BrookShakeAlgorithm.h
View file @ 309008f7
#ifndef OPENMM_BROOK_SHAKE_H_ #ifndef OPENMM_BROOK_SHAKE_ALGORITHM_H_
#define OPENMM_BROOK_SHAKE_H_ #define OPENMM_BROOK_SHAKE_ALGORITHM_H_
/* -------------------------------------------------------------------------- * /* -------------------------------------------------------------------------- *
* OpenMM * * OpenMM *
...@@ -83,28 +83,28 @@ class BrookShakeAlgorithm : public BrookCommon { ...@@ -83,28 +83,28 @@ class BrookShakeAlgorithm : public BrookCommon {
BrookOpenMMFloat getInverseHydrogenMass( void ) const; 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 * Get Shake constraint stream width
...@@ -143,7 +143,7 @@ class BrookShakeAlgorithm : public BrookCommon { ...@@ -143,7 +143,7 @@ class BrookShakeAlgorithm : public BrookCommon {
* Setup of Shake parameters * Setup of Shake parameters
* *
* @param masses masses * @param masses masses
* @param constraintIndices constraint atom indices * @param constraintIndices constraint particle indices
* @param constraintLengths constraint lengths * @param constraintLengths constraint lengths
* @param platform Brook platform * @param platform Brook platform
* *
...@@ -166,22 +166,22 @@ class BrookShakeAlgorithm : public BrookCommon { ...@@ -166,22 +166,22 @@ class BrookShakeAlgorithm : public BrookCommon {
std::string getContentsString( int level = 0 ) const; 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 * Get XCons0 stream
...@@ -233,8 +233,8 @@ class BrookShakeAlgorithm : public BrookCommon { ...@@ -233,8 +233,8 @@ class BrookShakeAlgorithm : public BrookCommon {
// streams indices // streams indices
enum BrookShakeAlgorithmStreams { enum BrookShakeAlgorithmStreams {
ShakeAtomIndicesStream, ShakeParticleIndicesStream,
ShakeAtomParameterStream, ShakeParticleParameterStream,
ShakeXCons0Stream, ShakeXCons0Stream,
ShakeXCons1Stream, ShakeXCons1Stream,
ShakeXCons2Stream, ShakeXCons2Stream,
...@@ -251,11 +251,11 @@ class BrookShakeAlgorithm : public BrookCommon { ...@@ -251,11 +251,11 @@ class BrookShakeAlgorithm : public BrookCommon {
BrookOpenMMFloat _inverseHydrogenMass; BrookOpenMMFloat _inverseHydrogenMass;
// atom stream dimensions // particle stream dimensions
int _shakeAtomStreamWidth; int _shakeParticleStreamWidth;
int _shakeAtomStreamHeight; int _shakeParticleStreamHeight;
int _shakeAtomStreamSize; int _shakeParticleStreamSize;
// constraint stream dimensions // constraint stream dimensions
...@@ -274,19 +274,19 @@ class BrookShakeAlgorithm : public BrookCommon { ...@@ -274,19 +274,19 @@ class BrookShakeAlgorithm : public BrookCommon {
/* /*
* Setup of stream dimensions * Setup of stream dimensions
* *
* @param atomStreamSize atom stream size * @param particleStreamSize particle stream size
* @param atomStreamWidth atom stream width * @param particleStreamWidth particle stream width
* *
* @return ErrorReturnValue if error, else DefaultReturnValueValue * @return ErrorReturnValue if error, else DefaultReturnValueValue
* *
* */ * */
int _initializeStreamSizes( int atomStreamSize, int atomStreamWidth ); int _initializeStreamSizes( int particleStreamSize, int particleStreamWidth );
/** /**
* Initialize stream dimensions * Initialize stream dimensions
* *
* @param numberOfAtoms number of atoms * @param numberOfParticles number of particles
* @param numberOfConstraints number of constraints * @param numberOfConstraints number of constraints
* @param platform platform * @param platform platform
* *
...@@ -294,7 +294,7 @@ class BrookShakeAlgorithm : public BrookCommon { ...@@ -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 * Initialize stream dimensions and streams
...@@ -311,7 +311,7 @@ class BrookShakeAlgorithm : public BrookCommon { ...@@ -311,7 +311,7 @@ class BrookShakeAlgorithm : public BrookCommon {
* Set Shake streams * Set Shake streams
* *
* @param masses masses * @param masses masses
* @param constraintIndices constraint atom indices * @param constraintIndices constraint particle indices
* @param constraintLengths constraint lengths * @param constraintLengths constraint lengths
* *
* @return ErrorReturnValue if error * @return ErrorReturnValue if error
...@@ -327,4 +327,4 @@ class BrookShakeAlgorithm : public BrookCommon { ...@@ -327,4 +327,4 @@ class BrookShakeAlgorithm : public BrookCommon {
} // namespace OpenMM } // 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 @@ ...@@ -33,14 +33,17 @@
#include "OpenMMException.h" #include "OpenMMException.h"
#include "BrookStreamFactory.h" #include "BrookStreamFactory.h"
#include "BrookStreamImpl.h" #include "BrookStreamImpl.h"
#include "internal/OpenMMContextImpl.h"
#include "OpenMMBrookInterface.h"
using namespace OpenMM; using namespace OpenMM;
const std::string BrookStreamFactory::AtomPositions = "atomPositions"; const std::string BrookStreamFactory::ParticlePositions = "particlePositions";
const std::string BrookStreamFactory::AtomVelocities = "atomVelocities"; const std::string BrookStreamFactory::ParticleVelocities = "particleVelocities";
const std::string BrookStreamFactory::AtomForces = "atomForces"; const std::string BrookStreamFactory::ParticleForces = "particleForces";
const double DefaultDangleValue = 1.0e+08;
const double DefaultDangleValue = 1.0e+08;
/** /**
* BrookStreamFactory constructor * BrookStreamFactory constructor
* *
...@@ -56,7 +59,7 @@ BrookStreamFactory::BrookStreamFactory( void ){ ...@@ -56,7 +59,7 @@ BrookStreamFactory::BrookStreamFactory( void ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
_defaultDangleValue = 1.0e+08; _defaultDangleValue = 1.0e+08;
_defaultAtomStreamWidth = DefaultStreamAtomWidth; _defaultParticleStreamWidth = DefaultStreamParticleWidth;
_defaultStreamRandomNumberWidth = DefaultStreamRandomNumberWidth; _defaultStreamRandomNumberWidth = DefaultStreamRandomNumberWidth;
_defaultStreamRandomNumberSize = DefaultStreamRandomNumberSize; _defaultStreamRandomNumberSize = DefaultStreamRandomNumberSize;
...@@ -71,52 +74,52 @@ BrookStreamFactory::~BrookStreamFactory( void ){ ...@@ -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 * @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; std::stringstream message;
message << methodName << " atomStreamWidth=" << atomStreamWidth << " is less than 1."; message << methodName << " particleStreamWidth=" << particleStreamWidth << " is less than 1.";
throw OpenMMException( message.str() ); throw OpenMMException( message.str() );
return ErrorReturnValue; return ErrorReturnValue;
} }
_defaultAtomStreamWidth = atomStreamWidth; _defaultParticleStreamWidth = particleStreamWidth;
return DefaultReturnValue; return DefaultReturnValue;
...@@ -289,10 +292,22 @@ StreamImpl* BrookStreamFactory::createStreamImpl( std::string name, int size, St ...@@ -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 { ...@@ -233,6 +233,19 @@ class BrookStreamInternal {
int printToFile( FILE* log ); 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: protected:
std::string _name; std::string _name;
......
platforms/brook/src/BrookVelocityCenterOfMassRemoval.cpp
View file @ 309008f7
...@@ -55,13 +55,13 @@ BrookVelocityCenterOfMassRemoval::BrookVelocityCenterOfMassRemoval( ){ ...@@ -55,13 +55,13 @@ BrookVelocityCenterOfMassRemoval::BrookVelocityCenterOfMassRemoval( ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
_numberOfAtoms = -1; _numberOfParticles = -1;
// mark stream dimension variables as unset // mark stream dimension variables as unset
_atomStreamWidth = -1; _particleStreamWidth = -1;
_atomStreamHeight = -1; _particleStreamHeight = -1;
_atomStreamSize = -1; _particleStreamSize = -1;
_totalInverseMass = zero; _totalInverseMass = zero;
...@@ -148,9 +148,7 @@ int BrookVelocityCenterOfMassRemoval::removeVelocityCenterOfMass( Stream& veloci ...@@ -148,9 +148,7 @@ int BrookVelocityCenterOfMassRemoval::removeVelocityCenterOfMass( Stream& veloci
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
static const char* methodName = "BrookVelocityCenterOfMassRemoval::removeVelocityCenterOfMass"; static const char* methodName = "BrookVelocityCenterOfMassRemoval::removeVelocityCenterOfMass";
static const int debug = 1;
static int debug = 0;
float zero = 0.0f;
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -158,6 +156,19 @@ int BrookVelocityCenterOfMassRemoval::removeVelocityCenterOfMass( Stream& veloci ...@@ -158,6 +156,19 @@ int BrookVelocityCenterOfMassRemoval::removeVelocityCenterOfMass( Stream& veloci
BrookOpenMMFloat com[3]; BrookOpenMMFloat com[3];
getVelocityCenterOfMass( velocities, com ); 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] ); (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 // calculate linear momentum via reduction
...@@ -166,17 +177,20 @@ int BrookVelocityCenterOfMassRemoval::removeVelocityCenterOfMass( Stream& veloci ...@@ -166,17 +177,20 @@ int BrookVelocityCenterOfMassRemoval::removeVelocityCenterOfMass( Stream& veloci
BrookStreamImpl& velocityStream = dynamic_cast<BrookStreamImpl&> (velocities.getImpl()); BrookStreamImpl& velocityStream = dynamic_cast<BrookStreamImpl&> (velocities.getImpl());
kCalculateLinearMomentum( getMassStream()->getBrookStream(), velocityStream.getBrookStream(), getWorkStream()->getBrookStream() ); 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() ); kScale( (float) getTotalInverseMass(), getLinearMomentumStream()->getBrookStream(), getLinearMomentumStream()->getBrookStream() );
kRemoveLinearMomentum( getLinearMomentumStream()->getBrookStream(), velocityStream.getBrookStream(), velocityStream.getBrookStream() ); kRemoveLinearMomentum( getLinearMomentumStream()->getBrookStream(), velocityStream.getBrookStream(), velocityStream.getBrookStream() );
if( (0 || debug) && getLog() ){ if( (0 || debug) && getLog() ){
BrookOpenMMFloat com[3]; BrookOpenMMFloat com[3];
getVelocityCenterOfMass( velocities, com ); getVelocityCenterOfMass( velocities, com );
(void) fprintf( getLog(), "\n%s strW=%d iatm=%d Post removal com: [%12.5e %12.5e %12.5e]\n", methodName, (void) fprintf( getLog(), "%s strW=%d iatm=%d Post removal com: [%12.5e %12.5e %12.5e]", methodName,
getComAtomStreamWidth(), getNumberOfAtoms(), com[0], com[1], com[2] ); getComParticleStreamWidth(), getNumberOfParticles(), com[0], com[1], com[2] );
/*
(void) fprintf( getLog(), "LM [%12.5e %12.5e %12.5e]\n", 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()); BrookStreamImpl& v1 = dynamic_cast<BrookStreamImpl&> (velocities.getImpl());
BrookStreamInternal* velocityStream = dynamic_cast<BrookStreamInternal*> (v1.getBrookStreamImpl()); BrookStreamInternal* velocityStream = dynamic_cast<BrookStreamInternal*> (v1.getBrookStreamImpl());
...@@ -187,12 +201,14 @@ int BrookVelocityCenterOfMassRemoval::removeVelocityCenterOfMass( Stream& veloci ...@@ -187,12 +201,14 @@ int BrookVelocityCenterOfMassRemoval::removeVelocityCenterOfMass( Stream& veloci
const float* w2 = (float*) w1; const float* w2 = (float*) w1;
int index = 0; 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, (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] ); vArray[index], vArray[index+1], vArray[index+2], w2[index], w2[index+1], w2[index+2] );
} }
(void) fflush( getLog() ); (void) fflush( getLog() );
*/
//exit(0); //exit(0);
} }
...@@ -232,12 +248,12 @@ int BrookVelocityCenterOfMassRemoval::getVelocityCenterOfMass( Stream& velocitie ...@@ -232,12 +248,12 @@ int BrookVelocityCenterOfMassRemoval::getVelocityCenterOfMass( Stream& velocitie
void* massV = getMassStream()->getData( 1); void* massV = getMassStream()->getData( 1);
const float* mArray = (float*) massV; const float* mArray = (float*) massV;
int numberOfAtoms = getNumberOfAtoms(); int numberOfParticles = getNumberOfParticles();
int index = 0; int index = 0;
velocityCom[0] = velocityCom[1] = velocityCom[2] = zero; 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[0] += mArray[ii]*vArray[index];
velocityCom[1] += mArray[ii]*vArray[index+1]; velocityCom[1] += mArray[ii]*vArray[index+1];
velocityCom[2] += mArray[ii]*vArray[index+2]; velocityCom[2] += mArray[ii]*vArray[index+2];
...@@ -247,48 +263,48 @@ int BrookVelocityCenterOfMassRemoval::getVelocityCenterOfMass( Stream& velocitie ...@@ -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 { int BrookVelocityCenterOfMassRemoval::getComParticleStreamSize( void ) const {
return _atomStreamSize; return _particleStreamSize;
} }
/** /**
* Get atom stream width * Get particle stream width
* *
* @return atom stream width * @return particle stream width
* *
*/ */
int BrookVelocityCenterOfMassRemoval::getComAtomStreamWidth( void ) const { int BrookVelocityCenterOfMassRemoval::getComParticleStreamWidth( void ) const {
return _atomStreamWidth; return _particleStreamWidth;
} }
/** /**
* Get atom stream height * Get particle stream height
* *
* @return atom stream height * @return particle stream height
*/ */
int BrookVelocityCenterOfMassRemoval::getComAtomStreamHeight( void ) const { int BrookVelocityCenterOfMassRemoval::getComParticleStreamHeight( void ) const {
return _atomStreamHeight; return _particleStreamHeight;
} }
/** /**
* Initialize stream dimensions * Initialize stream dimensions
* *
* @param numberOfAtoms number of atoms * @param numberOfParticles number of particles
* @param platform platform * @param platform platform
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @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, ...@@ -296,9 +312,9 @@ int BrookVelocityCenterOfMassRemoval::_initializeStreamSizes( int numberOfAtoms,
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
_atomStreamSize = getAtomStreamSize( platform ); _particleStreamSize = getParticleStreamSize( platform );
_atomStreamWidth = getAtomStreamWidth( platform ); _particleStreamWidth = getParticleStreamWidth( platform );
_atomStreamHeight = getAtomStreamHeight( platform ); _particleStreamHeight = getParticleStreamHeight( platform );
return DefaultReturnValue; return DefaultReturnValue;
} }
...@@ -322,16 +338,16 @@ int BrookVelocityCenterOfMassRemoval::_initializeStreams( const Platform& platfo ...@@ -322,16 +338,16 @@ int BrookVelocityCenterOfMassRemoval::_initializeStreams( const Platform& platfo
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
int atomStreamSize = getComAtomStreamSize(); int particleStreamSize = getComParticleStreamSize();
int atomStreamWidth = getComAtomStreamWidth(); int particleStreamWidth = getComParticleStreamWidth();
_streams[WorkStream] = new BrookFloatStreamInternal( BrookCommon::BrookVelocityCenterOfMassRemovalWorkStream, _streams[WorkStream] = new BrookFloatStreamInternal( BrookCommon::BrookVelocityCenterOfMassRemovalWorkStream,
atomStreamSize, atomStreamWidth, particleStreamSize, particleStreamWidth,
BrookStreamInternal::Float3, dangleValue ); BrookStreamInternal::Float3, dangleValue );
_streams[MassStream] = new BrookFloatStreamInternal( BrookCommon::BrookVelocityCenterOfMassRemovalMassStream, _streams[MassStream] = new BrookFloatStreamInternal( BrookCommon::BrookVelocityCenterOfMassRemovalMassStream,
atomStreamSize, atomStreamWidth, particleStreamSize, particleStreamWidth,
BrookStreamInternal::Float, dangleValue ); BrookStreamInternal::Float, dangleValue );
...@@ -345,7 +361,7 @@ int BrookVelocityCenterOfMassRemoval::_initializeStreams( const Platform& platfo ...@@ -345,7 +361,7 @@ int BrookVelocityCenterOfMassRemoval::_initializeStreams( const Platform& platfo
/** /**
* Set masses & _totalInverseMass * Set masses & _totalInverseMass
* *
* @param masses atomic masses * @param masses particle masses
* *
*/ */
...@@ -362,16 +378,16 @@ int BrookVelocityCenterOfMassRemoval::_setMasses( const std::vector<double>& mas ...@@ -362,16 +378,16 @@ int BrookVelocityCenterOfMassRemoval::_setMasses( const std::vector<double>& mas
// check that masses vector is not larger than expected // check that masses vector is not larger than expected
if( (int) masses.size() > getComAtomStreamSize() ){ if( (int) masses.size() > getComParticleStreamSize() ){
std::stringstream message; 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() ); throw OpenMMException( message.str() );
} }
// setup masses // setup masses
BrookOpenMMFloat* localMasses = new BrookOpenMMFloat[getComAtomStreamSize()]; BrookOpenMMFloat* localMasses = new BrookOpenMMFloat[getComParticleStreamSize()];
memset( localMasses, 0, sizeof( BrookOpenMMFloat )*getComAtomStreamSize() ); memset( localMasses, 0, sizeof( BrookOpenMMFloat )*getComParticleStreamSize() );
int index = 0; int index = 0;
_totalInverseMass = (BrookOpenMMFloat) 0.0; _totalInverseMass = (BrookOpenMMFloat) 0.0;
...@@ -419,12 +435,12 @@ int BrookVelocityCenterOfMassRemoval::setup( const std::vector<double>& masses, ...@@ -419,12 +435,12 @@ int BrookVelocityCenterOfMassRemoval::setup( const std::vector<double>& masses,
const BrookPlatform brookPlatform = dynamic_cast<const BrookPlatform&> (platform); const BrookPlatform brookPlatform = dynamic_cast<const BrookPlatform&> (platform);
setLog( brookPlatform.getLog() ); setLog( brookPlatform.getLog() );
int numberOfAtoms = (int) masses.size(); int numberOfParticles = (int) masses.size();
setNumberOfAtoms( numberOfAtoms ); setNumberOfParticles( numberOfParticles );
// set stream sizes and then create streams // set stream sizes and then create streams
_initializeStreamSizes( numberOfAtoms, platform ); _initializeStreamSizes( numberOfParticles, platform );
_initializeStreams( platform ); _initializeStreams( platform );
_setMasses( masses ); _setMasses( masses );
...@@ -463,17 +479,17 @@ std::string BrookVelocityCenterOfMassRemoval::getContentsString( int level ) con ...@@ -463,17 +479,17 @@ std::string BrookVelocityCenterOfMassRemoval::getContentsString( int level ) con
#define LOCAL_SPRINTF(a,b,c) sprintf( (a), (b), (c) ); #define LOCAL_SPRINTF(a,b,c) sprintf( (a), (b), (c) );
#endif #endif
(void) LOCAL_SPRINTF( value, "%d", getNumberOfAtoms() ); (void) LOCAL_SPRINTF( value, "%d", getNumberOfParticles() );
message << _getLine( tab, "Number of atoms:", value ); message << _getLine( tab, "Number of particles:", value );
(void) LOCAL_SPRINTF( value, "%d", getComAtomStreamWidth() ); (void) LOCAL_SPRINTF( value, "%d", getComParticleStreamWidth() );
message << _getLine( tab, "Atom stream width:", value ); message << _getLine( tab, "Particle stream width:", value );
(void) LOCAL_SPRINTF( value, "%d", getComAtomStreamHeight() ); (void) LOCAL_SPRINTF( value, "%d", getComParticleStreamHeight() );
message << _getLine( tab, "Atom stream height:", value ); message << _getLine( tab, "Particle stream height:", value );
(void) LOCAL_SPRINTF( value, "%d", getComAtomStreamSize() ); (void) LOCAL_SPRINTF( value, "%d", getComParticleStreamSize() );
message << _getLine( tab, "Atom stream size:", value ); message << _getLine( tab, "Particle stream size:", value );
(void) LOCAL_SPRINTF( value, "%.5f", getTotalInverseMass() ); (void) LOCAL_SPRINTF( value, "%.5f", getTotalInverseMass() );
message << _getLine( tab, "TotalInverseMass:", value ); message << _getLine( tab, "TotalInverseMass:", value );
......
platforms/brook/src/BrookVelocityCenterOfMassRemoval.h
View file @ 309008f7
...@@ -66,33 +66,33 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon { ...@@ -66,33 +66,33 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon {
~BrookVelocityCenterOfMassRemoval( ); ~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 * Remove velocity center-of-mass
* *
* @param velocities atom velocities * @param velocities particle velocities
* *
* @return DefaultReturnValue * @return DefaultReturnValue
* *
...@@ -103,7 +103,7 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon { ...@@ -103,7 +103,7 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon {
/** /**
* Get velocity center-of-mass * Get velocity center-of-mass
* *
* @param velocities atom velocities * @param velocities particle velocities
* @param velocityCom output velocity com * @param velocityCom output velocity com
* *
* @return DefaultReturnValue * @return DefaultReturnValue
...@@ -115,7 +115,7 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon { ...@@ -115,7 +115,7 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon {
/* /*
* Setup of parameters * Setup of parameters
* *
* @param masses atom masses * @param masses particle masses
* @param platform Brook platform * @param platform Brook platform
* *
* @return ErrorReturnValue value if error, else DefaultReturnValue * @return ErrorReturnValue value if error, else DefaultReturnValue
...@@ -184,11 +184,11 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon { ...@@ -184,11 +184,11 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon {
BrookOpenMMFloat _totalInverseMass; BrookOpenMMFloat _totalInverseMass;
// Atom stream dimensions // Particle stream dimensions
int _atomStreamWidth; int _particleStreamWidth;
int _atomStreamHeight; int _particleStreamHeight;
int _atomStreamSize; int _particleStreamSize;
// internal streams // internal streams
...@@ -197,26 +197,26 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon { ...@@ -197,26 +197,26 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon {
/* /*
* Setup of stream dimensions * Setup of stream dimensions
* *
* @param atomStreamSize atom stream size * @param particleStreamSize particle stream size
* @param atomStreamWidth atom stream width * @param particleStreamWidth particle stream width
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @return ErrorReturnValue if error, else DefaultReturnValue
* *
* */ * */
int _initializeStreamSizes( int atomStreamSize, int atomStreamWidth ); int _initializeStreamSizes( int particleStreamSize, int particleStreamWidth );
/** /**
* Initialize stream dimensions * Initialize stream dimensions
* *
* @param numberOfAtoms number of atoms * @param numberOfParticles number of particles
* @param platform platform * @param platform platform
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @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 * Initialize stream dimensions and streams
...@@ -232,7 +232,7 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon { ...@@ -232,7 +232,7 @@ class BrookVelocityCenterOfMassRemoval : public BrookCommon {
/** /**
* Set inverse masses * 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( ){ ...@@ -63,19 +63,19 @@ BrookVerletDynamics::BrookVerletDynamics( ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
_numberOfAtoms = -1; _numberOfParticles = -1;
// mark stream dimension variables as unset // mark stream dimension variables as unset
_verletAtomStreamWidth = -1; _verletParticleStreamWidth = -1;
_verletAtomStreamHeight = -1; _verletParticleStreamHeight = -1;
_verletAtomStreamSize = -1; _verletParticleStreamSize = -1;
for( int ii = 0; ii < LastStreamIndex; ii++ ){ for( int ii = 0; ii < LastStreamIndex; ii++ ){
_verletStreams[ii] = NULL; _verletStreams[ii] = NULL;
} }
_stepSize = oneMinus; _stepSize = oneMinus;
// setup inverse sqrt masses // setup inverse sqrt masses
...@@ -167,9 +167,9 @@ int BrookVerletDynamics::updateParameters( double stepSize ){ ...@@ -167,9 +167,9 @@ int BrookVerletDynamics::updateParameters( double stepSize ){
/** /**
* Update * Update
* *
* @param positions atom positions * @param positions particle positions
* @param velocities atom velocities * @param velocities particle velocities
* @param forces atom forces * @param forces particle forces
* @param brookShakeAlgorithm BrookShakeAlgorithm reference * @param brookShakeAlgorithm BrookShakeAlgorithm reference
* @param brookRandomNumberGenerator BrookRandomNumberGenerator reference * @param brookRandomNumberGenerator BrookRandomNumberGenerator reference
* *
...@@ -234,8 +234,8 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities, ...@@ -234,8 +234,8 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities,
// diagnostics // diagnostics
if( PrintOn && getLog() ){ if( PrintOn && getLog() ){
(void) fprintf( getLog(), "\nPost kupdate_md_verlet: atomStrW=%3d step=%.5f", (void) fprintf( getLog(), "\nPost kupdate_md_verlet: particleStrW=%3d step=%.5f",
getVerletDynamicsAtomStreamWidth(), getStepSize() ); getVerletDynamicsParticleStreamWidth(), getStepSize() );
(void) fprintf( getLog(), "\nInverseMassStream\n" ); (void) fprintf( getLog(), "\nInverseMassStream\n" );
getInverseMassStream()->printToFile( getLog() ); getInverseMassStream()->printToFile( getLog() );
...@@ -262,13 +262,13 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities, ...@@ -262,13 +262,13 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities,
kshakeh_fix1( kshakeh_fix1(
10.0f, 10.0f,
(float) getVerletDynamicsAtomStreamWidth(), (float) getVerletDynamicsParticleStreamWidth(),
brookShakeAlgorithm.getInverseHydrogenMass(), brookShakeAlgorithm.getInverseHydrogenMass(),
omega, omega,
brookShakeAlgorithm.getShakeAtomIndicesStream()->getBrookStream(), brookShakeAlgorithm.getShakeParticleIndicesStream()->getBrookStream(),
positionStream.getBrookStream(), positionStream.getBrookStream(),
getXPrimeStream()->getBrookStream(), getXPrimeStream()->getBrookStream(),
brookShakeAlgorithm.getShakeAtomParameterStream()->getBrookStream(), brookShakeAlgorithm.getShakeParticleParameterStream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons0Stream()->getBrookStream(), brookShakeAlgorithm.getShakeXCons0Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons1Stream()->getBrookStream(), brookShakeAlgorithm.getShakeXCons1Stream()->getBrookStream(),
brookShakeAlgorithm.getShakeXCons2Stream()->getBrookStream(), brookShakeAlgorithm.getShakeXCons2Stream()->getBrookStream(),
...@@ -276,11 +276,11 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities, ...@@ -276,11 +276,11 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities,
if( (1|| PrintOn) && getLog() ){ if( (1|| PrintOn) && getLog() ){
(void) fprintf( getLog(), "\nPost kshakeh_fix1: atomStrW=%3d invMass_H=%.5f", (void) fprintf( getLog(), "\nPost kshakeh_fix1: particleStrW=%3d invMass_H=%.5f",
getVerletDynamicsAtomStreamWidth(), brookShakeAlgorithm.getInverseHydrogenMass() ); getVerletDynamicsParticleStreamWidth(), brookShakeAlgorithm.getInverseHydrogenMass() );
(void) fprintf( getLog(), "\nShakeAtomIndicesStream\n" ); (void) fprintf( getLog(), "\nShakeParticleIndicesStream\n" );
brookShakeAlgorithm.getShakeAtomIndicesStream()->printToFile( getLog() ); brookShakeAlgorithm.getShakeParticleIndicesStream()->printToFile( getLog() );
BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl(); BrookStreamInternal* brookStreamInternalPos = positionStream.getBrookStreamImpl();
(void) fprintf( getLog(), "\nPositionStream\n" ); (void) fprintf( getLog(), "\nPositionStream\n" );
...@@ -289,8 +289,8 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities, ...@@ -289,8 +289,8 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities,
(void) fprintf( getLog(), "\nXPrimeStream\n" ); (void) fprintf( getLog(), "\nXPrimeStream\n" );
getXPrimeStream()->printToFile( getLog() ); getXPrimeStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeAtomParameterStream\n" ); (void) fprintf( getLog(), "\nShakeParticleParameterStream\n" );
brookShakeAlgorithm.getShakeAtomParameterStream()->printToFile( getLog() ); brookShakeAlgorithm.getShakeParticleParameterStream()->printToFile( getLog() );
(void) fprintf( getLog(), "\nShakeXCons0\n" ); (void) fprintf( getLog(), "\nShakeXCons0\n" );
brookShakeAlgorithm.getShakeXCons0Stream()->printToFile( getLog() ); brookShakeAlgorithm.getShakeXCons0Stream()->printToFile( getLog() );
...@@ -309,7 +309,7 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities, ...@@ -309,7 +309,7 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities,
// second Shake gather // second Shake gather
kshakeh_update2_fix1( kshakeh_update2_fix1(
(float) getVerletDynamicsAtomStreamWidth(), (float) getVerletDynamicsParticleStreamWidth(),
brookShakeAlgorithm.getShakeInverseMapStream()->getBrookStream(), brookShakeAlgorithm.getShakeInverseMapStream()->getBrookStream(),
positionStream.getBrookStream(), positionStream.getBrookStream(),
getXPrimeStream()->getBrookStream(), getXPrimeStream()->getBrookStream(),
...@@ -321,8 +321,8 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities, ...@@ -321,8 +321,8 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities,
if( ( 1 || PrintOn) && getLog() ){ if( ( 1 || PrintOn) && getLog() ){
(void) fprintf( getLog(), "\nPost kshakeh_update2_fix1: atomStrW=%3d", (void) fprintf( getLog(), "\nPost kshakeh_update2_fix1: particleStrW=%3d",
getVerletDynamicsAtomStreamWidth() ); getVerletDynamicsParticleStreamWidth() );
(void) fprintf( getLog(), "\nShakeInverseMapStream\n" ); (void) fprintf( getLog(), "\nShakeInverseMapStream\n" );
brookShakeAlgorithm.getShakeInverseMapStream()->printToFile( getLog() ); brookShakeAlgorithm.getShakeInverseMapStream()->printToFile( getLog() );
...@@ -360,35 +360,35 @@ int BrookVerletDynamics::update( Stream& positions, Stream& velocities, ...@@ -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 { int BrookVerletDynamics::getVerletDynamicsParticleStreamSize( void ) const {
return _verletAtomStreamSize; return _verletParticleStreamSize;
} }
/** /**
* Get atom stream width * Get particle stream width
* *
* @return atom stream width * @return particle stream width
* *
*/ */
int BrookVerletDynamics::getVerletDynamicsAtomStreamWidth( void ) const { int BrookVerletDynamics::getVerletDynamicsParticleStreamWidth( void ) const {
return _verletAtomStreamWidth; return _verletParticleStreamWidth;
} }
/** /**
* Get atom stream height * Get particle stream height
* *
* @return atom stream height * @return particle stream height
*/ */
int BrookVerletDynamics::getVerletDynamicsAtomStreamHeight( void ) const { int BrookVerletDynamics::getVerletDynamicsParticleStreamHeight( void ) const {
return _verletAtomStreamHeight; return _verletParticleStreamHeight;
} }
/** /**
...@@ -427,14 +427,14 @@ BrookFloatStreamInternal* BrookVerletDynamics::getInverseMassStream( void ) cons ...@@ -427,14 +427,14 @@ BrookFloatStreamInternal* BrookVerletDynamics::getInverseMassStream( void ) cons
/** /**
* Initialize stream dimensions * Initialize stream dimensions
* *
* @param numberOfAtoms number of atoms * @param numberOfParticles number of particles
* @param platform platform * @param platform platform
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @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 ...@@ -442,9 +442,9 @@ int BrookVerletDynamics::_initializeStreamSizes( int numberOfAtoms, const Platfo
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
_verletAtomStreamSize = getAtomStreamSize( platform ); _verletParticleStreamSize = getParticleStreamSize( platform );
_verletAtomStreamWidth = getAtomStreamWidth( platform ); _verletParticleStreamWidth = getParticleStreamWidth( platform );
_verletAtomStreamHeight = getAtomStreamHeight( platform ); _verletParticleStreamHeight = getParticleStreamHeight( platform );
return DefaultReturnValue; return DefaultReturnValue;
} }
...@@ -464,24 +464,24 @@ int BrookVerletDynamics::_initializeStreams( const Platform& platform ){ ...@@ -464,24 +464,24 @@ int BrookVerletDynamics::_initializeStreams( const Platform& platform ){
//static const std::string methodName = "BrookVerletDynamics::_initializeStreams"; //static const std::string methodName = "BrookVerletDynamics::_initializeStreams";
BrookOpenMMFloat dangleValue = (BrookOpenMMFloat) 0.0; BrookOpenMMFloat dangleValue = (BrookOpenMMFloat) 0.0;
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
int sdAtomStreamSize = getVerletDynamicsAtomStreamSize(); int sdParticleStreamSize = getVerletDynamicsParticleStreamSize();
int sdAtomStreamWidth = getVerletDynamicsAtomStreamWidth(); int sdParticleStreamWidth = getVerletDynamicsParticleStreamWidth();
_verletStreams[VPrimeStream] = new BrookFloatStreamInternal( BrookCommon::VPrimeStream, _verletStreams[VPrimeStream] = new BrookFloatStreamInternal( BrookCommon::VPrimeStream,
sdAtomStreamSize, sdAtomStreamWidth, sdParticleStreamSize, sdParticleStreamWidth,
BrookStreamInternal::Float3, dangleValue ); BrookStreamInternal::Float3, dangleValue );
_verletStreams[XPrimeStream] = new BrookFloatStreamInternal( BrookCommon::XPrimeStream, _verletStreams[XPrimeStream] = new BrookFloatStreamInternal( BrookCommon::XPrimeStream,
sdAtomStreamSize, sdAtomStreamWidth, sdParticleStreamSize, sdParticleStreamWidth,
BrookStreamInternal::Float3, dangleValue ); BrookStreamInternal::Float3, dangleValue );
_verletStreams[InverseMassStream] = new BrookFloatStreamInternal( BrookCommon::InverseMassStream, _verletStreams[InverseMassStream] = new BrookFloatStreamInternal( BrookCommon::InverseMassStream,
sdAtomStreamSize, sdAtomStreamWidth, sdParticleStreamSize, sdParticleStreamWidth,
BrookStreamInternal::Float, dangleValue ); BrookStreamInternal::Float, dangleValue );
return DefaultReturnValue; return DefaultReturnValue;
} }
...@@ -501,13 +501,13 @@ int BrookVerletDynamics::_updateVerletStreams( void ){ ...@@ -501,13 +501,13 @@ int BrookVerletDynamics::_updateVerletStreams( void ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
int atomStreamSize = getVerletDynamicsAtomStreamSize(); int particleStreamSize = getVerletDynamicsParticleStreamSize();
BrookOpenMMFloat* inverseMass = new BrookOpenMMFloat[atomStreamSize]; BrookOpenMMFloat* inverseMass = new BrookOpenMMFloat[particleStreamSize];
memset( inverseMass, 0, atomStreamSize*sizeof( BrookOpenMMFloat ) ); memset( inverseMass, 0, particleStreamSize*sizeof( BrookOpenMMFloat ) );
int numberOfAtoms = getNumberOfAtoms(); int numberOfParticles = getNumberOfParticles();
for( int ii = 0; ii < numberOfAtoms; ii++ ){ for( int ii = 0; ii < numberOfParticles; ii++ ){
inverseMass[ii] = _inverseMasses[ii]; inverseMass[ii] = _inverseMasses[ii];
} }
...@@ -522,7 +522,7 @@ int BrookVerletDynamics::_updateVerletStreams( void ){ ...@@ -522,7 +522,7 @@ int BrookVerletDynamics::_updateVerletStreams( void ){
/** /**
* Set masses * Set masses
* *
* @param masses atomic masses * @param masses particle masses
* *
*/ */
...@@ -574,12 +574,12 @@ int BrookVerletDynamics::setup( const std::vector<double>& masses, const Platfor ...@@ -574,12 +574,12 @@ int BrookVerletDynamics::setup( const std::vector<double>& masses, const Platfor
const BrookPlatform brookPlatform = dynamic_cast<const BrookPlatform&> (platform); const BrookPlatform brookPlatform = dynamic_cast<const BrookPlatform&> (platform);
setLog( brookPlatform.getLog() ); setLog( brookPlatform.getLog() );
int numberOfAtoms = (int) masses.size(); int numberOfParticles = (int) masses.size();
setNumberOfAtoms( numberOfAtoms ); setNumberOfParticles( numberOfParticles );
// set stream sizes and then create streams // set stream sizes and then create streams
_initializeStreamSizes( numberOfAtoms, platform ); _initializeStreamSizes( numberOfParticles, platform );
_initializeStreams( platform ); _initializeStreams( platform );
_setInverseMasses( masses ); _setInverseMasses( masses );
...@@ -618,17 +618,17 @@ std::string BrookVerletDynamics::getContentsString( int level ) const { ...@@ -618,17 +618,17 @@ std::string BrookVerletDynamics::getContentsString( int level ) const {
#define LOCAL_SPRINTF(a,b,c) sprintf( (a), (b), (c) ); #define LOCAL_SPRINTF(a,b,c) sprintf( (a), (b), (c) );
#endif #endif
(void) LOCAL_SPRINTF( value, "%d", getNumberOfAtoms() ); (void) LOCAL_SPRINTF( value, "%d", getNumberOfParticles() );
message << _getLine( tab, "Number of atoms:", value ); message << _getLine( tab, "Number of particles:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamWidth() ); (void) LOCAL_SPRINTF( value, "%d", getParticleStreamWidth() );
message << _getLine( tab, "Atom stream width:", value ); message << _getLine( tab, "Particle stream width:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamHeight() ); (void) LOCAL_SPRINTF( value, "%d", getParticleStreamHeight() );
message << _getLine( tab, "Atom stream height:", value ); message << _getLine( tab, "Particle stream height:", value );
(void) LOCAL_SPRINTF( value, "%d", getAtomStreamSize() ); (void) LOCAL_SPRINTF( value, "%d", getParticleStreamSize() );
message << _getLine( tab, "Atom stream size:", value ); message << _getLine( tab, "Particle stream size:", value );
(void) LOCAL_SPRINTF( value, "%.5f", getStepSize() ); (void) LOCAL_SPRINTF( value, "%.5f", getStepSize() );
message << _getLine( tab, "Step size:", value ); message << _getLine( tab, "Step size:", value );
......
platforms/brook/src/BrookVerletDynamics.h
View file @ 309008f7
...@@ -85,28 +85,28 @@ class BrookVerletDynamics : public BrookCommon { ...@@ -85,28 +85,28 @@ class BrookVerletDynamics : public BrookCommon {
const BrookOpenMMFloat* getDerivedParameters( void ) const; 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 * Update parameters
...@@ -122,9 +122,9 @@ class BrookVerletDynamics : public BrookCommon { ...@@ -122,9 +122,9 @@ class BrookVerletDynamics : public BrookCommon {
/** /**
* Update * Update
* *
* @param positions atom positions * @param positions particle positions
* @param velocities atom velocities * @param velocities particle velocities
* @param forces atom forces * @param forces particle forces
* @param brookShakeAlgorithm BrookShakeAlgorithm reference * @param brookShakeAlgorithm BrookShakeAlgorithm reference
* *
* @return DefaultReturnValue * @return DefaultReturnValue
...@@ -146,7 +146,7 @@ class BrookVerletDynamics : public BrookCommon { ...@@ -146,7 +146,7 @@ class BrookVerletDynamics : public BrookCommon {
/* /*
* Setup of VerletDynamics parameters * Setup of VerletDynamics parameters
* *
* @param masses atom masses * @param masses particle masses
* @param platform Brook platform * @param platform Brook platform
* *
* @return ErrorReturnValue value if error, else DefaultReturnValue * @return ErrorReturnValue value if error, else DefaultReturnValue
...@@ -206,11 +206,11 @@ class BrookVerletDynamics : public BrookCommon { ...@@ -206,11 +206,11 @@ class BrookVerletDynamics : public BrookCommon {
BrookOpenMMFloat _stepSize; BrookOpenMMFloat _stepSize;
// Atom stream dimensions // Particle stream dimensions
int _verletAtomStreamWidth; int _verletParticleStreamWidth;
int _verletAtomStreamHeight; int _verletParticleStreamHeight;
int _verletAtomStreamSize; int _verletParticleStreamSize;
/* /*
* Update streams * Update streams
...@@ -243,26 +243,26 @@ class BrookVerletDynamics : public BrookCommon { ...@@ -243,26 +243,26 @@ class BrookVerletDynamics : public BrookCommon {
/* /*
* Setup of stream dimensions * Setup of stream dimensions
* *
* @param atomStreamSize atom stream size * @param particleStreamSize particle stream size
* @param atomStreamWidth atom stream width * @param particleStreamWidth particle stream width
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @return ErrorReturnValue if error, else DefaultReturnValue
* *
* */ * */
int _initializeStreamSizes( int atomStreamSize, int atomStreamWidth ); int _initializeStreamSizes( int particleStreamSize, int particleStreamWidth );
/** /**
* Initialize stream dimensions * Initialize stream dimensions
* *
* @param numberOfAtoms number of atoms * @param numberOfParticles number of particles
* @param platform platform * @param platform platform
* *
* @return ErrorReturnValue if error, else DefaultReturnValue * @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 * Initialize stream dimensions and streams
...@@ -278,7 +278,7 @@ class BrookVerletDynamics : public BrookCommon { ...@@ -278,7 +278,7 @@ class BrookVerletDynamics : public BrookCommon {
/** /**
* Set masses * 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 ){ ...@@ -56,9 +56,16 @@ OpenMMBrookInterface::OpenMMBrookInterface( void ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
_numberOfAtoms = 0; _numberOfParticles = 0;
_brookBonded = NULL; _brookBonded = NULL;
_brookNonBonded = NULL; _brookNonBonded = NULL;
_brookGbsa = NULL;
_positions = NULL;
_velocities = NULL;
_forces = NULL;
_refForceField = NULL; _refForceField = NULL;
_log = NULL; _log = NULL;
...@@ -198,215 +205,98 @@ int OpenMMBrookInterface::setRBTorsionForceParameters( BrookBondParameters* broo ...@@ -198,215 +205,98 @@ int OpenMMBrookInterface::setRBTorsionForceParameters( BrookBondParameters* broo
* *
*/ */
int OpenMMBrookInterface::setLJ14( BrookBondParameters* brookBondParameters ){ int OpenMMBrookInterface::setNonBonded14ForceParameters( BrookBondParameters* brookBondParameters ){
return _setBondParameters( LJ14Index, 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 * @return particle positions
* @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 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, BrookStreamImpl* OpenMMBrookInterface::getParticlePositions( void ){
bondIndices, bondParameters, return _positions;
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];
// 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 context context
* @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.
*/ */
void OpenMMBrookInterface::executeForces( const Stream& positions, Stream& forces ){ void OpenMMBrookInterface::computeForces( OpenMMContextImpl& context ){
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
static const std::string methodName = "OpenMMBrookInterface::executeForces"; 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 PrintOn = 0;
static const int MaxErrorMessages = 2; static const int MaxErrorMessages = 2;
static int ErrorMessages = 0; static int ErrorMessages = 0;
...@@ -417,459 +307,47 @@ void OpenMMBrookInterface::executeForces( const Stream& positions, Stream& force ...@@ -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 // nonbonded forces
// added charge stream to knbforce_CDLJ4 BrookStreamImpl* positions = getParticlePositions();
// libs generated from ~/src/gmxgpu-nsqOpenMM BrookStreamImpl* forces = getParticleForces();
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() );
if( _brookNonBonded ){
_brookNonBonded->computeForces( *positions, *forces );
} }
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// bonded
epsfac = (float) (_brookBonded->getLJ_14Scale()*_brookBonded->getCoulombFactor());
float width = (float) (_brookBonded->getInverseMapStreamWidth());
// bonded forces // bonded forces
BrookFloatStreamInternal** bondedParameters = _brookBonded->getBondedParameterStreams(); if( _brookBonded ){
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() );
*/
(void) fprintf( getLog(), "\nInverse map streams -- K_Stream cnt=%d\n", _brookBonded->getInverseMapStreamCount( K_Stream ) ); _brookBonded->computeForces( *positions, *forces );
for( int ii = 0; ii < 4; ii++ ){
for( int jj = 0; jj < countPrintInvMap[ii]; jj++ ){ // diagnostics
(void) fprintf( getLog(), "\n Inverse map streams index=%d %d\n", ii, jj );
inverseStreamMaps[ii][jj]->printToFile( getLog() ); 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 // GBSA OBC forces
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] );
}
*/
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 @@ ...@@ -34,16 +34,16 @@
#include "kernels.h" #include "kernels.h"
#include "../../reference/src/SimTKUtilities/SimTKOpenMMRealType.h" #include "../../reference/src/SimTKUtilities/SimTKOpenMMRealType.h"
#include "BrookBondParameters.h"
#include "BrookBonded.h" #include "BrookBonded.h"
#include "BrookNonBonded.h" #include "BrookNonBonded.h"
#include "BrookGbsa.h"
#include "NonbondedForce.h" #include "NonbondedForce.h"
#include "OpenMMContext.h" #include "OpenMMContext.h"
#include "System.h" #include "System.h"
#include "ReferencePlatform.h" #include "ReferencePlatform.h"
#include "VerletIntegrator.h" #include "VerletIntegrator.h"
class BrookBondParameters;
namespace OpenMM { namespace OpenMM {
/** /**
...@@ -57,76 +57,16 @@ class OpenMMBrookInterface { ...@@ -57,76 +57,16 @@ class OpenMMBrookInterface {
~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 * Get reference Context
* *
* @param numberOfAtoms number of atoms * @param numberOfParticles number of particles
* *
* @return OpenMMContext * @return OpenMMContext
* *
*/ */
OpenMMContext* getReferenceOpenMMContext( int numberOfAtoms ); OpenMMContext* getReferenceOpenMMContext( int numberOfParticles );
/** /**
* Set log file reference * Set log file reference
...@@ -266,27 +206,97 @@ class OpenMMBrookInterface { ...@@ -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: private:
static const int DefaultReturnValue = 0;
static const int ErrorReturnValue = -1;
enum BondParameterIndices { HarmonicBondIndex, HarmonicAngleIndex, PeriodicTorsionForceIndex, RbTorsionForceIndex, LJ14Index, LastBondForce }; enum BondParameterIndices { HarmonicBondIndex, HarmonicAngleIndex, PeriodicTorsionForceIndex, RbTorsionForceIndex, LJ14Index, LastBondForce };
// log file reference // log file reference
FILE* _log; FILE* _log;
// number of atoms // number of particles
int _numberOfAtoms; int _numberOfParticles;
// Brook bonded & nonbonded // Brook bonded, nonbonded, Gbsa
BrookBonded* _brookBonded; BrookBonded* _brookBonded;
BrookNonBonded* _brookNonBonded; BrookNonBonded* _brookNonBonded;
BrookGbsa* _brookGbsa;
BrookBondParameters* _bondParameters[LastBondForce]; BrookBondParameters* _bondParameters[LastBondForce];
// context-related fields
BrookStreamImpl* _positions;
BrookStreamImpl* _velocities;
BrookStreamImpl* _forces;
// used to calculate energy // used to calculate energy
NonbondedForce* _refForceField; 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, 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 ...@@ -57,7 +37,7 @@ kernel void loop2Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jA
iAtomicRadii4 = float4( iAtomicRadii, iAtomicRadii, iAtomicRadii, iAtomicRadii ); 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 ...@@ -69,13 +49,13 @@ kernel void loop2Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jA
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
r = sqrt( r2 ); r = sqrt( r2 ); //4
rInverse = rsqrt( r2 ); rInverse = rsqrt( r2 ); //8
r2Inverse = rInverse*rInverse; r2Inverse = rInverse*rInverse; //4
rPlusScaledJ = r + jAtomicRadiiScaled; rPlusScaledJ = r + jAtomicRadiiScaled; //4
rMinusScaledJ = r - jAtomicRadiiScaled; rMinusScaledJ = r - jAtomicRadiiScaled; //4
rMinusScaledJAbs = abs( rMinusScaledJ ); rMinusScaledJAbs = abs( rMinusScaledJ );
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -84,21 +64,21 @@ kernel void loop2Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jA ...@@ -84,21 +64,21 @@ kernel void loop2Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jA
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
l_ij = 1.0f/l_ij; l_ij = 1.0f/l_ij; //4
l_ij2 = l_ij*l_ij; l_ij2 = l_ij*l_ij; //4
u_ij = 1.0f/rPlusScaledJ; u_ij = 1.0f/rPlusScaledJ; //4
u_ij2 = u_ij*u_ij; u_ij2 = u_ij*u_ij; //4
diff_u2_l2 = u_ij2 - l_ij2; diff_u2_l2 = u_ij2 - l_ij2; //4
scaledRadiusJ2 = jAtomicRadiiScaled*jAtomicRadiiScaled; scaledRadiusJ2 = jAtomicRadiiScaled*jAtomicRadiiScaled; //4
logRatio = log(u_ij/l_ij); logRatio = log(u_ij/l_ij); //4
// terms associated w/ dL/dr & dU/dr are zero and not included // 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 = float4( 1.0f, 1.0f, 1.0f, 1.0f );
// de = scaledRadiusJ2; // de = scaledRadiusJ2;
...@@ -112,15 +92,16 @@ kernel void loop2Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jA ...@@ -112,15 +92,16 @@ kernel void loop2Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jA
// Born radius term // 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.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; 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; bornSum += t3; //4
bornSum *= mask; bornSum *= mask; //4
*/
} }
/**************************************************************** /****************************************************************
* This file is part of the gpu acceleration library for gromacs. * This file is part of the gpu acceleration library for gromacs.
* Author: Mark Friedrichs * Author: Mark Friedrichs
...@@ -221,6 +202,7 @@ kernel void loop2InternalR2( float4 r2, float4 jAtomicRadiiScaled, ...@@ -221,6 +202,7 @@ kernel void loop2InternalR2( float4 r2, float4 jAtomicRadiiScaled,
/* This is a copy of loop2Internal(), but w/ the calculation of bornSum removed */ /* 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, kernel void loop2InternalNoSum( float3 d1, float3 d2, float3 d3, float3 d4, float4 jAtomicRadiiScaled,
float bornForce, float iAtomicRadii, out float4 de<> ){ float bornForce, float iAtomicRadii, out float4 de<> ){
...@@ -236,19 +218,19 @@ kernel void loop2InternalNoSum( float3 d1, float3 d2, float3 d3, float3 d4, floa ...@@ -236,19 +218,19 @@ kernel void loop2InternalNoSum( float3 d1, float3 d2, float3 d3, float3 d4, floa
const float bigValue = 1000000.0f; const float bigValue = 1000000.0f;
const float4 bigValue4 = float4( bigValue, bigValue, bigValue, bigValue ); const float4 bigValue4 = float4( bigValue, bigValue, bigValue, bigValue );
const float smallValue = 0.000001f; const float smallValue = 0.000001f;
const float4 smallValue4 = float4( smallValue, smallValue, smallValue, smallValue ); const float4 smallValue4 = float4( smallValue, smallValue, smallValue, smallValue );
const float4 zero4 = float4( 0.0f, 0.0f, 0.0f, 0.0f ); const float4 zero4 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
const float4 one4 = float4( 1.0f, 1.0f, 1.0f, 1.0f ); const float4 one4 = float4( 1.0f, 1.0f, 1.0f, 1.0f );
float4 mask; float4 mask;
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
iAtomicRadii4 = float4( iAtomicRadii, iAtomicRadii, iAtomicRadii, iAtomicRadii ); 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 ...@@ -259,12 +241,12 @@ kernel void loop2InternalNoSum( float3 d1, float3 d2, float3 d3, float3 d4, floa
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
r = sqrt( r2 ); r = sqrt( r2 ); //4
rInverse = rsqrt( r2 ); rInverse = rsqrt( r2 ); //8
r2Inverse = rInverse*rInverse; r2Inverse = rInverse*rInverse; //4
rPlusScaledJ = r + jAtomicRadiiScaled; rPlusScaledJ = r + jAtomicRadiiScaled; //4
rMinusScaledJ = r - jAtomicRadiiScaled; rMinusScaledJ = r - jAtomicRadiiScaled; //4
rMinusScaledJAbs = abs( rMinusScaledJ ); rMinusScaledJAbs = abs( rMinusScaledJ );
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -272,29 +254,105 @@ kernel void loop2InternalNoSum( float3 d1, float3 d2, float3 d3, float3 d4, floa ...@@ -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 : mask;
mask = iAtomicRadii4 >= rPlusScaledJ ? zero4 : one4; 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 = iAtomicRadii4 > rMinusScaledJAbs ? iAtomicRadii4 : rMinusScaledJAbs;
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
l_ij = 1.0f/l_ij; l_ij = 1.0f/l_ij; //4
l_ij2 = l_ij*l_ij; l_ij2 = l_ij*l_ij; //4
u_ij = 1.0f/rPlusScaledJ; u_ij = 1.0f/rPlusScaledJ; //4
u_ij2 = u_ij*u_ij; u_ij2 = u_ij*u_ij; //4
diff_u2_l2 = u_ij2 - l_ij2; //4
scaledRadiusJ2 = jAtomicRadiiScaled*jAtomicRadiiScaled; logRatio = log(u_ij/l_ij); //4
logRatio = log(u_ij/l_ij); //24
// ---------------------------------------------------------------------------------------
// terms associated w/ dL/dr & dU/dr are zero and not included // 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; bornSum = l_ij - u_ij + 0.5f*rInverse*logRatio + 0.25f*( r - jAtomicRadiiScaled*jAtomicRadiiScaled*rInverse)*diff_u2_l2; //10*4
// de = rInverse;
// de = float4( 1.0f, 1.0f, 1.0f, 1.0f );
// de = bornForce;
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 // 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 ...@@ -415,9 +473,9 @@ kernel void loop2InternalNoSumX( float3 d1, float3 d2, float3 d3, float3 d4, flo
const float bigValue = 1000000.0f; const float bigValue = 1000000.0f;
const float4 bigValue4 = float4( bigValue, bigValue, bigValue, bigValue ); const float4 bigValue4 = float4( bigValue, bigValue, bigValue, bigValue );
const float smallValue = 0.000001f; const float smallValue = 0.000001f;
const float4 smallValue4 = float4( smallValue, smallValue, smallValue, smallValue ); const float4 smallValue4 = float4( smallValue, smallValue, smallValue, smallValue );
const float4 zero4 = float4( 0.0f, 0.0f, 0.0f, 0.0f ); const float4 zero4 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
const float4 one4 = float4( 1.0f, 1.0f, 1.0f, 1.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 ...@@ -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, kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicationFactor,
float streamWidth, float fstreamWidth, float3 posq[][], float streamWidth, float fstreamWidth, float4 posq[][],
float2 scaledAtomicRadii[][], float atomicRadii[][], float scaledAtomicRadii[][],
float bornForceFactor[][], float bornForceFactor[][],
out float4 bornForce1<>, out float4 bornForce2<>, out float4 bornForce1<>, out float4 bornForce2<>,
out float4 bornForce3<>, out float4 bornForce4<> ){ out float4 bornForce3<>, out float4 bornForce4<> ){
...@@ -562,6 +621,8 @@ kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicat ...@@ -562,6 +621,8 @@ kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicat
float jEnd, jStart, jBlock; float jEnd, jStart, jBlock;
float whichRep; float whichRep;
float tmp; float tmp;
float tmp2;
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -589,42 +650,38 @@ kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicat ...@@ -589,42 +650,38 @@ kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicat
// etch i1 position, Born prefactor, atomic radius // etch i1 position, Born prefactor, atomic radius
i1pos = posq[ iAtom ]; i1pos = posq[ iAtom ].xyz;
i1BornForceFactor = bornForceFactor[ iAtom ]; i1BornForceFactor = bornForceFactor[ iAtom ];
i1AtomicRadii = scaledAtomicRadii[ iAtom ].y; i1AtomicRadii = atomicRadii[ iAtom ];
i1ScaledAtomicRadii = scaledAtomicRadii[ iAtom ].x; i1ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
bornForce1 = float4( 0.0f, 0.0f, 0.0f, 0.0f ); bornForce1 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
//bornForce1.xyz = float3( i1BornForceFactor, i1ScaledAtomicRadii, i1AtomicRadii );
// etch i2 position, Born prefactor, atomic radius // etch i2 position, Born prefactor, atomic radius
iAtom.x += 1; iAtom.x += 1;
i2pos = posq[ iAtom ]; i2pos = posq[ iAtom ].xyz;
i2BornForceFactor = bornForceFactor[ iAtom ]; i2BornForceFactor = bornForceFactor[ iAtom ];
i2AtomicRadii = scaledAtomicRadii[ iAtom ].y; i2AtomicRadii = atomicRadii[ iAtom ];
i2ScaledAtomicRadii = scaledAtomicRadii[ iAtom ].x; i2ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
bornForce2 = float4( 0.0f, 0.0f, 0.0f, 0.0f ); bornForce2 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
//bornForce2.xyz = float3( i2BornForceFactor, i2ScaledAtomicRadii, i2AtomicRadii );
// etch i3 position, Born prefactor, atomic radius // etch i3 position, Born prefactor, atomic radius
iAtom.x += 1; iAtom.x += 1;
i3pos = posq[ iAtom ]; i3pos = posq[ iAtom ].xyz;
i3BornForceFactor = bornForceFactor[ iAtom ]; i3BornForceFactor = bornForceFactor[ iAtom ];
i3AtomicRadii = scaledAtomicRadii[ iAtom ].y; i3AtomicRadii = atomicRadii[ iAtom ];
i3ScaledAtomicRadii = scaledAtomicRadii[ iAtom ].x; i3ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
bornForce3 = float4( 0.0f, 0.0f, 0.0f, 0.0f ); bornForce3 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
//bornForce3.xyz = float3( i3BornForceFactor, i3ScaledAtomicRadii, i3AtomicRadii );
// etch i4 position, Born prefactor, atomic radius // etch i4 position, Born prefactor, atomic radius
iAtom.x += 1; iAtom.x += 1;
i4pos = posq[ iAtom ]; i4pos = posq[ iAtom ].xyz;
i4BornForceFactor = bornForceFactor[ iAtom ]; i4BornForceFactor = bornForceFactor[ iAtom ];
i4AtomicRadii = scaledAtomicRadii[ iAtom ].y; i4AtomicRadii = atomicRadii[ iAtom ];
i4ScaledAtomicRadii = scaledAtomicRadii[ iAtom ].x; i4ScaledAtomicRadii = scaledAtomicRadii[ iAtom ];
bornForce4 = float4( 0.0f, 0.0f, 0.0f, 0.0f ); bornForce4 = float4( 0.0f, 0.0f, 0.0f, 0.0f );
//bornForce4.xyz = float3( i4BornForceFactor, i4ScaledAtomicRadii, i4AtomicRadii );
// create float4 for main vars // create float4 for main vars
...@@ -635,9 +692,12 @@ kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicat ...@@ -635,9 +692,12 @@ kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicat
// inner loop indices setup // inner loop indices setup
//changed the following instruction for rounding issues on some ASICs //changed the following instruction for rounding issues on some ASICs
//whichRep = floor( forceIndex / roundedUpAtoms ); //whichRep = floor( forceIndex / roundedUpAtoms );
tmp = fmod(forceIndex, roundedUpAtoms); tmp = fmod(forceIndex, roundedUpAtoms);
whichRep = round((forceIndex - tmp)/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; jStart = whichRep*jBlock;
jEnd = ( whichRep > duplicationFactor - 1.5f ) ? 999999.0f : (jStart + jBlock); jEnd = ( whichRep > duplicationFactor - 1.5f ) ? 999999.0f : (jStart + jBlock);
...@@ -654,30 +714,32 @@ kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicat ...@@ -654,30 +714,32 @@ kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicat
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// gather required values // gather required values
j1BornForceFactor = bornForceFactor[ jAtom ]; j1BornForceFactor = bornForceFactor[ jAtom ];
j1AtomicRadii = scaledAtomicRadii[ jAtom ].y; j1AtomicRadii = atomicRadii[ jAtom ];
j1ScaledAtomicRadii = scaledAtomicRadii[ jAtom ].x; j1ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j1pos = posq[ jAtom ]; j1pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f; jAtom.x += 1.0f;
j2BornForceFactor = bornForceFactor[ jAtom ]; j2BornForceFactor = bornForceFactor[ jAtom ];
j2AtomicRadii = scaledAtomicRadii[ jAtom ].y; j2AtomicRadii = atomicRadii[ jAtom ];
j2ScaledAtomicRadii = scaledAtomicRadii[ jAtom ].x; j2ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j2pos = posq[ jAtom ]; j2pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f; jAtom.x += 1.0f;
j3BornForceFactor = bornForceFactor[ jAtom ]; j3BornForceFactor = bornForceFactor[ jAtom ];
j3AtomicRadii = scaledAtomicRadii[ jAtom ].y; j3AtomicRadii = atomicRadii[ jAtom ];
j3ScaledAtomicRadii = scaledAtomicRadii[ jAtom ].x; j3ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j3pos = posq[ jAtom ]; j3pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f; jAtom.x += 1.0f;
j4BornForceFactor = bornForceFactor[ jAtom ]; j4BornForceFactor = bornForceFactor[ jAtom ];
j4AtomicRadii = scaledAtomicRadii[ jAtom ].y; j4AtomicRadii = atomicRadii[ jAtom ];
j4ScaledAtomicRadii = scaledAtomicRadii[ jAtom ].x; j4ScaledAtomicRadii = scaledAtomicRadii[ jAtom ];
j4pos = posq[ jAtom ]; j4pos = posq[ jAtom ].xyz;
jAtom.x += 1.0f; jAtom.x += 1.0f;
//jBornForceFactor = float4( j1BornForceFactor, j2BornForceFactor, j3BornForceFactor, j4BornForceFactor ); //jBornForceFactor = float4( j1BornForceFactor, j2BornForceFactor, j3BornForceFactor, j4BornForceFactor );
jAtomicRadii = float4( j1AtomicRadii, j2AtomicRadii, j3AtomicRadii, j4AtomicRadii ); jAtomicRadii = float4( j1AtomicRadii, j2AtomicRadii, j3AtomicRadii, j4AtomicRadii );
...@@ -687,143 +749,141 @@ kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicat ...@@ -687,143 +749,141 @@ kernel void kObcLoop2( float numberOfAtoms, float roundedUpAtoms, float duplicat
// First set of 4 -- i == 1 // First set of 4 -- i == 1
d1 = j1pos - i1pos; //3
d1 = j1pos - i1pos; d2 = j2pos - i1pos; //3
d2 = j2pos - i1pos; d3 = j3pos - i1pos; //3
d3 = j3pos - i1pos; d4 = j4pos - i1pos; //3
d4 = j4pos - i1pos;
// i = 1 // 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.x*d1; //3*2=6
bornForce1.xyz += de.y*d2; bornForce1.xyz += de.y*d2; //3*2=6
bornForce1.xyz += de.z*d3; bornForce1.xyz += de.z*d3; //3*2=6
bornForce1.xyz += de.w*d4; bornForce1.xyz += de.w*d4; //3*2=6
bornForce1.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //bornForce1.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// i = 2 // i = 2
d1 = j1pos - i2pos; d1 = j1pos - i2pos; //3
d2 = j2pos - i2pos; d2 = j2pos - i2pos; //3
d3 = j3pos - i2pos; d3 = j3pos - i2pos; //3
d4 = j4pos - i2pos; 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.x*d1; //3*2=6
bornForce2.xyz += de.y*d2; bornForce2.xyz += de.y*d2; //3*2=6
bornForce2.xyz += de.z*d3; bornForce2.xyz += de.z*d3; //3*2=6
bornForce2.xyz += de.w*d4; bornForce2.xyz += de.w*d4; //3*2=6
bornForce2.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //bornForce2.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// i = 3 // i = 3
d1 = j1pos - i3pos; d1 = j1pos - i3pos; //3
d2 = j2pos - i3pos; d2 = j2pos - i3pos; //3
d3 = j3pos - i3pos; d3 = j3pos - i3pos; //3
d4 = j4pos - i3pos; 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.x*d1; //3*2=6
bornForce3.xyz += de.y*d2; bornForce3.xyz += de.y*d2; //3*2=6
bornForce3.xyz += de.z*d3; bornForce3.xyz += de.z*d3; //3*2=6
bornForce3.xyz += de.w*d4; bornForce3.xyz += de.w*d4; //3*2=6
bornForce3.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //bornForce3.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// i = 4 // i = 4
d1 = j1pos - i4pos; d1 = j1pos - i4pos; //3
d2 = j2pos - i4pos; d2 = j2pos - i4pos; //3
d3 = j3pos - i4pos; d3 = j3pos - i4pos; //3
d4 = j4pos - i4pos; 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.x*d1; //3*2=6
bornForce4.xyz += de.y*d2; bornForce4.xyz += de.y*d2; //3*2=6
bornForce4.xyz += de.z*d3; bornForce4.xyz += de.z*d3; //3*2=6
bornForce4.xyz += de.w*d4; bornForce4.xyz += de.w*d4; //3*2=6
bornForce4.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //bornForce4.w += bornSum.x + bornSum.y + bornSum.z + bornSum.w; //4
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// j = 1 // j = 1
d1 = j1pos - i1pos; d1 = j1pos - i1pos; //3
d2 = j1pos - i2pos; d2 = j1pos - i2pos; //3
d3 = j1pos - i3pos; d3 = j1pos - i3pos; //3
d4 = j1pos - i4pos; d4 = j1pos - i4pos; //3
// loop2Internal( d1, d2, d3, d4, iScaledAtomicRadii, j1BornForceFactor, j1AtomicRadii, de, bornSum ); // 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; bornForce1.xyz += de.x*d1; //3*2=6
bornForce2.xyz += de.y*d2; bornForce2.xyz += de.y*d2; //3*2=6
bornForce3.xyz += de.z*d3; bornForce3.xyz += de.z*d3; //3*2=6
bornForce4.xyz += de.w*d4; bornForce4.xyz += de.w*d4; //3*2=6
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// j = 2 // j = 2
d1 = j2pos - i1pos; d1 = j2pos - i1pos; //3
d2 = j2pos - i2pos; d2 = j2pos - i2pos; //3
d3 = j2pos - i3pos; d3 = j2pos - i3pos; //3
d4 = j2pos - i4pos; d4 = j2pos - i4pos; //3
// loop2Internal( d1, d2, d3, d4, iScaledAtomicRadii, j2BornForceFactor, j2AtomicRadii, de, bornSum ); // loop2Internal( d1, d2, d3, d4, iScaledAtomicRadii, j2BornForceFactor, j2AtomicRadii, de, bornSum );
loop2InternalNoSum( d1, d2, d3, d4, iScaledAtomicRadii, j2BornForceFactor, j2AtomicRadii, de ); loop2InternalNoSum( d1, d2, d3, d4, iScaledAtomicRadii, j2BornForceFactor, j2AtomicRadii, de ); //112 : 304
bornForce1.xyz += de.x*d1; bornForce1.xyz += de.x*d1; //3*2=6
bornForce2.xyz += de.y*d2; bornForce2.xyz += de.y*d2; //3*2=6
bornForce3.xyz += de.z*d3; bornForce3.xyz += de.z*d3; //3*2=6
bornForce4.xyz += de.w*d4; bornForce4.xyz += de.w*d4; //3*2=6
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// j = 3 // j = 3
d1 = j3pos - i1pos; d1 = j3pos - i1pos; //3
d2 = j3pos - i2pos; d2 = j3pos - i2pos; //3
d3 = j3pos - i3pos; d3 = j3pos - i3pos; //3
d4 = j3pos - i4pos; d4 = j3pos - i4pos; //3
// loop2Internal( d1, d2, d3, d4, iScaledAtomicRadii, j3BornForceFactor, j3AtomicRadii, de, bornSum ); // 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; bornForce1.xyz += de.x*d1; //3*2=6
bornForce2.xyz += de.y*d2; bornForce2.xyz += de.y*d2; //3*2=6
bornForce3.xyz += de.z*d3; bornForce3.xyz += de.z*d3; //3*2=6
bornForce4.xyz += de.w*d4; bornForce4.xyz += de.w*d4; //3*2=6
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
// j = 4 // j = 4
d1 = j4pos - i1pos; d1 = j4pos - i1pos; //3
d2 = j4pos - i2pos; d2 = j4pos - i2pos; //3
d3 = j4pos - i3pos; d3 = j4pos - i3pos; //3
d4 = j4pos - i4pos; d4 = j4pos - i4pos; //3
// loop2Internal( d1, d2, d3, d4, iScaledAtomicRadii, j4BornForceFactor, j4AtomicRadii, de, bornSum ); // 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; //3*2=6
bornForce1.xyz += de.x*d1; bornForce2.xyz += de.y*d2; //3*2=6
bornForce2.xyz += de.y*d2; bornForce3.xyz += de.z*d3; //3*2=6
bornForce3.xyz += de.z*d3; bornForce4.xyz += de.w*d4; //3*2=6
bornForce4.xyz += de.w*d4;
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -909,6 +969,471 @@ kernel float4 scalar_force_CDLJMerge( float4 qq, float epsfac, float4 sig, float ...@@ -909,6 +969,471 @@ kernel float4 scalar_force_CDLJMerge( float4 qq, float epsfac, float4 sig, float
return f; 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) Calculate Loop 2 OBC forces (Simbios)
......
platforms/brook/src/gpu/kgbsa.h
View file @ 309008f7
#ifndef __KGBSA_H__ #ifndef __KGBSA_H__
#define __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( void kMergeFloat4(
const float repfac, const float repfac,
const float atomStrWidth, const float atomStrWidth,
...@@ -108,6 +75,28 @@ void kAddAndMergeFloat4_4( ...@@ -108,6 +75,28 @@ void kAddAndMergeFloat4_4(
::brook::stream outputStream ::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( void kPostObcLoop2_nobranch(
const float repfac, const float repfac,
const float atomStrWidth, const float atomStrWidth,
...@@ -129,6 +118,21 @@ void kPostObcLoop2_nobranch( ...@@ -129,6 +118,21 @@ void kPostObcLoop2_nobranch(
::brook::stream outputStream ::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( void kPreGbsaForce2(
::brook::stream intermediateForceIn, ::brook::stream intermediateForceIn,
::brook::stream bornRadii, ::brook::stream bornRadii,
...@@ -483,6 +487,7 @@ void kObcLoop2( ...@@ -483,6 +487,7 @@ void kObcLoop2(
float fstreamWidth, float fstreamWidth,
::brook::stream posq, ::brook::stream posq,
::brook::stream atomicRadii, ::brook::stream atomicRadii,
::brook::stream scaledAtomicRadii,
::brook::stream bornForceFactor, ::brook::stream bornForceFactor,
::brook::stream bornForce1, ::brook::stream bornForce1,
::brook::stream bornForce2, ::brook::stream bornForce2,
...@@ -490,6 +495,18 @@ void kObcLoop2( ...@@ -490,6 +495,18 @@ void kObcLoop2(
::brook::stream bornForce4 ::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( void kObcBornRadii(
float numberOfAtoms, float numberOfAtoms,
float streamWidth, float streamWidth,
...@@ -508,6 +525,22 @@ void kAceNonPolar( ...@@ -508,6 +525,22 @@ void kAceNonPolar(
::brook::stream bornForce ::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 kZeroFloat4( ::brook::stream bornForce );
void kSetValue4( float value, ::brook::stream bornForce ); void kSetValue4( float value, ::brook::stream bornForce );
void kSetValue3( float value, ::brook::stream bornForce ); void kSetValue3( float value, ::brook::stream bornForce );
......
platforms/brook/src/gpu/kgbsa1.br
View file @ 309008f7
/* -------------------------------------------------------------------------- * /****************************************************************
* OpenMM * * This file is part of the gpu acceleration library for gromacs.
* -------------------------------------------------------------------------- * * Author: Mark Friedrichs
* This is part of the OpenMM molecular simulation toolkit originating from * *
* Simbios, the NIH National Center for Physics-Based Simulation of * * This kernel was developed in collaboration with
* Biological Structures at Stanford, funded under the NIH Roadmap for * *
* Medical Research, grant U54 GM072970. See https://simtk.org. * * Copyright (C) Pande Group, Stanford, 2006
* * *****************************************************************/
* Portions copyright (c) 2008 Stanford University and the Authors. * //96 : 228 Flops
* 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. *
* -------------------------------------------------------------------------- */
kernel void loop1Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jBornR, kernel void loop1Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jBornR,
float4 jQ, float iBornR, float iQ, out float4 dGpol_dr<>, float4 jQ, float iBornR, float iQ, out float4 dGpol_dr<>,
out float4 dGpol_dalpha2_ij<> ){ out float4 dGpol_dalpha2_ij<> ){
...@@ -40,16 +18,16 @@ kernel void loop1Internal( float3 d1, float3 d2, float3 d3, float3 d4, float4 jB ...@@ -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 ) ); r2 = float4( dot(d1, d1), dot( d2, d2 ), dot( d3, d3 ), dot( d4, d4 ) ); //20
alpha2_ij = jBornR*iBornR; alpha2_ij = jBornR*iBornR; //4
D_ij = r2/(4.0f*alpha2_ij); D_ij = r2/(4.0f*alpha2_ij); //8
expTerm = exp( -D_ij ); expTerm = exp( -D_ij ); //4 : 80
denominator2 = r2 + alpha2_ij*expTerm; denominator2 = r2 + alpha2_ij*expTerm; //8
denominator = sqrt( denominator2 ); denominator = sqrt( denominator2 ); //4 : 60
Gpol = jQ/denominator; Gpol = jQ/denominator; //4
Gpol *= iQ; Gpol *= iQ;//4
dGpol_dr = -Gpol*( 1.0f - 0.25f*expTerm )/denominator2; dGpol_dr = -Gpol*( 1.0f - 0.25f*expTerm )/denominator2; //16
dGpol_dalpha2_ij = -0.5f*Gpol*expTerm*( 1.0f + D_ij )*jBornR/denominator2; 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 ...@@ -82,9 +60,9 @@ kernel void kAceNonPolarLoop1( float iBornRadius, float iVdwRadius, float duplic
const float probeRadius = 0.14f; 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 = -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 ...@@ -129,11 +107,11 @@ kernel void kAceNonPolarLoop1( float iBornRadius, float iVdwRadius, float duplic
bornForce4: i-unroll second force component, including dBornR/dr in .w bornForce4: i-unroll second force component, including dBornR/dr in .w
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
//FLOPS = 544
kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicationFactor, kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicationFactor,
float streamWidth, float fstreamWidth, float soluteDielectric, float streamWidth, float fstreamWidth, float soluteDielectric,
float solventDielectric, float includeAce, float solventDielectric, float includeAce,
float3 posq[][], float bornRadii[][], float2 atomicRadii[][], float4 posq[][], float bornRadii[][], float atomicRadii[][],
out float4 bornForce1<>, out float4 bornForce2<>, out float4 bornForce1<>, out float4 bornForce2<>,
out float4 bornForce3<>, out float4 bornForce4<> ){ out float4 bornForce3<>, out float4 bornForce4<> ){
...@@ -214,11 +192,11 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat ...@@ -214,11 +192,11 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat
// etch i1 position and partial charge // etch i1 position and partial charge
jQ = posq[ iAtom ]; jQ = posq[ iAtom ];
i1BornR = bornRadii[ iAtom ];
i1AtomicR = atomicRadii[ iAtom ];
i1Pos = jQ.xyz; i1Pos = jQ.xyz;
i1Q = atomicRadii[ iAtom ].y; i1Q = jQ.w;
i1Q *= preFactor; i1Q *= preFactor;
i1BornR = bornRadii[ iAtom ];
i1AtomicR = atomicRadii[ iAtom ].x;
kAceNonPolarLoop1( i1BornR, i1AtomicR, duplicationFactor, aceForce ); kAceNonPolarLoop1( i1BornR, i1AtomicR, duplicationFactor, aceForce );
bornForce1.xyz = zero3; bornForce1.xyz = zero3;
bornForce1.w = includeAce > 0.5f ? aceForce : 0.0f; bornForce1.w = includeAce > 0.5f ? aceForce : 0.0f;
...@@ -229,11 +207,11 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat ...@@ -229,11 +207,11 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat
iAtom.x += 1; iAtom.x += 1;
jQ = posq[ iAtom ]; jQ = posq[ iAtom ];
i2BornR = bornRadii[ iAtom ];
i2AtomicR = atomicRadii[ iAtom ];
i2Pos = jQ.xyz; i2Pos = jQ.xyz;
i2Q = atomicRadii[ iAtom ].y; i2Q = jQ.w;
i2Q *= preFactor; i2Q *= preFactor;
i2BornR = bornRadii[ iAtom ];
i2AtomicR = atomicRadii[ iAtom ].x;
kAceNonPolarLoop1( i2BornR, i2AtomicR, duplicationFactor, aceForce ); kAceNonPolarLoop1( i2BornR, i2AtomicR, duplicationFactor, aceForce );
bornForce2.xyz = zero3; bornForce2.xyz = zero3;
bornForce2.w = includeAce > 0.5f ? aceForce : 0.0f; bornForce2.w = includeAce > 0.5f ? aceForce : 0.0f;
...@@ -244,11 +222,11 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat ...@@ -244,11 +222,11 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat
iAtom.x += 1; iAtom.x += 1;
jQ = posq[ iAtom ]; jQ = posq[ iAtom ];
i3BornR = bornRadii[ iAtom ];
i3AtomicR = atomicRadii[ iAtom ];
i3Pos = jQ.xyz; i3Pos = jQ.xyz;
i3Q = atomicRadii[ iAtom ].y; i3Q = jQ.w;
i3Q *= preFactor; i3Q *= preFactor;
i3BornR = bornRadii[ iAtom ];
i3AtomicR = atomicRadii[ iAtom ].x;
kAceNonPolarLoop1( i3BornR, i3AtomicR, duplicationFactor, aceForce ); kAceNonPolarLoop1( i3BornR, i3AtomicR, duplicationFactor, aceForce );
bornForce3.xyz = zero3; bornForce3.xyz = zero3;
bornForce3.w = includeAce > 0.5f ? aceForce : 0.0f; bornForce3.w = includeAce > 0.5f ? aceForce : 0.0f;
...@@ -260,11 +238,11 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat ...@@ -260,11 +238,11 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat
iAtom.x += 1; iAtom.x += 1;
jQ = posq[ iAtom ]; jQ = posq[ iAtom ];
i4BornR = bornRadii[ iAtom ];
i4AtomicR = atomicRadii[ iAtom ];
i4Pos = jQ.xyz; i4Pos = jQ.xyz;
i4Q = atomicRadii[ iAtom ].y; i4Q = jQ.w;
i4Q *= preFactor; i4Q *= preFactor;
i4BornR = bornRadii[ iAtom ];
i4AtomicR = atomicRadii[ iAtom ].x;
kAceNonPolarLoop1( i4BornR, i4AtomicR, duplicationFactor, aceForce ); kAceNonPolarLoop1( i4BornR, i4AtomicR, duplicationFactor, aceForce );
bornForce4.xyz = zero3; bornForce4.xyz = zero3;
bornForce4.w = includeAce > 0.5f ? aceForce : 0.0f; bornForce4.w = includeAce > 0.5f ? aceForce : 0.0f;
...@@ -286,8 +264,11 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat ...@@ -286,8 +264,11 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat
tmp = fmod(forceIndex, roundedUpAtoms); tmp = fmod(forceIndex, roundedUpAtoms);
whichRep = round((forceIndex - tmp)/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; jStart = whichRep*jBlock;
jEnd = ( whichRep > duplicationFactor - 1.5f ) ? 999999.0f : (jStart + jBlock); jEnd = ( whichRep > duplicationFactor - 1.5f ) ? 999999.0f : (jStart + jBlock);
...@@ -305,23 +286,27 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat ...@@ -305,23 +286,27 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat
// gather required values // gather required values
j1Pos = posq[ jAtom ]; j1PosQ = posq[ jAtom ];
j1Q = atomicRadii[ jAtom ].y; j1Pos = j1PosQ.xyz;
j1Q = j1PosQ.w;
j1BornR = bornRadii[ jAtom ]; j1BornR = bornRadii[ jAtom ];
jAtom.x += 1.0f; jAtom.x += 1.0f;
j2Pos = posq[ jAtom ]; j2PosQ = posq[ jAtom ];
j2Q = atomicRadii[ jAtom ].y; j2Pos = j2PosQ.xyz;
j2Q = j2PosQ.w;
j2BornR = bornRadii[ jAtom ]; j2BornR = bornRadii[ jAtom ];
jAtom.x += 1.0f; jAtom.x += 1.0f;
j3Pos = posq[ jAtom ]; j3PosQ = posq[ jAtom ];
j3Q = atomicRadii[ jAtom ].y; j3Pos = j3PosQ.xyz;
j3Q = j3PosQ.w;
j3BornR = bornRadii[ jAtom ]; j3BornR = bornRadii[ jAtom ];
jAtom.x += 1.0f; jAtom.x += 1.0f;
j4Pos = posq[ jAtom ]; j4PosQ = posq[ jAtom ];
j4Q = atomicRadii[ jAtom ].y; j4Pos = j4PosQ.xyz;
j4Q = j4PosQ.w;
j4BornR = bornRadii[ jAtom ]; j4BornR = bornRadii[ jAtom ];
jAtom.x += 1.0f; jAtom.x += 1.0f;
...@@ -332,73 +317,73 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat ...@@ -332,73 +317,73 @@ kernel void kObcLoop1( float numberOfAtoms, float roundedUpAtoms, float duplicat
// i == 1 // i == 1
d1 = i1Pos - j1Pos; d1 = i1Pos - j1Pos; //3
d2 = i1Pos - j2Pos; d2 = i1Pos - j2Pos; //3
d3 = i1Pos - j3Pos; d3 = i1Pos - j3Pos; //3
d4 = i1Pos - j4Pos; 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.x*d1; //6
bornForce1.xyz += dGpol_dr.y*d2; bornForce1.xyz += dGpol_dr.y*d2; //6
bornForce1.xyz += dGpol_dr.z*d3; bornForce1.xyz += dGpol_dr.z*d3; //6
bornForce1.xyz += dGpol_dr.w*d4; 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 // i == 2
d1 = i2Pos - j1Pos; d1 = i2Pos - j1Pos; //3
d2 = i2Pos - j2Pos; d2 = i2Pos - j2Pos; //3
d3 = i2Pos - j3Pos; d3 = i2Pos - j3Pos; //3
d4 = i2Pos - j4Pos; 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.x*d1; //6
bornForce2.xyz += dGpol_dr.y*d2; bornForce2.xyz += dGpol_dr.y*d2; //6
bornForce2.xyz += dGpol_dr.z*d3; bornForce2.xyz += dGpol_dr.z*d3; //6
bornForce2.xyz += dGpol_dr.w*d4; 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 // i == 3
d1 = i3Pos - j1Pos; d1 = i3Pos - j1Pos; //3
d2 = i3Pos - j2Pos; d2 = i3Pos - j2Pos; //3
d3 = i3Pos - j3Pos; d3 = i3Pos - j3Pos; //3
d4 = i3Pos - j4Pos; 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.x*d1; //6
bornForce3.xyz += dGpol_dr.y*d2; bornForce3.xyz += dGpol_dr.y*d2; //6
bornForce3.xyz += dGpol_dr.z*d3; bornForce3.xyz += dGpol_dr.z*d3; //6
bornForce3.xyz += dGpol_dr.w*d4; 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 // i == 4
d1 = i4Pos - j1Pos; d1 = i4Pos - j1Pos; //3
d2 = i4Pos - j2Pos; d2 = i4Pos - j2Pos; //3
d3 = i4Pos - j3Pos; d3 = i4Pos - j3Pos; //3
d4 = i4Pos - j4Pos; 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.x*d1; //6
bornForce4.xyz += dGpol_dr.y*d2; bornForce4.xyz += dGpol_dr.y*d2; //6
bornForce4.xyz += dGpol_dr.z*d3; bornForce4.xyz += dGpol_dr.z*d3; //6
bornForce4.xyz += dGpol_dr.w*d4; 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