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

platforms/reference/src/SimTKReference/ReferenceStochasticDynamics.cpp

@@ -47,10 +47,10 @@ using namespace OpenMM;
 
    --------------------------------------------------------------------------------------- */
 
-ReferenceStochasticDynamics::ReferenceStochasticDynamics( int numberOfAtoms,
+ReferenceStochasticDynamics::ReferenceStochasticDynamics(int numberOfAtoms,
                                                          RealOpenMM deltaT, RealOpenMM tau,
-                                                          RealOpenMM temperature ) : 
-           ReferenceDynamics( numberOfAtoms, deltaT, temperature ), _tau( tau ) {
+                                                         RealOpenMM temperature) : 
+           ReferenceDynamics(numberOfAtoms, deltaT, temperature), _tau(tau) {
    if (tau <= 0) {
       std::stringstream message;
       message << "illegal tau value: " << tau;
@@ -66,7 +66,7 @@ ReferenceStochasticDynamics::ReferenceStochasticDynamics( int numberOfAtoms,
 
    --------------------------------------------------------------------------------------- */
 
-ReferenceStochasticDynamics::~ReferenceStochasticDynamics( ){
+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 {
 
    --------------------------------------------------------------------------------------- */
 
-void ReferenceStochasticDynamics::updatePart1( int numberOfAtoms, vector<RealVec>& atomCoordinates,
+void ReferenceStochasticDynamics::updatePart1(int numberOfAtoms, vector<RealVec>& atomCoordinates,
                                               vector<RealVec>& velocities,
                                               vector<RealVec>& forces, vector<RealOpenMM>& inverseMasses,
-                                              vector<RealVec>& xPrime ){
+                                              vector<RealVec>& xPrime) {
 
    // ---------------------------------------------------------------------------------------
 
@@ -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>& forces, vector<RealOpenMM>& inverseMasses,
-                                              vector<RealVec>& xPrime ){
+                                              vector<RealVec>& xPrime) {
 
    // ---------------------------------------------------------------------------------------
 
@@ -197,10 +197,10 @@ void ReferenceStochasticDynamics::update(const OpenMM::System& system, vector<Re
    // first-time-through initialization
 
    int numberOfAtoms = system.getNumParticles();
-   if( getTimeStep() == 0 ){
+   if (getTimeStep() == 0) {
       // invert masses
 
-      for( int ii = 0; ii < numberOfAtoms; ii++ ){
+      for (int ii = 0; ii < numberOfAtoms; ii++) {
          if (masses[ii] == zero)
              inverseMasses[ii] = zero;
          else
@@ -210,11 +210,11 @@ void ReferenceStochasticDynamics::update(const OpenMM::System& system, vector<Re
 
    // 1st update
 
-   updatePart1( numberOfAtoms, atomCoordinates, velocities, forces, inverseMasses, xPrime );
+   updatePart1(numberOfAtoms, atomCoordinates, velocities, forces, inverseMasses, xPrime);
 
    // 2nd update
 
-   updatePart2( numberOfAtoms, atomCoordinates, velocities, forces, inverseMasses, xPrime );
+   updatePart2(numberOfAtoms, atomCoordinates, velocities, forces, inverseMasses, xPrime);
 
    ReferenceConstraintAlgorithm* referenceConstraintAlgorithm = getReferenceConstraintAlgorithm();
    if (referenceConstraintAlgorithm)

platforms/reference/src/SimTKReference/ReferenceVariableStochasticDynamics.cpp

@@ -49,9 +49,9 @@ using namespace OpenMM;
 
    --------------------------------------------------------------------------------------- */
 
-ReferenceVariableStochasticDynamics::ReferenceVariableStochasticDynamics( int numberOfAtoms,
+ReferenceVariableStochasticDynamics::ReferenceVariableStochasticDynamics(int numberOfAtoms,
                                                           RealOpenMM tau, RealOpenMM temperature,
-                                                          RealOpenMM accuracy ) :
+                                                          RealOpenMM accuracy) :
            ReferenceDynamics(numberOfAtoms, 0.0f, temperature), _tau(tau), _accuracy(accuracy) {
    if (tau <= 0) {
       std::stringstream message;
@@ -68,7 +68,7 @@ ReferenceVariableStochasticDynamics::ReferenceVariableStochasticDynamics( int nu
 
    --------------------------------------------------------------------------------------- */
 
-ReferenceVariableStochasticDynamics::~ReferenceVariableStochasticDynamics( ){
+ReferenceVariableStochasticDynamics::~ReferenceVariableStochasticDynamics() {
 
    // ---------------------------------------------------------------------------------------
 
@@ -86,7 +86,7 @@ ReferenceVariableStochasticDynamics::~ReferenceVariableStochasticDynamics( ){
 
  --------------------------------------------------------------------------------------- */
 
-RealOpenMM ReferenceVariableStochasticDynamics::getAccuracy( void ) const {
+RealOpenMM ReferenceVariableStochasticDynamics::getAccuracy() const {
     return _accuracy;
 }
 
@@ -96,7 +96,7 @@ RealOpenMM ReferenceVariableStochasticDynamics::getAccuracy( void ) const {
 
  --------------------------------------------------------------------------------------- */
 
-void ReferenceVariableStochasticDynamics::setAccuracy( RealOpenMM accuracy ) {
+void ReferenceVariableStochasticDynamics::setAccuracy(RealOpenMM accuracy) {
     _accuracy = 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 {
 
    --------------------------------------------------------------------------------------- */
 
-void ReferenceVariableStochasticDynamics::updatePart1( int numberOfAtoms, vector<RealVec>& atomCoordinates,
+void ReferenceVariableStochasticDynamics::updatePart1(int numberOfAtoms, vector<RealVec>& atomCoordinates,
                                               vector<RealVec>& velocities,
                                               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
 
    // first-time-through initialization
 
-   if( getTimeStep() == 0 ){
+   if (getTimeStep() == 0) {
       // invert masses
 
-      for( int ii = 0; ii < numberOfAtoms; ii++ ){
+      for (int ii = 0; ii < numberOfAtoms; ii++) {
          if (masses[ii] == 0)
              inverseMasses[ii] = 0;
          else
@@ -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>& forces, vector<RealOpenMM>& inverseMasses,
-                                              vector<RealVec>& xPrime ){
+                                              vector<RealVec>& xPrime) {
 
    // ---------------------------------------------------------------------------------------
 
@@ -255,11 +255,11 @@ void ReferenceVariableStochasticDynamics::update(const OpenMM::System& system, v
    // 1st update
 
    int numberOfAtoms = system.getNumParticles();
-   updatePart1( numberOfAtoms, atomCoordinates, velocities, forces, masses, inverseMasses, xPrime, maxStepSize );
+   updatePart1(numberOfAtoms, atomCoordinates, velocities, forces, masses, inverseMasses, xPrime, maxStepSize);
 
    // 2nd update
 
-   updatePart2( numberOfAtoms, atomCoordinates, velocities, forces, inverseMasses, xPrime );
+   updatePart2(numberOfAtoms, atomCoordinates, velocities, forces, inverseMasses, xPrime);
 
    ReferenceConstraintAlgorithm* referenceConstraintAlgorithm = getReferenceConstraintAlgorithm();
    if (referenceConstraintAlgorithm)
@@ -267,7 +267,7 @@ void ReferenceVariableStochasticDynamics::update(const OpenMM::System& system, v
 
    // copy xPrime -> atomCoordinates
 
-   for( int ii = 0; ii < numberOfAtoms; ii++ ) {
+   for (int ii = 0; ii < numberOfAtoms; ii++) {
        if (masses[ii] != 0.0) {
            atomCoordinates[ii][0] = xPrime[ii][0];
            atomCoordinates[ii][1] = xPrime[ii][1];

platforms/reference/src/SimTKReference/ReferenceVariableVerletDynamics.cpp

@@ -44,8 +44,8 @@ using namespace OpenMM;
 
    --------------------------------------------------------------------------------------- */
 
-ReferenceVariableVerletDynamics::ReferenceVariableVerletDynamics( int numberOfAtoms, RealOpenMM accuracy ) :
-           ReferenceDynamics( numberOfAtoms, 0.0f, 0.0f ), _accuracy(accuracy) {
+ReferenceVariableVerletDynamics::ReferenceVariableVerletDynamics(int numberOfAtoms, RealOpenMM accuracy) :
+           ReferenceDynamics(numberOfAtoms, 0.0f, 0.0f), _accuracy(accuracy) {
     xPrime.resize(numberOfAtoms);
     inverseMasses.resize(numberOfAtoms);
 }
@@ -56,7 +56,7 @@ ReferenceVariableVerletDynamics::ReferenceVariableVerletDynamics( int numberOfAt
 
    --------------------------------------------------------------------------------------- */
 
-ReferenceVariableVerletDynamics::~ReferenceVariableVerletDynamics( ){
+ReferenceVariableVerletDynamics::~ReferenceVariableVerletDynamics() {
 
    // ---------------------------------------------------------------------------------------
 
@@ -74,7 +74,7 @@ ReferenceVariableVerletDynamics::~ReferenceVariableVerletDynamics( ){
 
  --------------------------------------------------------------------------------------- */
 
-RealOpenMM ReferenceVariableVerletDynamics::getAccuracy( void ) const {
+RealOpenMM ReferenceVariableVerletDynamics::getAccuracy() const {
     return _accuracy;
 }
 
@@ -84,7 +84,7 @@ RealOpenMM ReferenceVariableVerletDynamics::getAccuracy( void ) const {
 
  --------------------------------------------------------------------------------------- */
 
-void ReferenceVariableVerletDynamics::setAccuracy( RealOpenMM accuracy ) {
+void ReferenceVariableVerletDynamics::setAccuracy(RealOpenMM accuracy) {
     _accuracy = accuracy;
 }
 
@@ -118,10 +118,10 @@ void ReferenceVariableVerletDynamics::update(const OpenMM::System& system, vecto
     // first-time-through initialization
 
     int numberOfAtoms = system.getNumParticles();
-    if( getTimeStep() == 0 ){
+    if (getTimeStep() == 0) {
        // invert masses
 
-       for( int ii = 0; ii < numberOfAtoms; ii++ ){
+       for (int ii = 0; ii < numberOfAtoms; ii++) {
           if (masses[ii] == zero)
               inverseMasses[ii] = zero;
           else

platforms/reference/src/SimTKReference/ReferenceVerletDynamics.cpp

@@ -46,9 +46,8 @@ using namespace OpenMM;
 
    --------------------------------------------------------------------------------------- */
 
-ReferenceVerletDynamics::ReferenceVerletDynamics( int numberOfAtoms,
-                                                          RealOpenMM deltaT ) : 
-           ReferenceDynamics( numberOfAtoms, deltaT, 0.0 ) {
+ReferenceVerletDynamics::ReferenceVerletDynamics(int numberOfAtoms, RealOpenMM deltaT) :
+           ReferenceDynamics(numberOfAtoms, deltaT, 0.0) {
 
    // ---------------------------------------------------------------------------------------
 
@@ -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
    // first-time-through initialization
 
    int numberOfAtoms = system.getNumParticles();
-   if( getTimeStep() == 0 ){
+   if (getTimeStep() == 0) {
       // invert masses
 
-      for( int ii = 0; ii < numberOfAtoms; ii++ ){
+      for (int ii = 0; ii < numberOfAtoms; ii++) {
          if (masses[ii] == zero)
              inverseMasses[ii] = zero;
          else
@@ -134,7 +133,7 @@ void ReferenceVerletDynamics::update(const OpenMM::System& system, vector<RealVe
    
    // 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) {
        if (masses[i] != zero)
            for (int j = 0; j < 3; ++j) {

platforms/reference/src/SimTKReference/fftpack.cpp

@@ -672,16 +672,16 @@ fftpack_transpose_2d(t_complex *          in_data,
     t_complex *  src;
     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);
         }
         return 0;
     }
 
-    if(in_data == out_data)
+    if (in_data == out_data)
     {
         src = (t_complex *)malloc(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,
         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].im = src[i*ny+j].im;
         }
     }
 
-    if(src != in_data)
+    if (src != in_data)
     {
         free(src);
     }
@@ -722,16 +722,16 @@ fftpack_transpose_2d_nelem(t_complex *          in_data,
 
     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);
         }
         return 0;
     }
 
-    if(in_data == out_data)
+    if (in_data == out_data)
     {
         src = (t_complex *)malloc(nx*ny*ncopy);
         memcpy(src,in_data,nx*ny*ncopy);
@@ -741,15 +741,15 @@ fftpack_transpose_2d_nelem(t_complex *          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);
         }
     }
 
-    if(src != in_data)
+    if (src != in_data)
     {
         free(src);
     }
@@ -767,14 +767,14 @@ fftpack_init_1d(fftpack_t *        pfft,
 {
     fftpack_t    fft;
 
-    if(pfft==NULL)
+    if (pfft==NULL)
     {
         fprintf(stderr,"Fatal error - Invalid FFT opaque type pointer.");
         return EINVAL;
     }
     *pfft = NULL;
 
-    if( (fft = (struct fftpack *)malloc(sizeof(struct fftpack))) == NULL)
+    if ((fft = (struct fftpack *)malloc(sizeof(struct fftpack))) == NULL)
     {
         return ENOMEM;
     }
@@ -783,13 +783,13 @@ fftpack_init_1d(fftpack_t *        pfft,
     fft->n    = nx;
 
     /* 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);
         return ENOMEM;
     }
 
-    if(fft->n>1)
+    if (fft->n>1)
         fftpack_cffti1(nx,fft->work,fft->ifac);
 
     *pfft = fft;
@@ -807,7 +807,7 @@ fftpack_init_2d(fftpack_t *        pfft,
     fftpack_t     fft;
     int           rc;
 
-    if(pfft==NULL)
+    if (pfft==NULL)
     {
         fprintf(stderr,"Fatal error - Invalid FFT opaque type pointer.");
         return EINVAL;
@@ -815,13 +815,13 @@ fftpack_init_2d(fftpack_t *        pfft,
     *pfft = NULL;
 
     /* Create the X transform */
-    if( (rc = fftpack_init_1d(&fft,nx)) != 0)
+    if ((rc = fftpack_init_1d(&fft,nx)) != 0)
     {
         return rc;
     }
 
     /* 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);
         return rc;
@@ -842,7 +842,7 @@ fftpack_init_3d(fftpack_t *        pfft,
     fftpack_t     fft;
     int           rc;
 
-    if(pfft==NULL)
+    if (pfft==NULL)
     {
         fprintf(stderr,"Fatal error - Invalid FFT opaque type pointer.");
         return EINVAL;
@@ -851,7 +851,7 @@ fftpack_init_3d(fftpack_t *        pfft,
 
     /* Create the X transform */
 
-    if( (fft = (struct fftpack *)malloc(sizeof(struct fftpack))) == NULL)
+    if ((fft = (struct fftpack *)malloc(sizeof(struct fftpack))) == NULL)
     {
         return ENOMEM;
     }
@@ -860,7 +860,7 @@ fftpack_init_3d(fftpack_t *        pfft,
 
     /* 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);
         return ENOMEM;
@@ -869,7 +869,7 @@ fftpack_init_3d(fftpack_t *        pfft,
     fftpack_cffti1(nx,fft->work,fft->ifac);
 
     /* 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);
         return rc;
@@ -893,7 +893,7 @@ fftpack_exec_1d          (fftpack_t                  fft,
 
     n=fft->n;
 
-    if(n==1)
+    if (n==1)
     {
         p1 = (RealOpenMM *)in_data;
         p2 = (RealOpenMM *)out_data;
@@ -904,13 +904,13 @@ fftpack_exec_1d          (fftpack_t                  fft,
     /* FFTPACK only does in-place transforms, so emulate out-of-place
      * by copying data to the output array first.
      */
-    if( in_data != out_data )
+    if (in_data != out_data)
     {
         p1 = (RealOpenMM *)in_data;
         p2 = (RealOpenMM *)out_data;
 
         /* n complex = 2*n RealOpenMM elements */
-        for(i=0;i<2*n;i++)
+        for (i=0;i<2*n;i++)
         {
             p2[i] = p1[i];
         }
@@ -920,11 +920,11 @@ fftpack_exec_1d          (fftpack_t                  fft,
      * 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);
     }
-    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);
     }
@@ -957,7 +957,7 @@ fftpack_exec_2d          (fftpack_t                  fft,
      * by copying data to the output array first.
      * 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);
     }
@@ -966,7 +966,7 @@ fftpack_exec_2d          (fftpack_t                  fft,
     data = (t_complex *)out_data;
 
     /* 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);
     }
@@ -975,7 +975,7 @@ fftpack_exec_2d          (fftpack_t                  fft,
     fftpack_transpose_2d(data,data,nx,ny);
 
     /* 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);
     }
@@ -1007,7 +1007,7 @@ fftpack_exec_3d     (fftpack_t                  fft,
      * by copying data to the output array first.
      * 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);
     }
@@ -1016,23 +1016,23 @@ fftpack_exec_3d     (fftpack_t                  fft,
     data = (t_complex *)out_data;
 
     /* 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);
 
     /* 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);
     }
 
     /* 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);
     }
 
     /* 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);
     }
@@ -1041,26 +1041,26 @@ fftpack_exec_3d     (fftpack_t                  fft,
      * (nx,ny,nz) to (ny,nx,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().");
         return rc;
     }
 
     /* 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);
     }
 
     /* 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);
     }
 
     /* 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);
     }
@@ -1068,7 +1068,7 @@ fftpack_exec_3d     (fftpack_t                  fft,
     /* Transpose from (ny,nx,nz) to (nx,ny,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().");
         return rc;
@@ -1082,10 +1082,10 @@ fftpack_exec_3d     (fftpack_t                  fft,
 void
 fftpack_destroy(fftpack_t      fft)
 {
-    if(fft != NULL)
+    if (fft != NULL)
     {
         free(fft->work);
-        if(fft->next != NULL)
+        if (fft->next != NULL)
             fftpack_destroy(fft->next);
         free(fft);
     }

platforms/reference/src/SimTKUtilities/SimTKOpenMMCommon.cpp

@@ -30,9 +30,9 @@ using namespace OpenMM;
 
 // initialization of static data members
 
-const std::string SimTKOpenMMCommon::NotSet                  = std::string( "NotSet" );
-const std::string SimTKOpenMMCommon::Comment                 = std::string( "#" );
-const std::string SimTKOpenMMCommon::Tab                     = std::string( "\t" ); 
+const std::string SimTKOpenMMCommon::NotSet                  = std::string("NotSet");
+const std::string SimTKOpenMMCommon::Comment                 = std::string("#");
+const std::string SimTKOpenMMCommon::Tab                     = std::string("\t"); 
 
 const int SimTKOpenMMCommon::DefaultReturn                   = 0;
 const int SimTKOpenMMCommon::ErrorReturn                     = -1;

platforms/reference/src/SimTKUtilities/SimTKOpenMMUtilities.cpp

@@ -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,
-                                                               const std::string& idString ){
+                                                              const std::string& idString) {
 
    // ---------------------------------------------------------------------------------------
 
@@ -71,17 +71,17 @@ RealOpenMM* SimTKOpenMMUtilities::allocateOneDRealOpenMMArray( int iSize, RealOp
 
    // ---------------------------------------------------------------------------------------
 
-   if( array1D == NULL ){
+   if (array1D == NULL) {
 
       array1D = new RealOpenMM[iSize];
 
    }
 
-   if( initialize ){
-      if( initialValue == zero ){
-         memset( array1D, 0, iSize*sizeof( RealOpenMM ) );
+   if (initialize) {
+      if (initialValue == zero) {
+         memset(array1D, 0, iSize*sizeof(RealOpenMM));
       } else {
-         for( int ii = 0; ii < iSize; ii++ ){
+         for (int ii = 0; ii < iSize; ii++) {
             array1D[ii] = initialValue;
          }
       }
@@ -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,
-                                                                const std::string& idString ){
+                                                               const std::string& idString) {
 
    // ---------------------------------------------------------------------------------------
 
@@ -117,22 +117,22 @@ RealOpenMM** SimTKOpenMMUtilities::allocateTwoDRealOpenMMArray( int iSize, int j
 
    // ---------------------------------------------------------------------------------------
 
-   if( array2D == NULL ){
+   if (array2D == NULL) {
 
       array2D = new RealOpenMM*[iSize];
       std::string blockString = idString;
-      blockString.append( "Block" );
+      blockString.append("Block");
 
       RealOpenMM* block = new RealOpenMM[jSize*iSize];
 
-      for( int ii = 0; ii < iSize; ii++ ){
+      for (int ii = 0; ii < iSize; ii++) {
          array2D[ii]  = block;
          block       += jSize;
       }    
    }
 
-   if( initialize ){
-      initialize2DRealOpenMMArray( iSize, jSize, array2D, initialValue );
+   if (initialize) {
+      initialize2DRealOpenMMArray(iSize, jSize, array2D, initialValue);
    }
 
    return array2D;
@@ -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
 
    // ---------------------------------------------------------------------------------------
 
-   if( array2D != NULL ){
+   if (array2D != NULL) {
 
       std::string blockString = idString;
-      blockString.append( "Block" );
+      blockString.append("Block");
 
       delete[] array2D[0];
       delete[] array2D;
@@ -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
 
    // ---------------------------------------------------------------------------------------
 
-   if( array1D != NULL ){
+   if (array1D != NULL) {
       delete[] array1D;
    }
 }
@@ -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 initialValue ){
+                                                       RealOpenMM initialValue) {
 
    // ---------------------------------------------------------------------------------------
 
@@ -217,9 +217,9 @@ void SimTKOpenMMUtilities::initialize2DRealOpenMMArray( int iSize, int jSize,
    bool useMemset;
    bool useMemsetSingleBlock;
 
-   if( initialValue == 0.0f ){
+   if (initialValue == 0.0f) {
       useMemset = true;
-      if( jSize > 1 && (array2D[0] + jSize) == array2D[1] ){  
+      if (jSize > 1 && (array2D[0] + jSize) == array2D[1]) {  
          useMemsetSingleBlock = true;
       } else {
          useMemsetSingleBlock = false;
@@ -229,17 +229,17 @@ void SimTKOpenMMUtilities::initialize2DRealOpenMMArray( int iSize, int jSize,
       useMemset = false;
    }
 
-   if( useMemset ){
-      if( useMemsetSingleBlock ){
-         memset( array2D[0], 0, iSize*jSize*sizeof( RealOpenMM ) );
+   if (useMemset) {
+      if (useMemsetSingleBlock) {
+         memset(array2D[0], 0, iSize*jSize*sizeof(RealOpenMM));
       } else {
-         for( int ii = 0; ii < iSize; ii++ ){
-            memset( array2D[ii], 0, jSize*sizeof( RealOpenMM ) );
+         for (int ii = 0; ii < iSize; ii++) {
+            memset(array2D[ii], 0, jSize*sizeof(RealOpenMM));
          }
       }
    } else {
-      for( int ii = 0; ii < iSize; ii++ ){
-         for( int jj = 0; jj < jSize; jj++ ){
+      for (int ii = 0; ii < iSize; ii++) {
+         for (int jj = 0; jj < jSize; jj++) {
             array2D[ii][jj] = initialValue;
          }
       }
@@ -260,9 +260,9 @@ void SimTKOpenMMUtilities::initialize2DRealOpenMMArray( int iSize, int jSize,
 
    --------------------------------------------------------------------------------------- */
      
-void SimTKOpenMMUtilities::crossProductVector3( RealOpenMM* vectorX,
+void SimTKOpenMMUtilities::crossProductVector3(RealOpenMM* vectorX,
                                                RealOpenMM* vectorY,
-                                                RealOpenMM* vectorZ ){
+                                               RealOpenMM* vectorZ) {
 
    // ---------------------------------------------------------------------------------------
 
@@ -285,7 +285,7 @@ void SimTKOpenMMUtilities::crossProductVector3( RealOpenMM* vectorX,
 
    --------------------------------------------------------------------------------------- */
 
-RealOpenMM SimTKOpenMMUtilities::getNormallyDistributedRandomNumber( void ) {
+RealOpenMM SimTKOpenMMUtilities::getNormallyDistributedRandomNumber() {
     if (nextGaussianIsValid) {
         nextGaussianIsValid = false;
         return nextGaussian;
@@ -304,7 +304,7 @@ RealOpenMM SimTKOpenMMUtilities::getNormallyDistributedRandomNumber( void ) {
         y = static_cast<RealOpenMM>(2.0 * genrand_real2(sfmt) - 1.0);
         r2 = x*x + y*y;
     } 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;
     nextGaussianIsValid = true;
     return x*multiplier;
@@ -318,13 +318,13 @@ RealOpenMM SimTKOpenMMUtilities::getNormallyDistributedRandomNumber( void ) {
 
    --------------------------------------------------------------------------------------- */
 
-RealOpenMM SimTKOpenMMUtilities::getUniformlyDistributedRandomNumber( void ) {
+RealOpenMM SimTKOpenMMUtilities::getUniformlyDistributedRandomNumber() {
     if (!_randomInitialized) {
         init_gen_rand(_randomNumberSeed, sfmt);
         _randomInitialized = true;
         nextGaussianIsValid = false;
     }
-    RealOpenMM value = static_cast<RealOpenMM>( genrand_real2(sfmt) );
+    RealOpenMM value = static_cast<RealOpenMM>(genrand_real2(sfmt));
     return value;
 }
 
@@ -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 ) {
 
    --------------------------------------------------------------------------------------- */
 
-void SimTKOpenMMUtilities::setRandomNumberSeed( uint32_t seed ) {
+void SimTKOpenMMUtilities::setRandomNumberSeed(uint32_t seed) {
 
    // ---------------------------------------------------------------------------------------