edit/add AMOEBA serialization proxies

plugins/amoeba/serialization/tests/TestSerializeAmoebaOutOfPlaneBendForce.cpp

@@ -41,34 +41,38 @@ using namespace std;
 void testSerialization() {
     // Create a Force.
 
-    AmoebaOutOfPlaneBendForce force;
-    force.setAmoebaGlobalOutOfPlaneBendCubic( 12.3 );
-    force.setAmoebaGlobalOutOfPlaneBendQuartic( 98.7 );
-    force.setAmoebaGlobalOutOfPlaneBendPentic( 91.7 );
-    force.setAmoebaGlobalOutOfPlaneBendSextic( 93.7 );
-    force.addOutOfPlaneBend(0, 1, 3, 4, 2.0);
-    force.addOutOfPlaneBend(0, 2, 3, 5, 2.1);
-    force.addOutOfPlaneBend(2, 3, 5, 6, 2.2);
-    force.addOutOfPlaneBend(5, 1, 8, 8, 2.3);
+    AmoebaOutOfPlaneBendForce force1;
+
+    force1.setAmoebaGlobalOutOfPlaneBendCubic( 12.3 );
+    force1.setAmoebaGlobalOutOfPlaneBendQuartic( 98.7 );
+    force1.setAmoebaGlobalOutOfPlaneBendPentic( 91.7 );
+    force1.setAmoebaGlobalOutOfPlaneBendSextic( 93.7 );
+
+    force1.addOutOfPlaneBend(0, 1, 3, 4, 2.0);
+    force1.addOutOfPlaneBend(0, 2, 3, 5, 2.1);
+    force1.addOutOfPlaneBend(2, 3, 5, 6, 2.2);
+    force1.addOutOfPlaneBend(5, 1, 8, 8, 2.3);
 
     // Serialize and then deserialize it.
 
     stringstream buffer;
-    XmlSerializer::serialize<AmoebaOutOfPlaneBendForce>(&force, "Force", buffer);
+    XmlSerializer::serialize<AmoebaOutOfPlaneBendForce>(&force1, "Force", buffer);
     AmoebaOutOfPlaneBendForce* copy = XmlSerializer::deserialize<AmoebaOutOfPlaneBendForce>(buffer);
 
     // Compare the two forces to see if they are identical.  
     AmoebaOutOfPlaneBendForce& force2 = *copy;
-    ASSERT_EQUAL(force.getAmoebaGlobalOutOfPlaneBendCubic(), force2.getAmoebaGlobalOutOfPlaneBendCubic());
-    ASSERT_EQUAL(force.getAmoebaGlobalOutOfPlaneBendQuartic(), force2.getAmoebaGlobalOutOfPlaneBendQuartic());
-    ASSERT_EQUAL(force.getAmoebaGlobalOutOfPlaneBendPentic(), force2.getAmoebaGlobalOutOfPlaneBendPentic());
-    ASSERT_EQUAL(force.getAmoebaGlobalOutOfPlaneBendSextic(), force2.getAmoebaGlobalOutOfPlaneBendSextic());
-    ASSERT_EQUAL(force.getNumOutOfPlaneBends(), force2.getNumOutOfPlaneBends());
-    for (int i = 0; i < force.getNumOutOfPlaneBends(); i++) {
+
+    ASSERT_EQUAL(force1.getAmoebaGlobalOutOfPlaneBendCubic(), force2.getAmoebaGlobalOutOfPlaneBendCubic());
+    ASSERT_EQUAL(force1.getAmoebaGlobalOutOfPlaneBendQuartic(), force2.getAmoebaGlobalOutOfPlaneBendQuartic());
+    ASSERT_EQUAL(force1.getAmoebaGlobalOutOfPlaneBendPentic(), force2.getAmoebaGlobalOutOfPlaneBendPentic());
+    ASSERT_EQUAL(force1.getAmoebaGlobalOutOfPlaneBendSextic(), force2.getAmoebaGlobalOutOfPlaneBendSextic());
+    ASSERT_EQUAL(force1.getNumOutOfPlaneBends(), force2.getNumOutOfPlaneBends());
+
+    for (unsigned int ii = 0; ii < force1.getNumOutOfPlaneBends(); ii++) {
         int a1, a2, a3, a4, b1, b2, b3, b4;
         double ka, kb;
-        force.getOutOfPlaneBendParameters(i, a1, a2, a3, a4, ka);
-        force2.getOutOfPlaneBendParameters(i, b1, b2, b3, b4, kb);
+        force1.getOutOfPlaneBendParameters(ii, a1, a2, a3, a4, ka);
+        force2.getOutOfPlaneBendParameters(ii, b1, b2, b3, b4, kb);
         ASSERT_EQUAL(a1, b1);
         ASSERT_EQUAL(a2, b2);
         ASSERT_EQUAL(a3, b3);

plugins/amoeba/serialization/tests/TestSerializeAmoebaPiTorsionForce.cpp

@@ -41,26 +41,26 @@ using namespace std;
 void testSerialization() {
     // Create a Force.
 
-    AmoebaPiTorsionForce force;
-    force.addPiTorsion(0, 1, 3, 4, 5, 6, 2.0);
-    force.addPiTorsion(0, 2, 3, 5, 12, 13, 2.1);
-    force.addPiTorsion(2, 3, 5, 6, 81, 91, 2.2);
-    force.addPiTorsion(5, 1, 8, 8, 101, 102, 2.3);
+    AmoebaPiTorsionForce force1;
+    force1.addPiTorsion(0, 1, 3, 4, 5, 6, 2.0);
+    force1.addPiTorsion(0, 2, 3, 5, 12, 13, 2.1);
+    force1.addPiTorsion(2, 3, 5, 6, 81, 91, 2.2);
+    force1.addPiTorsion(5, 1, 8, 8, 101, 102, 2.3);
 
     // Serialize and then deserialize it.
 
     stringstream buffer;
-    XmlSerializer::serialize<AmoebaPiTorsionForce>(&force, "Force", buffer);
+    XmlSerializer::serialize<AmoebaPiTorsionForce>(&force1, "Force", buffer);
     AmoebaPiTorsionForce* copy = XmlSerializer::deserialize<AmoebaPiTorsionForce>(buffer);
 
     // Compare the two forces to see if they are identical.  
     AmoebaPiTorsionForce& force2 = *copy;
-    ASSERT_EQUAL(force.getNumPiTorsions(), force2.getNumPiTorsions());
-    for (int i = 0; i < force.getNumPiTorsions(); i++) {
+    ASSERT_EQUAL(force1.getNumPiTorsions(), force2.getNumPiTorsions());
+    for (unsigned int ii = 0; ii < force1.getNumPiTorsions(); ii++) {
         int a1, a2, a3, a4, a5, a6, b1, b2, b3, b4, b5, b6;
         double ka, kb;
-        force.getPiTorsionParameters( i, a1, a2, a3, a4, a5, a6, ka);
-        force2.getPiTorsionParameters(i, b1, b2, b3, b4, b5, b6, kb);
+        force1.getPiTorsionParameters(ii, a1, a2, a3, a4, a5, a6, ka);
+        force2.getPiTorsionParameters(ii, b1, b2, b3, b4, b5, b6, kb);
         ASSERT_EQUAL(a1, b1);
         ASSERT_EQUAL(a2, b2);
         ASSERT_EQUAL(a3, b3);

plugins/amoeba/serialization/include/openmm/serializatio → plugins/amoeba/serialization/tests/TestSerializeAmoebaStretchBendForce.cpp

-#ifndef OPENMM_HARMONICBONDFORCE_PROXY_H_
-#define OPENMM_HARMONICBONDFORCE_PROXY_H_
-
 /* -------------------------------------------------------------------------- *
- *                                   OpenMM                                   *
+ *                                OpenMMAmoeba                                *
  * -------------------------------------------------------------------------- *
  * This is part of the OpenMM molecular simulation toolkit originating from   *
  * Simbios, the NIH National Center for Physics-Based Simulation of           *
@@ -32,22 +29,62 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-#include "openmm/internal/windowsExport.h"
-#include "openmm/serialization/SerializationProxy.h"
+#include "../../../tests/AssertionUtilities.h"
+#include "openmm/AmoebaStretchBendForce.h"
+#include "openmm/serialization/XmlSerializer.h"
+#include <iostream>
+#include <sstream>
+
+using namespace OpenMM;
+using namespace std;
+
+void testSerialization() {
+    // Create a Force.
+
+    AmoebaStretchBendForce force1;
+    force1.addStretchBend(0, 1, 3, 1.0, 1.2, 150.1, 83.2);
+    force1.addStretchBend(2, 4, 4, 1.1, 2.2, 180.1, 89.2);
+    force1.addStretchBend(5, 0, 1, 3.1, 8.2, 140.1, 98.2);
+
+    // Serialize and then deserialize it.
+
+    stringstream buffer;
+    XmlSerializer::serialize<AmoebaStretchBendForce>(&force1, "Force", buffer);
+    AmoebaStretchBendForce* copy = XmlSerializer::deserialize<AmoebaStretchBendForce>(buffer);
 
-namespace OpenMM {
+    // Compare the two forces to see if they are identical.  
+    AmoebaStretchBendForce& force2 = *copy;
+    ASSERT_EQUAL(force1.getNumStretchBends(), force2.getNumStretchBends());
+    for (unsigned int ii = 0; ii < force1.getNumStretchBends(); ii++) {
+        int p11, p12, p13;
+        int p21, p22, p23;
+        double dAB1, dAB2;
+        double dCB1, dCB2;
+        double angle1, angle2;
+        double k1, k2;
 
-/**
- * This is a proxy for serializing HarmonicBondForce objects.
- */
+        force1.getStretchBendParameters(ii, p11, p12, p13, dAB1, dCB1, angle1, k1);
+        force2.getStretchBendParameters(ii, p21, p22, p23, dAB2, dCB2, angle2, k2);
 
-class OPENMM_EXPORT HarmonicBondForceProxy : public SerializationProxy {
-public:
-    HarmonicBondForceProxy();
-    void serialize(const void* object, SerializationNode& node) const;
-    void* deserialize(const SerializationNode& node) const;
-};
+        ASSERT_EQUAL(p11, p21);
+        ASSERT_EQUAL(p12, p22);
+        ASSERT_EQUAL(p13, p23);
+        ASSERT_EQUAL(dAB1, dAB2);
+        ASSERT_EQUAL(dCB1, dCB2);
+        ASSERT_EQUAL(angle1, angle2);
+        ASSERT_EQUAL(k1, k2);
+    }
+}
 
-} // namespace OpenMM
+int main() {
+    try {
+        testSerialization();
+    }
+    catch(const exception& e) {
+        cout << "exception: " << e.what() << endl;
+        return 1;
+    }
+    cout << "Done" << endl;
+    return 0;
+}
 
-#endif /*OPENMM_HARMONICBONDFORCE_PROXY_H_*/

plugins/amoeba/serialization/tests/TestSerializeAmoebaTorsionForce.cpp

@@ -47,42 +47,43 @@ void loadTorsion( std::vector<double>& torsion, double offset ){
 
 void compareTorsion( std::vector<double> torsionA, std::vector<double> torsionB ){
     ASSERT_EQUAL(torsionA.size(), torsionB.size());
-    for (int i = 0; i < torsionA.size(); i++) {
-        ASSERT_EQUAL(torsionA[i], torsionB[i]);
+    for (unsigned int ii = 0; ii < torsionA.size(); ii++) {
+        ASSERT_EQUAL(torsionA[ii], torsionB[ii]);
     }
 }
 
 void testSerialization() {
+
     // Create a Force.
 
-    AmoebaTorsionForce force;
-    for( int ii = 0; ii < 5; ii++ ){
+    AmoebaTorsionForce force1;
+    for( unsigned int ii = 0; ii < 5; ii++ ){
         std::vector<double> torsion1;
         std::vector<double> torsion2;
         std::vector<double> torsion3;
         loadTorsion( torsion1, static_cast<double>(5*ii) + 11.1);
         loadTorsion( torsion2, static_cast<double>(5*ii) + 21.2);
         loadTorsion( torsion3, static_cast<double>(5*ii) + 31.3);
-        force.addTorsion( ii, ii+1,ii+3, ii+4, torsion1, torsion2, torsion3 );
+        force1.addTorsion( ii, ii+1,ii+3, ii+4, torsion1, torsion2, torsion3 );
     }
 
     // Serialize and then deserialize it.
 
     stringstream buffer;
-    XmlSerializer::serialize<AmoebaTorsionForce>(&force, "Force", buffer);
+    XmlSerializer::serialize<AmoebaTorsionForce>(&force1, "Force", buffer);
 
-if( 0 ){
-FILE* filePtr = fopen("Torsion.xml", "w" );
-(void) fprintf( filePtr, "%s", buffer.str().c_str() );
-(void) fclose( filePtr );
-}
+    if( 0 ){
+        FILE* filePtr = fopen("Torsion.xml", "w" );
+        (void) fprintf( filePtr, "%s", buffer.str().c_str() );
+        (void) fclose( filePtr );
+    }
 
     AmoebaTorsionForce* copy = XmlSerializer::deserialize<AmoebaTorsionForce>(buffer);
 
     // Compare the two forces to see if they are identical.  
     AmoebaTorsionForce& force2 = *copy;
-    ASSERT_EQUAL(force.getNumTorsions(), force2.getNumTorsions());
-    for (int i = 0; i < force.getNumTorsions(); i++) {
+    ASSERT_EQUAL(force1.getNumTorsions(), force2.getNumTorsions());
+    for (unsigned int ii = 0; ii < force1.getNumTorsions(); ii++) {
 
         int a1, a2, a3, a4, b1, b2, b3, b4;
 
@@ -93,8 +94,8 @@ FILE* filePtr = fopen("Torsion.xml", "w" );
         std::vector<double> torsion2b;
         std::vector<double> torsion3b;
 
-        force.getTorsionParameters( i, a1, a2, a3, a4, torsion1a, torsion2a, torsion3a);
-        force2.getTorsionParameters( i, b1, b2, b3, b4, torsion1b, torsion2b, torsion3b);
+        force1.getTorsionParameters( ii, a1, a2, a3, a4, torsion1a, torsion2a, torsion3a);
+        force2.getTorsionParameters( ii, b1, b2, b3, b4, torsion1b, torsion2b, torsion3b);
 
         ASSERT_EQUAL(a1, b1);
         ASSERT_EQUAL(a2, b2);

plugins/amoeba/serialization/tests/TestSerializeAmoebaTorsionTorsionForce.cpp

@@ -43,11 +43,11 @@ static void loadTorsionTorsionGrid( std::vector< std::vector< std::vector<double
  
     static const int gridSize = 25;
     gridVector.resize( gridSize );
-    for( int ii = 0; ii < gridSize; ii++ ){
+    for( unsigned int ii = 0; ii < gridSize; ii++ ){
         gridVector[ii].resize( gridSize );
-        for( int jj = 0; jj < gridSize; jj++ ){
+        for( unsigned int jj = 0; jj < gridSize; jj++ ){
             gridVector[ii][jj].resize( 6 );
-            for( int kk = 0; kk < 6; kk++ ){
+            for( unsigned int kk = 0; kk < 6; kk++ ){
                 gridVector[ii][jj][0] = -180.0 + 15.0*static_cast<double>(ii);
                 gridVector[ii][jj][1] = -180.0 + 15.0*static_cast<double>(jj);
                 gridVector[ii][jj][2] = static_cast<double>( rand());
@@ -62,12 +62,12 @@ static void loadTorsionTorsionGrid( std::vector< std::vector< std::vector<double
 static void compareGrids( const std::vector< std::vector< std::vector<double> > >& grid1, const std::vector< std::vector< std::vector<double> > >& grid2 ) {
 
     ASSERT_EQUAL(grid1.size(), grid2.size());
-    for (int i = 0; i < grid1.size(); i++) {
-        ASSERT_EQUAL(grid1[i].size(), grid2[i].size());
-        for (int jj = 0; jj < grid1[i].size(); jj++) {
-            ASSERT_EQUAL(grid1[i][jj].size(), grid2[i][jj].size());
-            for (int kk = 0; kk < grid1[i][jj].size(); kk++) {
-                ASSERT_EQUAL(grid1[i][jj][kk], grid2[i][jj][kk]);
+    for (unsigned int ii = 0; ii < grid1.size(); ii++) {
+        ASSERT_EQUAL(grid1[ii].size(), grid2[ii].size());
+        for (int jj = 0; jj < grid1[ii].size(); jj++) {
+            ASSERT_EQUAL(grid1[ii][jj].size(), grid2[ii][jj].size());
+            for (int kk = 0; kk < grid1[ii][jj].size(); kk++) {
+                ASSERT_EQUAL(grid1[ii][jj][kk], grid2[ii][jj][kk]);
             }
         }
     }
@@ -76,40 +76,40 @@ static void compareGrids( const std::vector< std::vector< std::vector<double> >
 void testSerialization() {
     // Create a Force.
 
-    AmoebaTorsionTorsionForce force;
+    AmoebaTorsionTorsionForce force1;
 
-    for( int ii = 0; ii < 5; ii++ ){
+    for( unsigned int ii = 0; ii < 5; ii++ ){
         std::vector< std::vector< std::vector<double> > > gridVector;
         loadTorsionTorsionGrid( gridVector );
-        force.setTorsionTorsionGrid( ii, gridVector );
+        force1.setTorsionTorsionGrid( ii, gridVector );
     }
-    for( int ii = 0; ii < 5; ii++ ){
-        force.addTorsionTorsion( ii, ii+1,ii+3, ii+4, ii+5, ( (ii % 2 ) ? 1 : 0), (ii % 4) );
+    for( unsigned int ii = 0; ii < 5; ii++ ){
+        force1.addTorsionTorsion( ii, ii+1,ii+3, ii+4, ii+5, ( (ii % 2 ) ? 1 : 0), (ii % 4) );
     }
 
     // Serialize and then deserialize it.
 
     stringstream buffer;
-    XmlSerializer::serialize<AmoebaTorsionTorsionForce>(&force, "Force", buffer);
+    XmlSerializer::serialize<AmoebaTorsionTorsionForce>(&force1, "Force", buffer);
 
-if( 0 ){
-FILE* filePtr = fopen("TorsionTorsion.xml", "w" );
-(void) fprintf( filePtr, "%s", buffer.str().c_str() );
-(void) fclose( filePtr );
-}
+    if( 0 ){
+        FILE* filePtr = fopen("TorsionTorsion.xml", "w" );
+        (void) fprintf( filePtr, "%s", buffer.str().c_str() );
+        (void) fclose( filePtr );
+    }
 
     AmoebaTorsionTorsionForce* copy = XmlSerializer::deserialize<AmoebaTorsionTorsionForce>(buffer);
 
-    // Compare the two forces to see if they are identical.  
+    // Compare the two force1s to see if they are identical.  
 
     AmoebaTorsionTorsionForce & force2 = *copy;
-    ASSERT_EQUAL(force.getNumTorsionTorsions(), force2.getNumTorsionTorsions());
-    for (int i = 0; i < force.getNumTorsionTorsions(); i++) {
+    ASSERT_EQUAL(force1.getNumTorsionTorsions(), force2.getNumTorsionTorsions());
+    for (unsigned int ii = 0; ii < force1.getNumTorsionTorsions(); ii++) {
 
         int a1, a2, a3, a4, a5, aChiral, aGridIndex, b1, b2, b3, b4, b5, bChiral, bGridIndex;
 
-        force.getTorsionTorsionParameters( i, a1, a2, a3, a4, a5, aChiral, aGridIndex);
-        force2.getTorsionTorsionParameters( i, b1, b2, b3, b4, b5, bChiral, bGridIndex);
+        force1.getTorsionTorsionParameters( ii, a1, a2, a3, a4, a5, aChiral, aGridIndex);
+        force2.getTorsionTorsionParameters( ii, b1, b2, b3, b4, b5, bChiral, bGridIndex);
 
         ASSERT_EQUAL(a1, b1);
         ASSERT_EQUAL(a2, b2);
@@ -120,10 +120,10 @@ FILE* filePtr = fopen("TorsionTorsion.xml", "w" );
         ASSERT_EQUAL(aGridIndex, bGridIndex );
     }
 
-    ASSERT_EQUAL(force.getNumTorsionTorsionGrids(), force2.getNumTorsionTorsionGrids());
-    for (int i = 0; i < force.getNumTorsionTorsionGrids(); i++) {
-        const std::vector< std::vector< std::vector<double> > >& grid1 = force.getTorsionTorsionGrid( i );
-        const std::vector< std::vector< std::vector<double> > >& grid2 = force2.getTorsionTorsionGrid( i );
+    ASSERT_EQUAL(force1.getNumTorsionTorsionGrids(), force2.getNumTorsionTorsionGrids());
+    for (unsigned int ii = 0; ii < force1.getNumTorsionTorsionGrids(); ii++) {
+        const std::vector< std::vector< std::vector<double> > >& grid1 = force1.getTorsionTorsionGrid( ii );
+        const std::vector< std::vector< std::vector<double> > >& grid2 = force2.getTorsionTorsionGrid( ii );
         compareGrids(grid1, grid2 );
     }
 

plugins/amoeba/serialization/tests/TestSerializeAmoebaUreyBradleyForce.cpp

@@ -41,30 +41,32 @@ using namespace std;
 void testSerialization() {
     // Create a Force.
 
-    AmoebaUreyBradleyForce force;
-    force.setAmoebaGlobalUreyBradleyCubic( 12.3 );
-    force.setAmoebaGlobalUreyBradleyQuartic( 98.7 );
-    force.addUreyBradley(0, 1, 1.0, 2.0);
-    force.addUreyBradley(0, 2, 2.0, 2.1);
-    force.addUreyBradley(2, 3, 3.0, 2.2);
-    force.addUreyBradley(5, 1, 4.0, 2.3);
+    AmoebaUreyBradleyForce force1;
+    force1.setAmoebaGlobalUreyBradleyCubic( 12.3 );
+    force1.setAmoebaGlobalUreyBradleyQuartic( 98.7 );
+    force1.addUreyBradley(0, 1, 1.0, 2.0);
+    force1.addUreyBradley(0, 2, 2.0, 2.1);
+    force1.addUreyBradley(2, 3, 3.0, 2.2);
+    force1.addUreyBradley(5, 1, 4.0, 2.3);
 
     // Serialize and then deserialize it.
 
     stringstream buffer;
-    XmlSerializer::serialize<AmoebaUreyBradleyForce>(&force, "Force", buffer);
+    XmlSerializer::serialize<AmoebaUreyBradleyForce>(&force1, "Force", buffer);
     AmoebaUreyBradleyForce* copy = XmlSerializer::deserialize<AmoebaUreyBradleyForce>(buffer);
 
     // Compare the two forces to see if they are identical.  
     AmoebaUreyBradleyForce& force2 = *copy;
-    ASSERT_EQUAL(force.getAmoebaGlobalUreyBradleyCubic(), force2.getAmoebaGlobalUreyBradleyCubic());
-    ASSERT_EQUAL(force.getAmoebaGlobalUreyBradleyQuartic(), force2.getAmoebaGlobalUreyBradleyQuartic());
-    ASSERT_EQUAL(force.getNumInteractions(), force2.getNumInteractions());
-    for (int i = 0; i < force.getNumInteractions(); i++) {
+    ASSERT_EQUAL(force1.getAmoebaGlobalUreyBradleyCubic(), force2.getAmoebaGlobalUreyBradleyCubic());
+    ASSERT_EQUAL(force1.getAmoebaGlobalUreyBradleyQuartic(), force2.getAmoebaGlobalUreyBradleyQuartic());
+    ASSERT_EQUAL(force1.getNumInteractions(), force2.getNumInteractions());
+    for (unsigned int ii = 0; ii < force1.getNumInteractions(); ii++) {
         int a1, a2, b1, b2;
         double da, db, ka, kb;
-        force.getUreyBradleyParameters(i, a1, a2, da, ka);
-        force2.getUreyBradleyParameters(i, b1, b2, db, kb);
+
+        force1.getUreyBradleyParameters(ii, a1, a2, da, ka);
+        force2.getUreyBradleyParameters(ii, b1, b2, db, kb);
+
         ASSERT_EQUAL(a1, b1);
         ASSERT_EQUAL(a2, b2);
         ASSERT_EQUAL(da, db);

plugins/amoeba/serialization/tests/TestSerializeAmoebaVdwForce.cpp

@@ -41,67 +41,78 @@ using namespace std;
 void testSerialization() {
     // Create a Force.
 
-    AmoebaVdwForce force;
-    force.setSigmaCombiningRule( "GEOMETRIC" );
-    force.setEpsilonCombiningRule( "GEOMETRIC" );
-    force.setCutoff( 0.9 );
-    force.setUseNeighborList( 1 );
-    force.setPBC( 1 );
-
-    force.addParticle(0, 1, 1.0, 2.0, 0.9);
-    force.addParticle(1, 0, 1.1, 2.1, 0.9);
-    force.addParticle(2, 3, 1.3, 4.1, 0.9);
+    AmoebaVdwForce force1;
+    force1.setSigmaCombiningRule(   "GEOMETRIC" );
+    force1.setEpsilonCombiningRule( "GEOMETRIC" );
+    force1.setCutoff( 0.9 );
+    force1.setUseNeighborList( 1 );
+    force1.setPBC( 1 );
+
+    force1.addParticle(0, 1, 1.0, 2.0, 0.9);
+    force1.addParticle(1, 0, 1.1, 2.1, 0.9);
+    force1.addParticle(2, 3, 1.3, 4.1, 0.9);
     for( unsigned int ii = 0; ii < 3; ii++ ){
         std::vector< int > exclusions;
         exclusions.push_back( ii );
         exclusions.push_back( ii + 1 );
         exclusions.push_back( ii + 10 );
-        force.setParticleExclusions( ii, exclusions );
+        force1.setParticleExclusions( ii, exclusions );
     }
 
     // Serialize and then deserialize it.
 
     stringstream buffer;
-    XmlSerializer::serialize<AmoebaVdwForce>(&force, "Force", buffer);
-if( 1 ){
-FILE* filePtr = fopen("Vdw.xml", "w" );
-(void) fprintf( filePtr, "%s", buffer.str().c_str() );
-(void) fclose( filePtr );
-}
+    XmlSerializer::serialize<AmoebaVdwForce>(&force1, "Force", buffer);
+
+    if( 0 ){
+        FILE* filePtr = fopen("Vdw.xml", "w" );
+        (void) fprintf( filePtr, "%s", buffer.str().c_str() );
+        (void) fclose( filePtr );
+    }
 
     AmoebaVdwForce* copy = XmlSerializer::deserialize<AmoebaVdwForce>(buffer);
 
     // Compare the two forces to see if they are identical.  
     AmoebaVdwForce& force2 = *copy;
-    ASSERT_EQUAL(force.getSigmaCombiningRule(), force2.getSigmaCombiningRule());
-    ASSERT_EQUAL(force.getEpsilonCombiningRule(), force2.getEpsilonCombiningRule());
-    ASSERT_EQUAL(force.getCutoff(), force2.getCutoff());
-    ASSERT_EQUAL(force.getUseNeighborList(), force2.getUseNeighborList());
-    ASSERT_EQUAL(force.getPBC(), force2.getPBC());
-    ASSERT_EQUAL(force.getNumParticles(), force2.getNumParticles());
-    for (int i = 0; i < force.getNumParticles(); i++) {
+
+    ASSERT_EQUAL(force1.getSigmaCombiningRule(),    force2.getSigmaCombiningRule());
+    ASSERT_EQUAL(force1.getEpsilonCombiningRule(),  force2.getEpsilonCombiningRule());
+    ASSERT_EQUAL(force1.getCutoff(),                force2.getCutoff());
+    ASSERT_EQUAL(force1.getUseNeighborList(),       force2.getUseNeighborList());
+    ASSERT_EQUAL(force1.getPBC(),                   force2.getPBC());
+
+    ASSERT_EQUAL(force1.getNumParticles(),          force2.getNumParticles());
+
+    for (unsigned int ii = 0; ii < force1.getNumParticles(); ii++) {
+
         int ivIndex1, classIndex1;
         int ivIndex2, classIndex2;
+
         double sigma1, epsilon1, reductionFactor1;
         double sigma2, epsilon2, reductionFactor2;
-        force.getParticleParameters( i, ivIndex1, classIndex1, sigma1, epsilon1, reductionFactor1 );
-        force2.getParticleParameters(i, ivIndex2, classIndex2, sigma2, epsilon2, reductionFactor2 );
+
+        force1.getParticleParameters( ii, ivIndex1, classIndex1, sigma1, epsilon1, reductionFactor1 );
+        force2.getParticleParameters( ii, ivIndex2, classIndex2, sigma2, epsilon2, reductionFactor2 );
+
         ASSERT_EQUAL(ivIndex1,          ivIndex2 );
         ASSERT_EQUAL(classIndex1,       classIndex2 );
         ASSERT_EQUAL(sigma1,            sigma2);
         ASSERT_EQUAL(epsilon1,          epsilon2);
         ASSERT_EQUAL(reductionFactor1,  reductionFactor2);
     }
-    for (int i = 0; i < force.getNumParticles(); i++) {
+    for (unsigned int ii = 0; ii < force1.getNumParticles(); ii++) {
+
         std::vector< int > exclusions1;
         std::vector< int > exclusions2;
-        force.getParticleExclusions(  i, exclusions1 );
-        force2.getParticleExclusions( i, exclusions2 );
+
+        force1.getParticleExclusions( ii, exclusions1 );
+        force2.getParticleExclusions( ii, exclusions2 );
+
         ASSERT_EQUAL(exclusions1.size(), exclusions2.size());
-        for (unsigned int ii = 0; ii < exclusions1.size(); ii++) {
+        for (unsigned int jj = 0; jj < exclusions1.size(); jj++) {
             int hit = 0;
-            for (unsigned int jj = 0; jj < exclusions2.size() && hit == 0; jj++) {
-                if( exclusions2[jj] == exclusions1[ii] )hit++;
+            for (unsigned int kk = 0; kk < exclusions2.size(); kk++) {
+                if( exclusions2[jj] == exclusions1[kk] )hit++;
             }
             ASSERT_EQUAL(hit, 1);
         }

plugins/amoeba/serialization/tests/TestSerializeAmoebaWcaDispersionForce.cpp

+/* -------------------------------------------------------------------------- *
+ *                                OpenMMAmoeba                                *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2010 Stanford University and the Authors.           *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#include "../../../tests/AssertionUtilities.h"
+#include "openmm/AmoebaWcaDispersionForce.h"
+#include "openmm/serialization/XmlSerializer.h"
+#include <iostream>
+#include <sstream>
+
+using namespace OpenMM;
+using namespace std;
+
+void testSerialization() {
+    // Create a Force.
+
+    AmoebaWcaDispersionForce force1;
+    force1.setEpso(    1.0 );
+    force1.setEpsh(    1.1 );
+    force1.setRmino(   1.2 );
+    force1.setRminh(   1.3 );
+    force1.setAwater(  1.4 );
+    force1.setShctd(   1.5 );
+    force1.setDispoff( 1.6 );
+    force1.setSlevy(   1.7 );
+
+    force1.addParticle(1.0, 2.0);
+    force1.addParticle(1.1, 2.1);
+    force1.addParticle(1.2, 2.2);
+
+    // Serialize and then deserialize it.
+
+    stringstream buffer;
+    XmlSerializer::serialize<AmoebaWcaDispersionForce>(&force1, "Force", buffer);
+    if( 1 ){
+        FILE* filePtr = fopen("WcaDispersion.xml", "w" );
+        (void) fprintf( filePtr, "%s", buffer.str().c_str() );
+        (void) fclose( filePtr );
+    }
+
+    AmoebaWcaDispersionForce* copy = XmlSerializer::deserialize<AmoebaWcaDispersionForce>(buffer);
+
+    // Compare the two forces to see if they are identical.  
+
+    AmoebaWcaDispersionForce& force2 = *copy;
+
+    ASSERT_EQUAL(force1.getEpso(),    force2.getEpso());
+    ASSERT_EQUAL(force1.getEpsh(),    force2.getEpsh());
+    ASSERT_EQUAL(force1.getRmino(),   force2.getRmino());
+    ASSERT_EQUAL(force1.getRminh(),   force2.getRminh());
+    ASSERT_EQUAL(force1.getAwater(),  force2.getAwater());
+    ASSERT_EQUAL(force1.getShctd(),   force2.getShctd());
+    ASSERT_EQUAL(force1.getDispoff(), force2.getDispoff());
+    ASSERT_EQUAL(force1.getSlevy(),   force2.getSlevy());
+
+    ASSERT_EQUAL(force1.getNumParticles(), force2.getNumParticles());
+    for (unsigned int ii = 0; ii < force1.getNumParticles(); ii++) {
+
+        double radius1, epsilon1;
+        double radius2, epsilon2;
+
+        force1.getParticleParameters( ii, radius1, epsilon1 );
+        force2.getParticleParameters( ii, radius2, epsilon2 );
+
+        ASSERT_EQUAL(radius1,  radius2);
+        ASSERT_EQUAL(epsilon1, epsilon2);
+    }
+}
+
+int main() {
+    try {
+        testSerialization();
+    }
+    catch(const exception& e) {
+        cout << "exception: " << e.what() << endl;
+        return 1;
+    }
+    cout << "Done" << endl;
+    return 0;
+}
+