Skip to content

GitLab

Commit 7fb10336 authored by peastman's avatar peastman
Browse files

Cleaned up lots of formatting to be more consistent with the rest of OpenMM

parent 1d3ffd7b
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 605 additions and 606 deletions
platforms/reference/src/SimTKReference/ReferenceStochasticDynamics.cpp
View file @ 7fb10336
...@@ -47,10 +47,10 @@ using namespace OpenMM; ...@@ -47,10 +47,10 @@ using namespace OpenMM;
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceStochasticDynamics::ReferenceStochasticDynamics( int numberOfAtoms, ReferenceStochasticDynamics::ReferenceStochasticDynamics(int numberOfAtoms,
RealOpenMM deltaT, RealOpenMM tau, RealOpenMM deltaT, RealOpenMM tau,
RealOpenMM temperature ) : RealOpenMM temperature) :
ReferenceDynamics( numberOfAtoms, deltaT, temperature ), _tau( tau ) { ReferenceDynamics(numberOfAtoms, deltaT, temperature), _tau(tau) {
if (tau <= 0) { if (tau <= 0) {
std::stringstream message; std::stringstream message;
message << "illegal tau value: " << tau; message << "illegal tau value: " << tau;
...@@ -66,7 +66,7 @@ ReferenceStochasticDynamics::ReferenceStochasticDynamics( int numberOfAtoms, ...@@ -66,7 +66,7 @@ ReferenceStochasticDynamics::ReferenceStochasticDynamics( int numberOfAtoms,
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceStochasticDynamics::~ReferenceStochasticDynamics( ){ ReferenceStochasticDynamics::~ReferenceStochasticDynamics() {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -84,7 +84,7 @@ ReferenceStochasticDynamics::~ReferenceStochasticDynamics( ){ ...@@ -84,7 +84,7 @@ ReferenceStochasticDynamics::~ReferenceStochasticDynamics( ){
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ReferenceStochasticDynamics::getTau( void ) const { RealOpenMM ReferenceStochasticDynamics::getTau() const {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -108,10 +108,10 @@ RealOpenMM ReferenceStochasticDynamics::getTau( void ) const { ...@@ -108,10 +108,10 @@ RealOpenMM ReferenceStochasticDynamics::getTau( void ) const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ReferenceStochasticDynamics::updatePart1( int numberOfAtoms, vector<RealVec>& atomCoordinates, void ReferenceStochasticDynamics::updatePart1(int numberOfAtoms, vector<RealVec>& atomCoordinates,
vector<RealVec>& velocities, vector<RealVec>& velocities,
vector<RealVec>& forces, vector<RealOpenMM>& inverseMasses, vector<RealVec>& forces, vector<RealOpenMM>& inverseMasses,
vector<RealVec>& xPrime ){ vector<RealVec>& xPrime) {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -149,10 +149,10 @@ void ReferenceStochasticDynamics::updatePart1( int numberOfAtoms, vector<RealVec ...@@ -149,10 +149,10 @@ void ReferenceStochasticDynamics::updatePart1( int numberOfAtoms, vector<RealVec
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ReferenceStochasticDynamics::updatePart2( int numberOfAtoms, vector<RealVec>& atomCoordinates, void ReferenceStochasticDynamics::updatePart2(int numberOfAtoms, vector<RealVec>& atomCoordinates,
vector<RealVec>& velocities, vector<RealVec>& velocities,
vector<RealVec>& forces, vector<RealOpenMM>& inverseMasses, vector<RealVec>& forces, vector<RealOpenMM>& inverseMasses,
vector<RealVec>& xPrime ){ vector<RealVec>& xPrime) {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -197,10 +197,10 @@ void ReferenceStochasticDynamics::update(const OpenMM::System& system, vector<Re ...@@ -197,10 +197,10 @@ void ReferenceStochasticDynamics::update(const OpenMM::System& system, vector<Re
// first-time-through initialization // first-time-through initialization
int numberOfAtoms = system.getNumParticles(); int numberOfAtoms = system.getNumParticles();
if( getTimeStep() == 0 ){ if (getTimeStep() == 0) {
// invert masses // invert masses
for( int ii = 0; ii < numberOfAtoms; ii++ ){ for (int ii = 0; ii < numberOfAtoms; ii++) {
if (masses[ii] == zero) if (masses[ii] == zero)
inverseMasses[ii] = zero; inverseMasses[ii] = zero;
else else
...@@ -210,11 +210,11 @@ void ReferenceStochasticDynamics::update(const OpenMM::System& system, vector<Re ...@@ -210,11 +210,11 @@ void ReferenceStochasticDynamics::update(const OpenMM::System& system, vector<Re
// 1st update // 1st update
updatePart1( numberOfAtoms, atomCoordinates, velocities, forces, inverseMasses, xPrime ); updatePart1(numberOfAtoms, atomCoordinates, velocities, forces, inverseMasses, xPrime);
// 2nd update // 2nd update
updatePart2( numberOfAtoms, atomCoordinates, velocities, forces, inverseMasses, xPrime ); updatePart2(numberOfAtoms, atomCoordinates, velocities, forces, inverseMasses, xPrime);
ReferenceConstraintAlgorithm* referenceConstraintAlgorithm = getReferenceConstraintAlgorithm(); ReferenceConstraintAlgorithm* referenceConstraintAlgorithm = getReferenceConstraintAlgorithm();
if (referenceConstraintAlgorithm) if (referenceConstraintAlgorithm)
......
platforms/reference/src/SimTKReference/ReferenceVariableStochasticDynamics.cpp
View file @ 7fb10336
...@@ -49,9 +49,9 @@ using namespace OpenMM; ...@@ -49,9 +49,9 @@ using namespace OpenMM;
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceVariableStochasticDynamics::ReferenceVariableStochasticDynamics( int numberOfAtoms, ReferenceVariableStochasticDynamics::ReferenceVariableStochasticDynamics(int numberOfAtoms,
RealOpenMM tau, RealOpenMM temperature, RealOpenMM tau, RealOpenMM temperature,
RealOpenMM accuracy ) : RealOpenMM accuracy) :
ReferenceDynamics(numberOfAtoms, 0.0f, temperature), _tau(tau), _accuracy(accuracy) { ReferenceDynamics(numberOfAtoms, 0.0f, temperature), _tau(tau), _accuracy(accuracy) {
if (tau <= 0) { if (tau <= 0) {
std::stringstream message; std::stringstream message;
...@@ -68,7 +68,7 @@ ReferenceVariableStochasticDynamics::ReferenceVariableStochasticDynamics( int nu ...@@ -68,7 +68,7 @@ ReferenceVariableStochasticDynamics::ReferenceVariableStochasticDynamics( int nu
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceVariableStochasticDynamics::~ReferenceVariableStochasticDynamics( ){ ReferenceVariableStochasticDynamics::~ReferenceVariableStochasticDynamics() {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -86,7 +86,7 @@ ReferenceVariableStochasticDynamics::~ReferenceVariableStochasticDynamics( ){ ...@@ -86,7 +86,7 @@ ReferenceVariableStochasticDynamics::~ReferenceVariableStochasticDynamics( ){
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ReferenceVariableStochasticDynamics::getAccuracy( void ) const { RealOpenMM ReferenceVariableStochasticDynamics::getAccuracy() const {
return _accuracy; return _accuracy;
} }
...@@ -96,7 +96,7 @@ RealOpenMM ReferenceVariableStochasticDynamics::getAccuracy( void ) const { ...@@ -96,7 +96,7 @@ RealOpenMM ReferenceVariableStochasticDynamics::getAccuracy( void ) const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ReferenceVariableStochasticDynamics::setAccuracy( RealOpenMM accuracy ) { void ReferenceVariableStochasticDynamics::setAccuracy(RealOpenMM accuracy) {
_accuracy = accuracy; _accuracy = accuracy;
} }
...@@ -108,7 +108,7 @@ void ReferenceVariableStochasticDynamics::setAccuracy( RealOpenMM accuracy ) { ...@@ -108,7 +108,7 @@ void ReferenceVariableStochasticDynamics::setAccuracy( RealOpenMM accuracy ) {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ReferenceVariableStochasticDynamics::getTau( void ) const { RealOpenMM ReferenceVariableStochasticDynamics::getTau() const {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -134,10 +134,10 @@ RealOpenMM ReferenceVariableStochasticDynamics::getTau( void ) const { ...@@ -134,10 +134,10 @@ RealOpenMM ReferenceVariableStochasticDynamics::getTau( void ) const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ReferenceVariableStochasticDynamics::updatePart1( int numberOfAtoms, vector<RealVec>& atomCoordinates, void ReferenceVariableStochasticDynamics::updatePart1(int numberOfAtoms, vector<RealVec>& atomCoordinates,
vector<RealVec>& velocities, vector<RealVec>& velocities,
vector<RealVec>& forces, vector<RealOpenMM>& masses, vector<RealOpenMM>& inverseMasses, vector<RealVec>& forces, vector<RealOpenMM>& masses, vector<RealOpenMM>& inverseMasses,
vector<RealVec>& xPrime, RealOpenMM maxStepSize ){ vector<RealVec>& xPrime, RealOpenMM maxStepSize) {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -148,10 +148,10 @@ void ReferenceVariableStochasticDynamics::updatePart1( int numberOfAtoms, vector ...@@ -148,10 +148,10 @@ void ReferenceVariableStochasticDynamics::updatePart1( int numberOfAtoms, vector
// first-time-through initialization // first-time-through initialization
if( getTimeStep() == 0 ){ if (getTimeStep() == 0) {
// invert masses // invert masses
for( int ii = 0; ii < numberOfAtoms; ii++ ){ for (int ii = 0; ii < numberOfAtoms; ii++) {
if (masses[ii] == 0) if (masses[ii] == 0)
inverseMasses[ii] = 0; inverseMasses[ii] = 0;
else else
...@@ -208,10 +208,10 @@ void ReferenceVariableStochasticDynamics::updatePart1( int numberOfAtoms, vector ...@@ -208,10 +208,10 @@ void ReferenceVariableStochasticDynamics::updatePart1( int numberOfAtoms, vector
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ReferenceVariableStochasticDynamics::updatePart2( int numberOfAtoms, vector<RealVec>& atomCoordinates, void ReferenceVariableStochasticDynamics::updatePart2(int numberOfAtoms, vector<RealVec>& atomCoordinates,
vector<RealVec>& velocities, vector<RealVec>& velocities,
vector<RealVec>& forces, vector<RealOpenMM>& inverseMasses, vector<RealVec>& forces, vector<RealOpenMM>& inverseMasses,
vector<RealVec>& xPrime ){ vector<RealVec>& xPrime) {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -255,11 +255,11 @@ void ReferenceVariableStochasticDynamics::update(const OpenMM::System& system, v ...@@ -255,11 +255,11 @@ void ReferenceVariableStochasticDynamics::update(const OpenMM::System& system, v
// 1st update // 1st update
int numberOfAtoms = system.getNumParticles(); int numberOfAtoms = system.getNumParticles();
updatePart1( numberOfAtoms, atomCoordinates, velocities, forces, masses, inverseMasses, xPrime, maxStepSize ); updatePart1(numberOfAtoms, atomCoordinates, velocities, forces, masses, inverseMasses, xPrime, maxStepSize);
// 2nd update // 2nd update
updatePart2( numberOfAtoms, atomCoordinates, velocities, forces, inverseMasses, xPrime ); updatePart2(numberOfAtoms, atomCoordinates, velocities, forces, inverseMasses, xPrime);
ReferenceConstraintAlgorithm* referenceConstraintAlgorithm = getReferenceConstraintAlgorithm(); ReferenceConstraintAlgorithm* referenceConstraintAlgorithm = getReferenceConstraintAlgorithm();
if (referenceConstraintAlgorithm) if (referenceConstraintAlgorithm)
...@@ -267,7 +267,7 @@ void ReferenceVariableStochasticDynamics::update(const OpenMM::System& system, v ...@@ -267,7 +267,7 @@ void ReferenceVariableStochasticDynamics::update(const OpenMM::System& system, v
// copy xPrime -> atomCoordinates // copy xPrime -> atomCoordinates
for( int ii = 0; ii < numberOfAtoms; ii++ ) { for (int ii = 0; ii < numberOfAtoms; ii++) {
if (masses[ii] != 0.0) { if (masses[ii] != 0.0) {
atomCoordinates[ii][0] = xPrime[ii][0]; atomCoordinates[ii][0] = xPrime[ii][0];
atomCoordinates[ii][1] = xPrime[ii][1]; atomCoordinates[ii][1] = xPrime[ii][1];
......
platforms/reference/src/SimTKReference/ReferenceVariableVerletDynamics.cpp
View file @ 7fb10336
...@@ -44,8 +44,8 @@ using namespace OpenMM; ...@@ -44,8 +44,8 @@ using namespace OpenMM;
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceVariableVerletDynamics::ReferenceVariableVerletDynamics( int numberOfAtoms, RealOpenMM accuracy ) : ReferenceVariableVerletDynamics::ReferenceVariableVerletDynamics(int numberOfAtoms, RealOpenMM accuracy) :
ReferenceDynamics( numberOfAtoms, 0.0f, 0.0f ), _accuracy(accuracy) { ReferenceDynamics(numberOfAtoms, 0.0f, 0.0f), _accuracy(accuracy) {
xPrime.resize(numberOfAtoms); xPrime.resize(numberOfAtoms);
inverseMasses.resize(numberOfAtoms); inverseMasses.resize(numberOfAtoms);
} }
...@@ -56,7 +56,7 @@ ReferenceVariableVerletDynamics::ReferenceVariableVerletDynamics( int numberOfAt ...@@ -56,7 +56,7 @@ ReferenceVariableVerletDynamics::ReferenceVariableVerletDynamics( int numberOfAt
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceVariableVerletDynamics::~ReferenceVariableVerletDynamics( ){ ReferenceVariableVerletDynamics::~ReferenceVariableVerletDynamics() {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -74,7 +74,7 @@ ReferenceVariableVerletDynamics::~ReferenceVariableVerletDynamics( ){ ...@@ -74,7 +74,7 @@ ReferenceVariableVerletDynamics::~ReferenceVariableVerletDynamics( ){
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ReferenceVariableVerletDynamics::getAccuracy( void ) const { RealOpenMM ReferenceVariableVerletDynamics::getAccuracy() const {
return _accuracy; return _accuracy;
} }
...@@ -84,7 +84,7 @@ RealOpenMM ReferenceVariableVerletDynamics::getAccuracy( void ) const { ...@@ -84,7 +84,7 @@ RealOpenMM ReferenceVariableVerletDynamics::getAccuracy( void ) const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ReferenceVariableVerletDynamics::setAccuracy( RealOpenMM accuracy ) { void ReferenceVariableVerletDynamics::setAccuracy(RealOpenMM accuracy) {
_accuracy = accuracy; _accuracy = accuracy;
} }
...@@ -118,10 +118,10 @@ void ReferenceVariableVerletDynamics::update(const OpenMM::System& system, vecto ...@@ -118,10 +118,10 @@ void ReferenceVariableVerletDynamics::update(const OpenMM::System& system, vecto
// first-time-through initialization // first-time-through initialization
int numberOfAtoms = system.getNumParticles(); int numberOfAtoms = system.getNumParticles();
if( getTimeStep() == 0 ){ if (getTimeStep() == 0) {
// invert masses // invert masses
for( int ii = 0; ii < numberOfAtoms; ii++ ){ for (int ii = 0; ii < numberOfAtoms; ii++) {
if (masses[ii] == zero) if (masses[ii] == zero)
inverseMasses[ii] = zero; inverseMasses[ii] = zero;
else else
......
platforms/reference/src/SimTKReference/ReferenceVerletDynamics.cpp
View file @ 7fb10336
...@@ -46,9 +46,8 @@ using namespace OpenMM; ...@@ -46,9 +46,8 @@ using namespace OpenMM;
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceVerletDynamics::ReferenceVerletDynamics( int numberOfAtoms, ReferenceVerletDynamics::ReferenceVerletDynamics(int numberOfAtoms, RealOpenMM deltaT) :
RealOpenMM deltaT ) : ReferenceDynamics(numberOfAtoms, deltaT, 0.0) {
ReferenceDynamics( numberOfAtoms, deltaT, 0.0 ) {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -69,7 +68,7 @@ ReferenceVerletDynamics::ReferenceVerletDynamics( int numberOfAtoms, ...@@ -69,7 +68,7 @@ ReferenceVerletDynamics::ReferenceVerletDynamics( int numberOfAtoms,
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceVerletDynamics::~ReferenceVerletDynamics( ){ ReferenceVerletDynamics::~ReferenceVerletDynamics() {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -108,10 +107,10 @@ void ReferenceVerletDynamics::update(const OpenMM::System& system, vector<RealVe ...@@ -108,10 +107,10 @@ void ReferenceVerletDynamics::update(const OpenMM::System& system, vector<RealVe
// first-time-through initialization // first-time-through initialization
int numberOfAtoms = system.getNumParticles(); int numberOfAtoms = system.getNumParticles();
if( getTimeStep() == 0 ){ if (getTimeStep() == 0) {
// invert masses // invert masses
for( int ii = 0; ii < numberOfAtoms; ii++ ){ for (int ii = 0; ii < numberOfAtoms; ii++) {
if (masses[ii] == zero) if (masses[ii] == zero)
inverseMasses[ii] = zero; inverseMasses[ii] = zero;
else else
...@@ -134,7 +133,7 @@ void ReferenceVerletDynamics::update(const OpenMM::System& system, vector<RealVe ...@@ -134,7 +133,7 @@ void ReferenceVerletDynamics::update(const OpenMM::System& system, vector<RealVe
// Update the positions and velocities. // Update the positions and velocities.
RealOpenMM velocityScale = static_cast<RealOpenMM>( 1.0/getDeltaT() ); RealOpenMM velocityScale = static_cast<RealOpenMM>(1.0/getDeltaT());
for (int i = 0; i < numberOfAtoms; ++i) { for (int i = 0; i < numberOfAtoms; ++i) {
if (masses[i] != zero) if (masses[i] != zero)
for (int j = 0; j < 3; ++j) { for (int j = 0; j < 3; ++j) {
......
platforms/reference/src/SimTKReference/fftpack.cpp
View file @ 7fb10336
...@@ -672,16 +672,16 @@ fftpack_transpose_2d(t_complex * in_data, ...@@ -672,16 +672,16 @@ fftpack_transpose_2d(t_complex * in_data,
t_complex * src; t_complex * src;
int i,j; int i,j;
if(nx<2 || ny<2) if (nx<2 || ny<2)
{ {
if(in_data != out_data) if (in_data != out_data)
{ {
memcpy(out_data,in_data,sizeof(t_complex)*nx*ny); memcpy(out_data,in_data,sizeof(t_complex)*nx*ny);
} }
return 0; return 0;
} }
if(in_data == out_data) if (in_data == out_data)
{ {
src = (t_complex *)malloc(sizeof(t_complex)*nx*ny); src = (t_complex *)malloc(sizeof(t_complex)*nx*ny);
memcpy(src,in_data,sizeof(t_complex)*nx*ny); memcpy(src,in_data,sizeof(t_complex)*nx*ny);
...@@ -691,16 +691,16 @@ fftpack_transpose_2d(t_complex * in_data, ...@@ -691,16 +691,16 @@ fftpack_transpose_2d(t_complex * in_data,
src = in_data; src = in_data;
} }
for(i=0;i<nx;i++) for (i=0;i<nx;i++)
{ {
for(j=0;j<ny;j++) for (j=0;j<ny;j++)
{ {
out_data[j*nx+i].re = src[i*ny+j].re; out_data[j*nx+i].re = src[i*ny+j].re;
out_data[j*nx+i].im = src[i*ny+j].im; out_data[j*nx+i].im = src[i*ny+j].im;
} }
} }
if(src != in_data) if (src != in_data)
{ {
free(src); free(src);
} }
...@@ -722,16 +722,16 @@ fftpack_transpose_2d_nelem(t_complex * in_data, ...@@ -722,16 +722,16 @@ fftpack_transpose_2d_nelem(t_complex * in_data,
ncopy = nelem*sizeof(t_complex); ncopy = nelem*sizeof(t_complex);
if(nx<2 || ny<2) if (nx<2 || ny<2)
{ {
if(in_data != out_data) if (in_data != out_data)
{ {
memcpy(out_data,in_data,nx*ny*ncopy); memcpy(out_data,in_data,nx*ny*ncopy);
} }
return 0; return 0;
} }
if(in_data == out_data) if (in_data == out_data)
{ {
src = (t_complex *)malloc(nx*ny*ncopy); src = (t_complex *)malloc(nx*ny*ncopy);
memcpy(src,in_data,nx*ny*ncopy); memcpy(src,in_data,nx*ny*ncopy);
...@@ -741,15 +741,15 @@ fftpack_transpose_2d_nelem(t_complex * in_data, ...@@ -741,15 +741,15 @@ fftpack_transpose_2d_nelem(t_complex * in_data,
src = in_data; src = in_data;
} }
for(i=0;i<nx;i++) for (i=0;i<nx;i++)
{ {
for(j=0;j<ny;j++) for (j=0;j<ny;j++)
{ {
memcpy(out_data + (j*nx+i)*nelem , src + (i*ny+j)*nelem , ncopy); memcpy(out_data + (j*nx+i)*nelem , src + (i*ny+j)*nelem , ncopy);
} }
} }
if(src != in_data) if (src != in_data)
{ {
free(src); free(src);
} }
...@@ -767,14 +767,14 @@ fftpack_init_1d(fftpack_t * pfft, ...@@ -767,14 +767,14 @@ fftpack_init_1d(fftpack_t * pfft,
{ {
fftpack_t fft; fftpack_t fft;
if(pfft==NULL) if (pfft==NULL)
{ {
fprintf(stderr,"Fatal error - Invalid FFT opaque type pointer."); fprintf(stderr,"Fatal error - Invalid FFT opaque type pointer.");
return EINVAL; return EINVAL;
} }
*pfft = NULL; *pfft = NULL;
if( (fft = (struct fftpack *)malloc(sizeof(struct fftpack))) == NULL) if ((fft = (struct fftpack *)malloc(sizeof(struct fftpack))) == NULL)
{ {
return ENOMEM; return ENOMEM;
} }
...@@ -783,13 +783,13 @@ fftpack_init_1d(fftpack_t * pfft, ...@@ -783,13 +783,13 @@ fftpack_init_1d(fftpack_t * pfft,
fft->n = nx; fft->n = nx;
/* Need 4*n storage for 1D complex FFT */ /* Need 4*n storage for 1D complex FFT */
if( (fft->work = (RealOpenMM *)malloc(sizeof(RealOpenMM)*(4*nx))) == NULL) if ((fft->work = (RealOpenMM *)malloc(sizeof(RealOpenMM)*(4*nx))) == NULL)
{ {
free(fft); free(fft);
return ENOMEM; return ENOMEM;
} }
if(fft->n>1) if (fft->n>1)
fftpack_cffti1(nx,fft->work,fft->ifac); fftpack_cffti1(nx,fft->work,fft->ifac);
*pfft = fft; *pfft = fft;
...@@ -807,7 +807,7 @@ fftpack_init_2d(fftpack_t * pfft, ...@@ -807,7 +807,7 @@ fftpack_init_2d(fftpack_t * pfft,
fftpack_t fft; fftpack_t fft;
int rc; int rc;
if(pfft==NULL) if (pfft==NULL)
{ {
fprintf(stderr,"Fatal error - Invalid FFT opaque type pointer."); fprintf(stderr,"Fatal error - Invalid FFT opaque type pointer.");
return EINVAL; return EINVAL;
...@@ -815,13 +815,13 @@ fftpack_init_2d(fftpack_t * pfft, ...@@ -815,13 +815,13 @@ fftpack_init_2d(fftpack_t * pfft,
*pfft = NULL; *pfft = NULL;
/* Create the X transform */ /* Create the X transform */
if( (rc = fftpack_init_1d(&fft,nx)) != 0) if ((rc = fftpack_init_1d(&fft,nx)) != 0)
{ {
return rc; return rc;
} }
/* Create Y transform as a link from X */ /* Create Y transform as a link from X */
if( (rc=fftpack_init_1d(&(fft->next),ny)) != 0) if ((rc=fftpack_init_1d(&(fft->next),ny)) != 0)
{ {
free(fft); free(fft);
return rc; return rc;
...@@ -842,7 +842,7 @@ fftpack_init_3d(fftpack_t * pfft, ...@@ -842,7 +842,7 @@ fftpack_init_3d(fftpack_t * pfft,
fftpack_t fft; fftpack_t fft;
int rc; int rc;
if(pfft==NULL) if (pfft==NULL)
{ {
fprintf(stderr,"Fatal error - Invalid FFT opaque type pointer."); fprintf(stderr,"Fatal error - Invalid FFT opaque type pointer.");
return EINVAL; return EINVAL;
...@@ -851,7 +851,7 @@ fftpack_init_3d(fftpack_t * pfft, ...@@ -851,7 +851,7 @@ fftpack_init_3d(fftpack_t * pfft,
/* Create the X transform */ /* Create the X transform */
if( (fft = (struct fftpack *)malloc(sizeof(struct fftpack))) == NULL) if ((fft = (struct fftpack *)malloc(sizeof(struct fftpack))) == NULL)
{ {
return ENOMEM; return ENOMEM;
} }
...@@ -860,7 +860,7 @@ fftpack_init_3d(fftpack_t * pfft, ...@@ -860,7 +860,7 @@ fftpack_init_3d(fftpack_t * pfft,
/* Need 4*nx storage for 1D complex FFT. /* Need 4*nx storage for 1D complex FFT.
*/ */
if( (fft->work = (RealOpenMM *)malloc(sizeof(RealOpenMM)*(4*nx))) == NULL) if ((fft->work = (RealOpenMM *)malloc(sizeof(RealOpenMM)*(4*nx))) == NULL)
{ {
free(fft); free(fft);
return ENOMEM; return ENOMEM;
...@@ -869,7 +869,7 @@ fftpack_init_3d(fftpack_t * pfft, ...@@ -869,7 +869,7 @@ fftpack_init_3d(fftpack_t * pfft,
fftpack_cffti1(nx,fft->work,fft->ifac); fftpack_cffti1(nx,fft->work,fft->ifac);
/* Create 2D Y/Z transforms as a link from X */ /* Create 2D Y/Z transforms as a link from X */
if( (rc=fftpack_init_2d(&(fft->next),ny,nz)) != 0) if ((rc=fftpack_init_2d(&(fft->next),ny,nz)) != 0)
{ {
free(fft); free(fft);
return rc; return rc;
...@@ -893,7 +893,7 @@ fftpack_exec_1d (fftpack_t fft, ...@@ -893,7 +893,7 @@ fftpack_exec_1d (fftpack_t fft,
n=fft->n; n=fft->n;
if(n==1) if (n==1)
{ {
p1 = (RealOpenMM *)in_data; p1 = (RealOpenMM *)in_data;
p2 = (RealOpenMM *)out_data; p2 = (RealOpenMM *)out_data;
...@@ -904,13 +904,13 @@ fftpack_exec_1d (fftpack_t fft, ...@@ -904,13 +904,13 @@ fftpack_exec_1d (fftpack_t fft,
/* FFTPACK only does in-place transforms, so emulate out-of-place /* FFTPACK only does in-place transforms, so emulate out-of-place
* by copying data to the output array first. * by copying data to the output array first.
*/ */
if( in_data != out_data ) if (in_data != out_data)
{ {
p1 = (RealOpenMM *)in_data; p1 = (RealOpenMM *)in_data;
p2 = (RealOpenMM *)out_data; p2 = (RealOpenMM *)out_data;
/* n complex = 2*n RealOpenMM elements */ /* n complex = 2*n RealOpenMM elements */
for(i=0;i<2*n;i++) for (i=0;i<2*n;i++)
{ {
p2[i] = p1[i]; p2[i] = p1[i];
} }
...@@ -920,11 +920,11 @@ fftpack_exec_1d (fftpack_t fft, ...@@ -920,11 +920,11 @@ fftpack_exec_1d (fftpack_t fft,
* Elements 2*n .. 4*n-1 are internal FFTPACK work space. * Elements 2*n .. 4*n-1 are internal FFTPACK work space.
*/ */
if(dir == FFTPACK_FORWARD) if (dir == FFTPACK_FORWARD)
{ {
fftpack_cfftf1(n,(RealOpenMM *)out_data,fft->work+2*n,fft->work,fft->ifac, -1); fftpack_cfftf1(n,(RealOpenMM *)out_data,fft->work+2*n,fft->work,fft->ifac, -1);
} }
else if(dir == FFTPACK_BACKWARD) else if (dir == FFTPACK_BACKWARD)
{ {
fftpack_cfftf1(n,(RealOpenMM *)out_data,fft->work+2*n,fft->work,fft->ifac, 1); fftpack_cfftf1(n,(RealOpenMM *)out_data,fft->work+2*n,fft->work,fft->ifac, 1);
} }
...@@ -957,7 +957,7 @@ fftpack_exec_2d (fftpack_t fft, ...@@ -957,7 +957,7 @@ fftpack_exec_2d (fftpack_t fft,
* by copying data to the output array first. * by copying data to the output array first.
* For 2D there is likely enough data to benefit from memcpy(). * For 2D there is likely enough data to benefit from memcpy().
*/ */
if( in_data != out_data ) if (in_data != out_data)
{ {
memcpy(out_data,in_data,sizeof(t_complex)*nx*ny); memcpy(out_data,in_data,sizeof(t_complex)*nx*ny);
} }
...@@ -966,7 +966,7 @@ fftpack_exec_2d (fftpack_t fft, ...@@ -966,7 +966,7 @@ fftpack_exec_2d (fftpack_t fft,
data = (t_complex *)out_data; data = (t_complex *)out_data;
/* y transforms */ /* y transforms */
for(i=0;i<nx;i++) for (i=0;i<nx;i++)
{ {
fftpack_exec_1d(fft->next,dir,data+i*ny,data+i*ny); fftpack_exec_1d(fft->next,dir,data+i*ny,data+i*ny);
} }
...@@ -975,7 +975,7 @@ fftpack_exec_2d (fftpack_t fft, ...@@ -975,7 +975,7 @@ fftpack_exec_2d (fftpack_t fft,
fftpack_transpose_2d(data,data,nx,ny); fftpack_transpose_2d(data,data,nx,ny);
/* x transforms */ /* x transforms */
for(i=0;i<ny;i++) for (i=0;i<ny;i++)
{ {
fftpack_exec_1d(fft,dir,data+i*nx,data+i*nx); fftpack_exec_1d(fft,dir,data+i*nx,data+i*nx);
} }
...@@ -1007,7 +1007,7 @@ fftpack_exec_3d (fftpack_t fft, ...@@ -1007,7 +1007,7 @@ fftpack_exec_3d (fftpack_t fft,
* by copying data to the output array first. * by copying data to the output array first.
* For 3D there is likely enough data to benefit from memcpy(). * For 3D there is likely enough data to benefit from memcpy().
*/ */
if( in_data != out_data ) if (in_data != out_data)
{ {
memcpy(out_data,in_data,sizeof(t_complex)*nx*ny*nz); memcpy(out_data,in_data,sizeof(t_complex)*nx*ny*nz);
} }
...@@ -1016,23 +1016,23 @@ fftpack_exec_3d (fftpack_t fft, ...@@ -1016,23 +1016,23 @@ fftpack_exec_3d (fftpack_t fft,
data = (t_complex *)out_data; data = (t_complex *)out_data;
/* Perform z transforms */ /* Perform z transforms */
for(i=0;i<nx*ny;i++) for (i=0;i<nx*ny;i++)
fftpack_exec_1d(fft->next->next,dir,data+i*nz,data+i*nz); fftpack_exec_1d(fft->next->next,dir,data+i*nz,data+i*nz);
/* For each X slice, transpose the y & z dimensions inside the slice */ /* For each X slice, transpose the y & z dimensions inside the slice */
for(i=0;i<nx;i++) for (i=0;i<nx;i++)
{ {
fftpack_transpose_2d(data+i*ny*nz,data+i*ny*nz,ny,nz); fftpack_transpose_2d(data+i*ny*nz,data+i*ny*nz,ny,nz);
} }
/* Array is now (nx,nz,ny) - perform y transforms */ /* Array is now (nx,nz,ny) - perform y transforms */
for(i=0;i<nx*nz;i++) for (i=0;i<nx*nz;i++)
{ {
fftpack_exec_1d(fft->next,dir,data+i*ny,data+i*ny); fftpack_exec_1d(fft->next,dir,data+i*ny,data+i*ny);
} }
/* Transpose back to (nx,ny,nz) */ /* Transpose back to (nx,ny,nz) */
for(i=0;i<nx;i++) for (i=0;i<nx;i++)
{ {
fftpack_transpose_2d(data+i*ny*nz,data+i*ny*nz,nz,ny); fftpack_transpose_2d(data+i*ny*nz,data+i*ny*nz,nz,ny);
} }
...@@ -1041,26 +1041,26 @@ fftpack_exec_3d (fftpack_t fft, ...@@ -1041,26 +1041,26 @@ fftpack_exec_3d (fftpack_t fft,
* (nx,ny,nz) to (ny,nx,nz). * (nx,ny,nz) to (ny,nx,nz).
*/ */
rc=fftpack_transpose_2d_nelem(data,data,nx,ny,nz); rc=fftpack_transpose_2d_nelem(data,data,nx,ny,nz);
if( rc != 0) if (rc != 0)
{ {
fprintf(stderr,"Fatal error - cannot transpose X & Y/Z in fftpack_exec_3d()."); fprintf(stderr,"Fatal error - cannot transpose X & Y/Z in fftpack_exec_3d().");
return rc; return rc;
} }
/* Then go from (ny,nx,nz) to (ny,nz,nx) */ /* Then go from (ny,nx,nz) to (ny,nz,nx) */
for(i=0;i<ny;i++) for (i=0;i<ny;i++)
{ {
fftpack_transpose_2d(data+i*nx*nz,data+i*nx*nz,nx,nz); fftpack_transpose_2d(data+i*nx*nz,data+i*nx*nz,nx,nz);
} }
/* Perform x transforms */ /* Perform x transforms */
for(i=0;i<ny*nz;i++) for (i=0;i<ny*nz;i++)
{ {
fftpack_exec_1d(fft,dir,data+i*nx,data+i*nx); fftpack_exec_1d(fft,dir,data+i*nx,data+i*nx);
} }
/* Transpose back from (ny,nz,nx) to (ny,nx,nz) */ /* Transpose back from (ny,nz,nx) to (ny,nx,nz) */
for(i=0;i<ny;i++) for (i=0;i<ny;i++)
{ {
fftpack_transpose_2d(data+i*nz*nx,data+i*nz*nx,nz,nx); fftpack_transpose_2d(data+i*nz*nx,data+i*nz*nx,nz,nx);
} }
...@@ -1068,7 +1068,7 @@ fftpack_exec_3d (fftpack_t fft, ...@@ -1068,7 +1068,7 @@ fftpack_exec_3d (fftpack_t fft,
/* Transpose from (ny,nx,nz) to (nx,ny,nz). /* Transpose from (ny,nx,nz) to (nx,ny,nz).
*/ */
rc = fftpack_transpose_2d_nelem(data,data,ny,nx,nz); rc = fftpack_transpose_2d_nelem(data,data,ny,nx,nz);
if( rc != 0) if (rc != 0)
{ {
fprintf(stderr,"Fatal error - cannot transpose Y/Z & X in fftpack_exec_3d()."); fprintf(stderr,"Fatal error - cannot transpose Y/Z & X in fftpack_exec_3d().");
return rc; return rc;
...@@ -1082,10 +1082,10 @@ fftpack_exec_3d (fftpack_t fft, ...@@ -1082,10 +1082,10 @@ fftpack_exec_3d (fftpack_t fft,
void void
fftpack_destroy(fftpack_t fft) fftpack_destroy(fftpack_t fft)
{ {
if(fft != NULL) if (fft != NULL)
{ {
free(fft->work); free(fft->work);
if(fft->next != NULL) if (fft->next != NULL)
fftpack_destroy(fft->next); fftpack_destroy(fft->next);
free(fft); free(fft);
} }
......
platforms/reference/src/SimTKUtilities/SimTKOpenMMCommon.cpp
View file @ 7fb10336
...@@ -30,9 +30,9 @@ using namespace OpenMM; ...@@ -30,9 +30,9 @@ using namespace OpenMM;
// initialization of static data members // initialization of static data members
const std::string SimTKOpenMMCommon::NotSet = std::string( "NotSet" ); const std::string SimTKOpenMMCommon::NotSet = std::string("NotSet");
const std::string SimTKOpenMMCommon::Comment = std::string( "#" ); const std::string SimTKOpenMMCommon::Comment = std::string("#");
const std::string SimTKOpenMMCommon::Tab = std::string( "\t" ); const std::string SimTKOpenMMCommon::Tab = std::string("\t");
const int SimTKOpenMMCommon::DefaultReturn = 0; const int SimTKOpenMMCommon::DefaultReturn = 0;
const int SimTKOpenMMCommon::ErrorReturn = -1; const int SimTKOpenMMCommon::ErrorReturn = -1;
......
platforms/reference/src/SimTKUtilities/SimTKOpenMMUtilities.cpp
View file @ 7fb10336
...@@ -59,9 +59,9 @@ OpenMM_SFMT::SFMT SimTKOpenMMUtilities::sfmt; ...@@ -59,9 +59,9 @@ OpenMM_SFMT::SFMT SimTKOpenMMUtilities::sfmt;
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM* SimTKOpenMMUtilities::allocateOneDRealOpenMMArray( int iSize, RealOpenMM* array1D, RealOpenMM* SimTKOpenMMUtilities::allocateOneDRealOpenMMArray(int iSize, RealOpenMM* array1D,
int initialize, RealOpenMM initialValue, int initialize, RealOpenMM initialValue,
const std::string& idString ){ const std::string& idString) {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -71,17 +71,17 @@ RealOpenMM* SimTKOpenMMUtilities::allocateOneDRealOpenMMArray( int iSize, RealOp ...@@ -71,17 +71,17 @@ RealOpenMM* SimTKOpenMMUtilities::allocateOneDRealOpenMMArray( int iSize, RealOp
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
if( array1D == NULL ){ if (array1D == NULL) {
array1D = new RealOpenMM[iSize]; array1D = new RealOpenMM[iSize];
} }
if( initialize ){ if (initialize) {
if( initialValue == zero ){ if (initialValue == zero) {
memset( array1D, 0, iSize*sizeof( RealOpenMM ) ); memset(array1D, 0, iSize*sizeof(RealOpenMM));
} else { } else {
for( int ii = 0; ii < iSize; ii++ ){ for (int ii = 0; ii < iSize; ii++) {
array1D[ii] = initialValue; array1D[ii] = initialValue;
} }
} }
...@@ -107,9 +107,9 @@ RealOpenMM* SimTKOpenMMUtilities::allocateOneDRealOpenMMArray( int iSize, RealOp ...@@ -107,9 +107,9 @@ RealOpenMM* SimTKOpenMMUtilities::allocateOneDRealOpenMMArray( int iSize, RealOp
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM** SimTKOpenMMUtilities::allocateTwoDRealOpenMMArray( int iSize, int jSize, RealOpenMM** array2D, RealOpenMM** SimTKOpenMMUtilities::allocateTwoDRealOpenMMArray(int iSize, int jSize, RealOpenMM** array2D,
int initialize, RealOpenMM initialValue, int initialize, RealOpenMM initialValue,
const std::string& idString ){ const std::string& idString) {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -117,22 +117,22 @@ RealOpenMM** SimTKOpenMMUtilities::allocateTwoDRealOpenMMArray( int iSize, int j ...@@ -117,22 +117,22 @@ RealOpenMM** SimTKOpenMMUtilities::allocateTwoDRealOpenMMArray( int iSize, int j
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
if( array2D == NULL ){ if (array2D == NULL) {
array2D = new RealOpenMM*[iSize]; array2D = new RealOpenMM*[iSize];
std::string blockString = idString; std::string blockString = idString;
blockString.append( "Block" ); blockString.append("Block");
RealOpenMM* block = new RealOpenMM[jSize*iSize]; RealOpenMM* block = new RealOpenMM[jSize*iSize];
for( int ii = 0; ii < iSize; ii++ ){ for (int ii = 0; ii < iSize; ii++) {
array2D[ii] = block; array2D[ii] = block;
block += jSize; block += jSize;
} }
} }
if( initialize ){ if (initialize) {
initialize2DRealOpenMMArray( iSize, jSize, array2D, initialValue ); initialize2DRealOpenMMArray(iSize, jSize, array2D, initialValue);
} }
return array2D; return array2D;
...@@ -149,7 +149,7 @@ RealOpenMM** SimTKOpenMMUtilities::allocateTwoDRealOpenMMArray( int iSize, int j ...@@ -149,7 +149,7 @@ RealOpenMM** SimTKOpenMMUtilities::allocateTwoDRealOpenMMArray( int iSize, int j
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void SimTKOpenMMUtilities::freeTwoDRealOpenMMArray( RealOpenMM** array2D, const std::string& idString ){ void SimTKOpenMMUtilities::freeTwoDRealOpenMMArray(RealOpenMM** array2D, const std::string& idString) {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -157,10 +157,10 @@ void SimTKOpenMMUtilities::freeTwoDRealOpenMMArray( RealOpenMM** array2D, const ...@@ -157,10 +157,10 @@ void SimTKOpenMMUtilities::freeTwoDRealOpenMMArray( RealOpenMM** array2D, const
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
if( array2D != NULL ){ if (array2D != NULL) {
std::string blockString = idString; std::string blockString = idString;
blockString.append( "Block" ); blockString.append("Block");
delete[] array2D[0]; delete[] array2D[0];
delete[] array2D; delete[] array2D;
...@@ -178,7 +178,7 @@ void SimTKOpenMMUtilities::freeTwoDRealOpenMMArray( RealOpenMM** array2D, const ...@@ -178,7 +178,7 @@ void SimTKOpenMMUtilities::freeTwoDRealOpenMMArray( RealOpenMM** array2D, const
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void SimTKOpenMMUtilities::freeOneDRealOpenMMArray( RealOpenMM* array1D, const std::string& idString ){ void SimTKOpenMMUtilities::freeOneDRealOpenMMArray(RealOpenMM* array1D, const std::string& idString) {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -186,7 +186,7 @@ void SimTKOpenMMUtilities::freeOneDRealOpenMMArray( RealOpenMM* array1D, const s ...@@ -186,7 +186,7 @@ void SimTKOpenMMUtilities::freeOneDRealOpenMMArray( RealOpenMM* array1D, const s
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
if( array1D != NULL ){ if (array1D != NULL) {
delete[] array1D; delete[] array1D;
} }
} }
...@@ -204,9 +204,9 @@ void SimTKOpenMMUtilities::freeOneDRealOpenMMArray( RealOpenMM* array1D, const s ...@@ -204,9 +204,9 @@ void SimTKOpenMMUtilities::freeOneDRealOpenMMArray( RealOpenMM* array1D, const s
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void SimTKOpenMMUtilities::initialize2DRealOpenMMArray( int iSize, int jSize, void SimTKOpenMMUtilities::initialize2DRealOpenMMArray(int iSize, int jSize,
RealOpenMM** array2D, RealOpenMM** array2D,
RealOpenMM initialValue ){ RealOpenMM initialValue) {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -217,9 +217,9 @@ void SimTKOpenMMUtilities::initialize2DRealOpenMMArray( int iSize, int jSize, ...@@ -217,9 +217,9 @@ void SimTKOpenMMUtilities::initialize2DRealOpenMMArray( int iSize, int jSize,
bool useMemset; bool useMemset;
bool useMemsetSingleBlock; bool useMemsetSingleBlock;
if( initialValue == 0.0f ){ if (initialValue == 0.0f) {
useMemset = true; useMemset = true;
if( jSize > 1 && (array2D[0] + jSize) == array2D[1] ){ if (jSize > 1 && (array2D[0] + jSize) == array2D[1]) {
useMemsetSingleBlock = true; useMemsetSingleBlock = true;
} else { } else {
useMemsetSingleBlock = false; useMemsetSingleBlock = false;
...@@ -229,17 +229,17 @@ void SimTKOpenMMUtilities::initialize2DRealOpenMMArray( int iSize, int jSize, ...@@ -229,17 +229,17 @@ void SimTKOpenMMUtilities::initialize2DRealOpenMMArray( int iSize, int jSize,
useMemset = false; useMemset = false;
} }
if( useMemset ){ if (useMemset) {
if( useMemsetSingleBlock ){ if (useMemsetSingleBlock) {
memset( array2D[0], 0, iSize*jSize*sizeof( RealOpenMM ) ); memset(array2D[0], 0, iSize*jSize*sizeof(RealOpenMM));
} else { } else {
for( int ii = 0; ii < iSize; ii++ ){ for (int ii = 0; ii < iSize; ii++) {
memset( array2D[ii], 0, jSize*sizeof( RealOpenMM ) ); memset(array2D[ii], 0, jSize*sizeof(RealOpenMM));
} }
} }
} else { } else {
for( int ii = 0; ii < iSize; ii++ ){ for (int ii = 0; ii < iSize; ii++) {
for( int jj = 0; jj < jSize; jj++ ){ for (int jj = 0; jj < jSize; jj++) {
array2D[ii][jj] = initialValue; array2D[ii][jj] = initialValue;
} }
} }
...@@ -260,9 +260,9 @@ void SimTKOpenMMUtilities::initialize2DRealOpenMMArray( int iSize, int jSize, ...@@ -260,9 +260,9 @@ void SimTKOpenMMUtilities::initialize2DRealOpenMMArray( int iSize, int jSize,
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void SimTKOpenMMUtilities::crossProductVector3( RealOpenMM* vectorX, void SimTKOpenMMUtilities::crossProductVector3(RealOpenMM* vectorX,
RealOpenMM* vectorY, RealOpenMM* vectorY,
RealOpenMM* vectorZ ){ RealOpenMM* vectorZ) {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -285,7 +285,7 @@ void SimTKOpenMMUtilities::crossProductVector3( RealOpenMM* vectorX, ...@@ -285,7 +285,7 @@ void SimTKOpenMMUtilities::crossProductVector3( RealOpenMM* vectorX,
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM SimTKOpenMMUtilities::getNormallyDistributedRandomNumber( void ) { RealOpenMM SimTKOpenMMUtilities::getNormallyDistributedRandomNumber() {
if (nextGaussianIsValid) { if (nextGaussianIsValid) {
nextGaussianIsValid = false; nextGaussianIsValid = false;
return nextGaussian; return nextGaussian;
...@@ -304,7 +304,7 @@ RealOpenMM SimTKOpenMMUtilities::getNormallyDistributedRandomNumber( void ) { ...@@ -304,7 +304,7 @@ RealOpenMM SimTKOpenMMUtilities::getNormallyDistributedRandomNumber( void ) {
y = static_cast<RealOpenMM>(2.0 * genrand_real2(sfmt) - 1.0); y = static_cast<RealOpenMM>(2.0 * genrand_real2(sfmt) - 1.0);
r2 = x*x + y*y; r2 = x*x + y*y;
} while (r2 >= 1.0 || r2 == 0.0); } while (r2 >= 1.0 || r2 == 0.0);
RealOpenMM multiplier = static_cast<RealOpenMM>( sqrt((-2.0*log(r2))/r2) ); RealOpenMM multiplier = static_cast<RealOpenMM>(sqrt((-2.0*log(r2))/r2));
nextGaussian = y*multiplier; nextGaussian = y*multiplier;
nextGaussianIsValid = true; nextGaussianIsValid = true;
return x*multiplier; return x*multiplier;
...@@ -318,13 +318,13 @@ RealOpenMM SimTKOpenMMUtilities::getNormallyDistributedRandomNumber( void ) { ...@@ -318,13 +318,13 @@ RealOpenMM SimTKOpenMMUtilities::getNormallyDistributedRandomNumber( void ) {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM SimTKOpenMMUtilities::getUniformlyDistributedRandomNumber( void ) { RealOpenMM SimTKOpenMMUtilities::getUniformlyDistributedRandomNumber() {
if (!_randomInitialized) { if (!_randomInitialized) {
init_gen_rand(_randomNumberSeed, sfmt); init_gen_rand(_randomNumberSeed, sfmt);
_randomInitialized = true; _randomInitialized = true;
nextGaussianIsValid = false; nextGaussianIsValid = false;
} }
RealOpenMM value = static_cast<RealOpenMM>( genrand_real2(sfmt) ); RealOpenMM value = static_cast<RealOpenMM>(genrand_real2(sfmt));
return value; return value;
} }
...@@ -336,7 +336,7 @@ RealOpenMM SimTKOpenMMUtilities::getUniformlyDistributedRandomNumber( void ) { ...@@ -336,7 +336,7 @@ RealOpenMM SimTKOpenMMUtilities::getUniformlyDistributedRandomNumber( void ) {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
uint32_t SimTKOpenMMUtilities::getRandomNumberSeed( void ) { uint32_t SimTKOpenMMUtilities::getRandomNumberSeed() {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -355,7 +355,7 @@ uint32_t SimTKOpenMMUtilities::getRandomNumberSeed( void ) { ...@@ -355,7 +355,7 @@ uint32_t SimTKOpenMMUtilities::getRandomNumberSeed( void ) {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void SimTKOpenMMUtilities::setRandomNumberSeed( uint32_t seed ) { void SimTKOpenMMUtilities::setRandomNumberSeed(uint32_t seed) {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
......
platforms/reference/src/gbsa/CpuGBVI.cpp
View file @ 7fb10336
This diff is collapsed.
platforms/reference/src/gbsa/CpuObc.cpp
View file @ 7fb10336
This diff is collapsed.
platforms/reference/src/gbsa/GBVIParameters.cpp
View file @ 7fb10336
...@@ -41,19 +41,19 @@ using namespace OpenMM; ...@@ -41,19 +41,19 @@ using namespace OpenMM;
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
GBVIParameters::GBVIParameters( int numberOfAtoms ) : _numberOfAtoms(numberOfAtoms), GBVIParameters::GBVIParameters(int numberOfAtoms) : _numberOfAtoms(numberOfAtoms),
_soluteDielectric(1.0), _soluteDielectric(1.0),
_solventDielectric(78.3), _solventDielectric(78.3),
_electricConstant(-0.5*ONE_4PI_EPS0), _electricConstant(-0.5*ONE_4PI_EPS0),
_cutoff(false), _cutoff(false),
_periodic(false), _periodic(false),
_bornRadiusScalingMethod(0), _bornRadiusScalingMethod(0),
_quinticLowerLimitFactor(0.8), _quinticLowerLimitFactor(0.8),
_quinticUpperBornRadiusLimit(5.0) { _quinticUpperBornRadiusLimit(5.0) {
_atomicRadii.resize( numberOfAtoms ); _atomicRadii.resize(numberOfAtoms);
_scaledRadii.resize( numberOfAtoms ); _scaledRadii.resize(numberOfAtoms);
_gammaParameters.resize( numberOfAtoms ); _gammaParameters.resize(numberOfAtoms);
} }
...@@ -63,7 +63,7 @@ GBVIParameters::GBVIParameters( int numberOfAtoms ) : _numberOfAtoms(numberOfAto ...@@ -63,7 +63,7 @@ GBVIParameters::GBVIParameters( int numberOfAtoms ) : _numberOfAtoms(numberOfAto
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
GBVIParameters::~GBVIParameters( ){ GBVIParameters::~GBVIParameters() {
} }
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -74,7 +74,7 @@ GBVIParameters::~GBVIParameters( ){ ...@@ -74,7 +74,7 @@ GBVIParameters::~GBVIParameters( ){
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
int GBVIParameters::getNumberOfAtoms( void ) const { int GBVIParameters::getNumberOfAtoms() const {
return _numberOfAtoms; return _numberOfAtoms;
} }
...@@ -86,7 +86,7 @@ int GBVIParameters::getNumberOfAtoms( void ) const { ...@@ -86,7 +86,7 @@ int GBVIParameters::getNumberOfAtoms( void ) const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM GBVIParameters::getElectricConstant( void ) const { RealOpenMM GBVIParameters::getElectricConstant() const {
return _electricConstant; return _electricConstant;
} }
...@@ -98,7 +98,7 @@ RealOpenMM GBVIParameters::getElectricConstant( void ) const { ...@@ -98,7 +98,7 @@ RealOpenMM GBVIParameters::getElectricConstant( void ) const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM GBVIParameters::getSolventDielectric( void ) const { RealOpenMM GBVIParameters::getSolventDielectric() const {
return _solventDielectric; return _solventDielectric;
} }
...@@ -110,7 +110,7 @@ RealOpenMM GBVIParameters::getSolventDielectric( void ) const { ...@@ -110,7 +110,7 @@ RealOpenMM GBVIParameters::getSolventDielectric( void ) const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void GBVIParameters::setSolventDielectric( RealOpenMM solventDielectric ){ void GBVIParameters::setSolventDielectric(RealOpenMM solventDielectric) {
_solventDielectric = solventDielectric; _solventDielectric = solventDielectric;
} }
...@@ -122,7 +122,7 @@ void GBVIParameters::setSolventDielectric( RealOpenMM solventDielectric ){ ...@@ -122,7 +122,7 @@ void GBVIParameters::setSolventDielectric( RealOpenMM solventDielectric ){
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM GBVIParameters::getSoluteDielectric( void ) const { RealOpenMM GBVIParameters::getSoluteDielectric() const {
return _soluteDielectric; return _soluteDielectric;
} }
...@@ -134,7 +134,7 @@ RealOpenMM GBVIParameters::getSoluteDielectric( void ) const { ...@@ -134,7 +134,7 @@ RealOpenMM GBVIParameters::getSoluteDielectric( void ) const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void GBVIParameters::setSoluteDielectric( RealOpenMM soluteDielectric ){ void GBVIParameters::setSoluteDielectric(RealOpenMM soluteDielectric) {
_soluteDielectric = soluteDielectric; _soluteDielectric = soluteDielectric;
} }
...@@ -146,7 +146,7 @@ void GBVIParameters::setSoluteDielectric( RealOpenMM soluteDielectric ){ ...@@ -146,7 +146,7 @@ void GBVIParameters::setSoluteDielectric( RealOpenMM soluteDielectric ){
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
const RealOpenMMVector& GBVIParameters::getAtomicRadii( void ) const { const RealOpenMMVector& GBVIParameters::getAtomicRadii() const {
return _atomicRadii; return _atomicRadii;
} }
...@@ -158,10 +158,10 @@ const RealOpenMMVector& GBVIParameters::getAtomicRadii( void ) const { ...@@ -158,10 +158,10 @@ const RealOpenMMVector& GBVIParameters::getAtomicRadii( void ) const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void GBVIParameters::setAtomicRadii( const RealOpenMMVector& atomicRadii ){ void GBVIParameters::setAtomicRadii(const RealOpenMMVector& atomicRadii) {
if( atomicRadii.size() == _atomicRadii.size() ){ if (atomicRadii.size() == _atomicRadii.size()) {
for( unsigned int ii = 0; ii < atomicRadii.size(); ii++ ){ for (unsigned int ii = 0; ii < atomicRadii.size(); ii++) {
_atomicRadii[ii] = atomicRadii[ii]; _atomicRadii[ii] = atomicRadii[ii];
} }
} else { } else {
...@@ -181,7 +181,7 @@ void GBVIParameters::setAtomicRadii( const RealOpenMMVector& atomicRadii ){ ...@@ -181,7 +181,7 @@ void GBVIParameters::setAtomicRadii( const RealOpenMMVector& atomicRadii ){
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
const RealOpenMMVector& GBVIParameters::getScaledRadii( void ) const { const RealOpenMMVector& GBVIParameters::getScaledRadii() const {
return _scaledRadii; return _scaledRadii;
} }
...@@ -193,10 +193,10 @@ const RealOpenMMVector& GBVIParameters::getScaledRadii( void ) const { ...@@ -193,10 +193,10 @@ const RealOpenMMVector& GBVIParameters::getScaledRadii( void ) const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void GBVIParameters::setScaledRadii( const RealOpenMMVector& scaledRadii ){ void GBVIParameters::setScaledRadii(const RealOpenMMVector& scaledRadii) {
if( scaledRadii.size() == _scaledRadii.size() ){ if (scaledRadii.size() == _scaledRadii.size()) {
for( unsigned int ii = 0; ii < scaledRadii.size(); ii++ ){ for (unsigned int ii = 0; ii < scaledRadii.size(); ii++) {
_scaledRadii[ii] = scaledRadii[ii]; _scaledRadii[ii] = scaledRadii[ii];
} }
} else { } else {
...@@ -218,7 +218,7 @@ void GBVIParameters::setScaledRadii( const RealOpenMMVector& scaledRadii ){ ...@@ -218,7 +218,7 @@ void GBVIParameters::setScaledRadii( const RealOpenMMVector& scaledRadii ){
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
const RealOpenMMVector& GBVIParameters::getGammaParameters( void ) const { const RealOpenMMVector& GBVIParameters::getGammaParameters() const {
return _gammaParameters; return _gammaParameters;
} }
...@@ -230,10 +230,10 @@ const RealOpenMMVector& GBVIParameters::getGammaParameters( void ) const { ...@@ -230,10 +230,10 @@ const RealOpenMMVector& GBVIParameters::getGammaParameters( void ) const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void GBVIParameters::setGammaParameters( const RealOpenMMVector& gammas ){ void GBVIParameters::setGammaParameters(const RealOpenMMVector& gammas) {
if( gammas.size() == _gammaParameters.size() ){ if (gammas.size() == _gammaParameters.size()) {
for( unsigned int ii = 0; ii < gammas.size(); ii++ ){ for (unsigned int ii = 0; ii < gammas.size(); ii++) {
_gammaParameters[ii] = gammas[ii]; _gammaParameters[ii] = gammas[ii];
} }
} else { } else {
...@@ -254,7 +254,7 @@ void GBVIParameters::setGammaParameters( const RealOpenMMVector& gammas ){ ...@@ -254,7 +254,7 @@ void GBVIParameters::setGammaParameters( const RealOpenMMVector& gammas ){
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void GBVIParameters::setUseCutoff( RealOpenMM distance ) { void GBVIParameters::setUseCutoff(RealOpenMM distance) {
_cutoff = true; _cutoff = true;
_cutoffDistance = distance; _cutoffDistance = distance;
...@@ -330,7 +330,7 @@ const OpenMM::RealVec* GBVIParameters::getPeriodicBox() { ...@@ -330,7 +330,7 @@ const OpenMM::RealVec* GBVIParameters::getPeriodicBox() {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM GBVIParameters::getTau( void ) const { RealOpenMM GBVIParameters::getTau() const {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -340,7 +340,7 @@ RealOpenMM GBVIParameters::getTau( void ) const { ...@@ -340,7 +340,7 @@ RealOpenMM GBVIParameters::getTau( void ) const {
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
RealOpenMM tau; RealOpenMM tau;
if( getSoluteDielectric() != zero && getSolventDielectric() != zero ){ if (getSoluteDielectric() != zero && getSolventDielectric() != zero) {
tau = (one/getSoluteDielectric()) - (one/getSolventDielectric()); tau = (one/getSoluteDielectric()) - (one/getSolventDielectric());
} else { } else {
tau = zero; tau = zero;
...@@ -357,7 +357,7 @@ RealOpenMM GBVIParameters::getTau( void ) const { ...@@ -357,7 +357,7 @@ RealOpenMM GBVIParameters::getTau( void ) const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
int GBVIParameters::getBornRadiusScalingMethod( void ) const { int GBVIParameters::getBornRadiusScalingMethod() const {
return _bornRadiusScalingMethod; return _bornRadiusScalingMethod;
} }
...@@ -369,7 +369,7 @@ int GBVIParameters::getBornRadiusScalingMethod( void ) const { ...@@ -369,7 +369,7 @@ int GBVIParameters::getBornRadiusScalingMethod( void ) const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void GBVIParameters::setBornRadiusScalingMethod( int bornRadiusScalingMethod ){ void GBVIParameters::setBornRadiusScalingMethod(int bornRadiusScalingMethod) {
_bornRadiusScalingMethod = bornRadiusScalingMethod; _bornRadiusScalingMethod = bornRadiusScalingMethod;
} }
...@@ -381,7 +381,7 @@ void GBVIParameters::setBornRadiusScalingMethod( int bornRadiusScalingMethod ){ ...@@ -381,7 +381,7 @@ void GBVIParameters::setBornRadiusScalingMethod( int bornRadiusScalingMethod ){
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM GBVIParameters::getQuinticLowerLimitFactor( void ) const { RealOpenMM GBVIParameters::getQuinticLowerLimitFactor() const {
return _quinticLowerLimitFactor; return _quinticLowerLimitFactor;
} }
...@@ -393,7 +393,7 @@ RealOpenMM GBVIParameters::getQuinticLowerLimitFactor( void ) const { ...@@ -393,7 +393,7 @@ RealOpenMM GBVIParameters::getQuinticLowerLimitFactor( void ) const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void GBVIParameters::setQuinticLowerLimitFactor( RealOpenMM quinticLowerLimitFactor ){ void GBVIParameters::setQuinticLowerLimitFactor(RealOpenMM quinticLowerLimitFactor) {
_quinticLowerLimitFactor = quinticLowerLimitFactor; _quinticLowerLimitFactor = quinticLowerLimitFactor;
} }
...@@ -405,7 +405,7 @@ void GBVIParameters::setQuinticLowerLimitFactor( RealOpenMM quinticLowerLimitFac ...@@ -405,7 +405,7 @@ void GBVIParameters::setQuinticLowerLimitFactor( RealOpenMM quinticLowerLimitFac
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM GBVIParameters::getQuinticUpperBornRadiusLimit( void ) const { RealOpenMM GBVIParameters::getQuinticUpperBornRadiusLimit() const {
return _quinticUpperBornRadiusLimit; return _quinticUpperBornRadiusLimit;
} }
...@@ -417,6 +417,6 @@ RealOpenMM GBVIParameters::getQuinticUpperBornRadiusLimit( void ) const { ...@@ -417,6 +417,6 @@ RealOpenMM GBVIParameters::getQuinticUpperBornRadiusLimit( void ) const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void GBVIParameters::setQuinticUpperBornRadiusLimit( RealOpenMM quinticUpperBornRadiusLimit ){ void GBVIParameters::setQuinticUpperBornRadiusLimit(RealOpenMM quinticUpperBornRadiusLimit) {
_quinticUpperBornRadiusLimit = quinticUpperBornRadiusLimit; _quinticUpperBornRadiusLimit = quinticUpperBornRadiusLimit;
} }
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