Skip to content

GitLab

Commit 1877eb67 authored by Mark Friedrichs's avatar Mark Friedrichs
Browse files

edit/add AMOEBA serialization proxies

parent 67971bf4
Show whitespace changes
Inline Side-by-side
Showing with 304 additions and 141 deletions
plugins/amoeba/serialization/tests/TestSerializeAmoebaOutOfPlaneBendForce.cpp
View file @ 1877eb67
......@@ -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
View file @ 1877eb67
......@@ -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
View file @ 1877eb67
#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
View file @ 1877eb67
......@@ -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
View file @ 1877eb67
......@@ -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
View file @ 1877eb67
......@@ -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
View file @ 1877eb67
......@@ -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 0 → 100644
View file @ 1877eb67
/* -------------------------------------------------------------------------- *
* 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;
}
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