Skip to content

GitLab

"platforms/cuda-old/src/CudaKernelFactory.cpp" did not exist on "10379a9a4405bc4efa5f1ba0ab93b85b21404e44"
Commit c6ebf6e2 authored by Peter Eastman's avatar Peter Eastman
Browse files

Removed the word "harmonic" from lots of places it didn't belong, including class and method names

parent 58b094ce
Hide whitespace changes
Inline Side-by-side
Showing with 214 additions and 214 deletions
plugins/amoeba/platforms/reference/src/SimTKReference/AmoebaReferenceHarmonicBondForce.h → plugins/amoeba/platforms/reference/src/SimTKReference/AmoebaReferenceBondForce.h
View file @ c6ebf6e2
...@@ -22,15 +22,15 @@ ...@@ -22,15 +22,15 @@
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/ */
#ifndef __AmoebaReferenceHarmonicBondForce_H__ #ifndef __AmoebaReferenceBondForce_H__
#define __AmoebaReferenceHarmonicBondForce_H__ #define __AmoebaReferenceBondForce_H__
#include "SimTKUtilities/RealVec.h" #include "SimTKUtilities/RealVec.h"
#include <vector> #include <vector>
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
class AmoebaReferenceHarmonicBondForce { class AmoebaReferenceBondForce {
public: public:
...@@ -40,7 +40,7 @@ public: ...@@ -40,7 +40,7 @@ public:
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
AmoebaReferenceHarmonicBondForce( ){}; AmoebaReferenceBondForce( ){};
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -48,12 +48,12 @@ public: ...@@ -48,12 +48,12 @@ public:
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
~AmoebaReferenceHarmonicBondForce( ){}; ~AmoebaReferenceBondForce( ){};
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
Calculate Amoeba harmonic bond ixns (force and energy) Calculate Amoeba bond ixns (force and energy)
@param numBonds number of bonds @param numBonds number of bonds
@param posData particle positions @param posData particle positions
...@@ -81,7 +81,7 @@ private: ...@@ -81,7 +81,7 @@ private:
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
Calculate Amoeba harmonic bond ixns (force and energy) Calculate Amoeba bond ixns (force and energy)
@param positionAtomA Cartesian coordinates of atom A @param positionAtomA Cartesian coordinates of atom A
@param positionAtomB Cartesian coordinates of atom B @param positionAtomB Cartesian coordinates of atom B
...@@ -104,4 +104,4 @@ private: ...@@ -104,4 +104,4 @@ private:
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
#endif // _AmoebaReferenceHarmonicBondForce___ #endif // _AmoebaReferenceBondForce___
plugins/amoeba/platforms/reference/src/SimTKReference/AmoebaReferenceHarmonicInPlaneAngleForce.cpp → plugins/amoeba/platforms/reference/src/SimTKReference/AmoebaReferenceInPlaneAngleForce.cpp
View file @ c6ebf6e2
...@@ -23,7 +23,7 @@ ...@@ -23,7 +23,7 @@
*/ */
#include "AmoebaReferenceForce.h" #include "AmoebaReferenceForce.h"
#include "AmoebaReferenceHarmonicInPlaneAngleForce.h" #include "AmoebaReferenceInPlaneAngleForce.h"
using std::vector; using std::vector;
using OpenMM::RealVec; using OpenMM::RealVec;
...@@ -46,7 +46,7 @@ using OpenMM::RealVec; ...@@ -46,7 +46,7 @@ using OpenMM::RealVec;
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM AmoebaReferenceHarmonicInPlaneAngleForce::getPrefactorsGivenAngleCosine( RealOpenMM cosine, RealOpenMM AmoebaReferenceInPlaneAngleForce::getPrefactorsGivenAngleCosine( RealOpenMM cosine,
RealOpenMM idealAngle, RealOpenMM angleK, RealOpenMM idealAngle, RealOpenMM angleK,
RealOpenMM angleCubic, RealOpenMM angleQuartic, RealOpenMM angleCubic, RealOpenMM angleQuartic,
RealOpenMM anglePentic, RealOpenMM angleSextic, RealOpenMM anglePentic, RealOpenMM angleSextic,
...@@ -62,7 +62,7 @@ RealOpenMM AmoebaReferenceHarmonicInPlaneAngleForce::getPrefactorsGivenAngleCosi ...@@ -62,7 +62,7 @@ RealOpenMM AmoebaReferenceHarmonicInPlaneAngleForce::getPrefactorsGivenAngleCosi
static const RealOpenMM five = 5.0; static const RealOpenMM five = 5.0;
static const RealOpenMM six = 6.0; static const RealOpenMM six = 6.0;
// static const std::string methodName = "AmoebaReferenceHarmonicInPlaneAngleForce::getPrefactorsGivenAngleCosine"; // static const std::string methodName = "AmoebaReferenceInPlaneAngleForce::getPrefactorsGivenAngleCosine";
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -96,7 +96,7 @@ RealOpenMM AmoebaReferenceHarmonicInPlaneAngleForce::getPrefactorsGivenAngleCosi ...@@ -96,7 +96,7 @@ RealOpenMM AmoebaReferenceHarmonicInPlaneAngleForce::getPrefactorsGivenAngleCosi
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
Calculate Amoeba harmonic angle ixn (force and energy) Calculate Amoeba angle ixn (force and energy)
@param positionAtomA Cartesian coordinates of atom A @param positionAtomA Cartesian coordinates of atom A
@param positionAtomB Cartesian coordinates of atom B @param positionAtomB Cartesian coordinates of atom B
...@@ -114,7 +114,7 @@ RealOpenMM AmoebaReferenceHarmonicInPlaneAngleForce::getPrefactorsGivenAngleCosi ...@@ -114,7 +114,7 @@ RealOpenMM AmoebaReferenceHarmonicInPlaneAngleForce::getPrefactorsGivenAngleCosi
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM AmoebaReferenceHarmonicInPlaneAngleForce::calculateAngleIxn( const RealVec& positionAtomA, const RealVec& positionAtomB, RealOpenMM AmoebaReferenceInPlaneAngleForce::calculateAngleIxn( const RealVec& positionAtomA, const RealVec& positionAtomB,
const RealVec& positionAtomC, const RealVec& positionAtomD, const RealVec& positionAtomC, const RealVec& positionAtomD,
RealOpenMM angle, RealOpenMM angleK, RealOpenMM angle, RealOpenMM angleK,
RealOpenMM angleCubic, RealOpenMM angleQuartic, RealOpenMM angleCubic, RealOpenMM angleQuartic,
...@@ -123,7 +123,7 @@ RealOpenMM AmoebaReferenceHarmonicInPlaneAngleForce::calculateAngleIxn( const Re ...@@ -123,7 +123,7 @@ RealOpenMM AmoebaReferenceHarmonicInPlaneAngleForce::calculateAngleIxn( const Re
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
//static const std::string methodName = "AmoebaReferenceHarmonicInPlaneAngleForce::calculateHarmonicForce"; //static const std::string methodName = "AmoebaReferenceInPlaneAngleForce::calculateAngleIxn";
static const RealOpenMM zero = 0.0; static const RealOpenMM zero = 0.0;
static const RealOpenMM one = 1.0; static const RealOpenMM one = 1.0;
...@@ -245,7 +245,7 @@ RealOpenMM AmoebaReferenceHarmonicInPlaneAngleForce::calculateAngleIxn( const Re ...@@ -245,7 +245,7 @@ RealOpenMM AmoebaReferenceHarmonicInPlaneAngleForce::calculateAngleIxn( const Re
} }
RealOpenMM AmoebaReferenceHarmonicInPlaneAngleForce::calculateForceAndEnergy( int numAngles, vector<RealVec>& posData, RealOpenMM AmoebaReferenceInPlaneAngleForce::calculateForceAndEnergy( int numAngles, vector<RealVec>& posData,
const std::vector<int>& particle1, const std::vector<int>& particle1,
const std::vector<int>& particle2, const std::vector<int>& particle2,
const std::vector<int>& particle3, const std::vector<int>& particle3,
......
plugins/amoeba/platforms/reference/src/SimTKReference/AmoebaReferenceHarmonicInPlaneAngleForce.h → plugins/amoeba/platforms/reference/src/SimTKReference/AmoebaReferenceInPlaneAngleForce.h
View file @ c6ebf6e2
...@@ -22,15 +22,15 @@ ...@@ -22,15 +22,15 @@
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/ */
#ifndef __AmoebaReferenceHarmonicInPlaneAngleForce_H__ #ifndef __AmoebaReferenceInPlaneAngleForce_H__
#define __AmoebaReferenceHarmonicInPlaneAngleForce_H__ #define __AmoebaReferenceInPlaneAngleForce_H__
#include "SimTKUtilities/RealVec.h" #include "SimTKUtilities/RealVec.h"
#include <vector> #include <vector>
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
class AmoebaReferenceHarmonicInPlaneAngleForce { class AmoebaReferenceInPlaneAngleForce {
public: public:
...@@ -40,7 +40,7 @@ public: ...@@ -40,7 +40,7 @@ public:
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
AmoebaReferenceHarmonicInPlaneAngleForce( ){}; AmoebaReferenceInPlaneAngleForce( ){};
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -48,11 +48,11 @@ public: ...@@ -48,11 +48,11 @@ public:
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
~AmoebaReferenceHarmonicInPlaneAngleForce( ){}; ~AmoebaReferenceInPlaneAngleForce( ){};
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
Calculate Amoeba harmonic in-plane angle ixns (force and energy) Calculate Amoeba in-plane angle ixns (force and energy)
@param numBonds number of angles @param numBonds number of angles
@param posData particle positions @param posData particle positions
...@@ -80,10 +80,10 @@ public: ...@@ -80,10 +80,10 @@ public:
const std::vector<int>& particle4, const std::vector<int>& particle4,
const std::vector<RealOpenMM>& angle, const std::vector<RealOpenMM>& angle,
const std::vector<RealOpenMM>& kQuadratic, const std::vector<RealOpenMM>& kQuadratic,
RealOpenMM globalHarmonicAngleCubic, RealOpenMM globalAngleCubic,
RealOpenMM globalHarmonicAngleQuartic, RealOpenMM globalAngleQuartic,
RealOpenMM globalHarmonicAnglePentic, RealOpenMM globalAnglePentic,
RealOpenMM globalHarmonicAngleSextic, RealOpenMM globalAngleSextic,
std::vector<OpenMM::RealVec>& forceData ) const; std::vector<OpenMM::RealVec>& forceData ) const;
private: private:
...@@ -113,7 +113,7 @@ private: ...@@ -113,7 +113,7 @@ private:
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
Calculate Amoeba harmonic angle ixn (force and energy) Calculate Amoeba angle ixn (force and energy)
@param positionAtomA Cartesian coordinates of atom A @param positionAtomA Cartesian coordinates of atom A
@param positionAtomB Cartesian coordinates of atom B @param positionAtomB Cartesian coordinates of atom B
...@@ -142,4 +142,4 @@ private: ...@@ -142,4 +142,4 @@ private:
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
#endif // _AmoebaReferenceHarmonicInPlaneAngleForce___ #endif // _AmoebaReferenceInPlaneAngleForce___
plugins/amoeba/platforms/reference/src/SimTKReference/AmoebaReferenceOutOfPlaneBendForce.cpp
View file @ c6ebf6e2
...@@ -57,7 +57,7 @@ RealOpenMM AmoebaReferenceOutOfPlaneBendForce::calculateOutOfPlaneBendIxn( const ...@@ -57,7 +57,7 @@ RealOpenMM AmoebaReferenceOutOfPlaneBendForce::calculateOutOfPlaneBendIxn( const
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
//static const std::string methodName = "AmoebaReferenceOutOfPlaneBendForce::calculateHarmonicForce"; //static const std::string methodName = "AmoebaReferenceOutOfPlaneBendForce::calculateOutOfPlaneBendIxn";
static const RealOpenMM zero = 0.0; static const RealOpenMM zero = 0.0;
static const RealOpenMM one = 1.0; static const RealOpenMM one = 1.0;
......
plugins/amoeba/platforms/reference/src/SimTKReference/AmoebaReferencePiTorsionForce.cpp
View file @ c6ebf6e2
...@@ -53,7 +53,7 @@ RealOpenMM AmoebaReferencePiTorsionForce::calculatePiTorsionIxn( const RealVec& ...@@ -53,7 +53,7 @@ RealOpenMM AmoebaReferencePiTorsionForce::calculatePiTorsionIxn( const RealVec&
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
//static const std::string methodName = "AmoebaReferencePiTorsionForce::calculateHarmonicForce"; //static const std::string methodName = "AmoebaReferencePiTorsionForce::calculatePiTorsionIxn";
static const RealOpenMM zero = 0.0; static const RealOpenMM zero = 0.0;
static const RealOpenMM one = 1.0; static const RealOpenMM one = 1.0;
......
plugins/amoeba/platforms/reference/src/SimTKReference/AmoebaReferenceStretchBendForce.cpp
View file @ c6ebf6e2
...@@ -57,7 +57,7 @@ RealOpenMM AmoebaReferenceStretchBendForce::calculateStretchBendIxn( const RealV ...@@ -57,7 +57,7 @@ RealOpenMM AmoebaReferenceStretchBendForce::calculateStretchBendIxn( const RealV
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
//static const std::string methodName = "AmoebaReferenceStretchBendForce::calculateHarmonicForce"; //static const std::string methodName = "AmoebaReferenceStretchBendForce::calculateStretchBendIxn";
static const RealOpenMM zero = 0.0; static const RealOpenMM zero = 0.0;
static const RealOpenMM one = 1.0; static const RealOpenMM one = 1.0;
......
plugins/amoeba/platforms/reference/tests/TestReferenceAmoebaHarmonicAngleForce.cpp → plugins/amoeba/platforms/reference/tests/TestReferenceAmoebaAngleForce.cpp
View file @ c6ebf6e2
...@@ -30,7 +30,7 @@ ...@@ -30,7 +30,7 @@
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
/** /**
* This tests the Cuda implementation of CudaAmoebaHarmonicAngleForce. * This tests the Cuda implementation of CudaAmoebaAngleForce.
*/ */
#include "openmm/internal/AssertionUtilities.h" #include "openmm/internal/AssertionUtilities.h"
...@@ -117,21 +117,21 @@ static void getPrefactorsGivenAngleCosine( double cosine, double idealAngle, dou ...@@ -117,21 +117,21 @@ static void getPrefactorsGivenAngleCosine( double cosine, double idealAngle, dou
return; return;
} }
static void computeAmoebaHarmonicAngleForce(int bondIndex, std::vector<Vec3>& positions, AmoebaHarmonicAngleForce& amoebaHarmonicAngleForce, static void computeAmoebaAngleForce(int bondIndex, std::vector<Vec3>& positions, AmoebaAngleForce& AmoebaAngleForce,
std::vector<Vec3>& forces, double* energy, FILE* log ) { std::vector<Vec3>& forces, double* energy, FILE* log ) {
int particle1, particle2, particle3; int particle1, particle2, particle3;
double idealAngle; double idealAngle;
double quadraticK; double quadraticK;
amoebaHarmonicAngleForce.getAngleParameters(bondIndex, particle1, particle2, particle3, idealAngle, quadraticK ); AmoebaAngleForce.getAngleParameters(bondIndex, particle1, particle2, particle3, idealAngle, quadraticK );
double cubicK = amoebaHarmonicAngleForce.getAmoebaGlobalHarmonicAngleCubic(); double cubicK = AmoebaAngleForce.getAmoebaGlobalAngleCubic();
double quarticK = amoebaHarmonicAngleForce.getAmoebaGlobalHarmonicAngleQuartic(); double quarticK = AmoebaAngleForce.getAmoebaGlobalAngleQuartic();
double penticK = amoebaHarmonicAngleForce.getAmoebaGlobalHarmonicAnglePentic(); double penticK = AmoebaAngleForce.getAmoebaGlobalAnglePentic();
double sexticK = amoebaHarmonicAngleForce.getAmoebaGlobalHarmonicAngleSextic(); double sexticK = AmoebaAngleForce.getAmoebaGlobalAngleSextic();
#ifdef AMOEBA_DEBUG #ifdef AMOEBA_DEBUG
if( log ){ if( log ){
(void) fprintf( log, "computeAmoebaHarmonicAngleForce: bond %d [%d %d %d] ang=%10.3f k=%10.3f [%10.3e %10.3e %10.3e %10.3e]\n", (void) fprintf( log, "computeAmoebaAngleForce: bond %d [%d %d %d] ang=%10.3f k=%10.3f [%10.3e %10.3e %10.3e %10.3e]\n",
bondIndex, particle1, particle2, particle3, idealAngle, quadraticK, cubicK, quarticK, penticK, sexticK ); bondIndex, particle1, particle2, particle3, idealAngle, quadraticK, cubicK, quarticK, penticK, sexticK );
(void) fflush( log ); (void) fflush( log );
} }
...@@ -198,7 +198,7 @@ static void computeAmoebaHarmonicAngleForce(int bondIndex, std::vector<Vec3>& p ...@@ -198,7 +198,7 @@ static void computeAmoebaHarmonicAngleForce(int bondIndex, std::vector<Vec3>& p
*energy += energyTerm; *energy += energyTerm;
} }
static void computeAmoebaHarmonicAngleForces( Context& context, AmoebaHarmonicAngleForce& amoebaHarmonicAngleForce, static void computeAmoebaAngleForces( Context& context, AmoebaAngleForce& AmoebaAngleForce,
std::vector<Vec3>& expectedForces, double* expectedEnergy, FILE* log ) { std::vector<Vec3>& expectedForces, double* expectedEnergy, FILE* log ) {
// get positions and zero forces // get positions and zero forces
...@@ -214,13 +214,13 @@ static void computeAmoebaHarmonicAngleForces( Context& context, AmoebaHarmonicAn ...@@ -214,13 +214,13 @@ static void computeAmoebaHarmonicAngleForces( Context& context, AmoebaHarmonicAn
// calculates forces/energy // calculates forces/energy
*expectedEnergy = 0.0; *expectedEnergy = 0.0;
for( int ii = 0; ii < amoebaHarmonicAngleForce.getNumAngles(); ii++ ){ for( int ii = 0; ii < AmoebaAngleForce.getNumAngles(); ii++ ){
computeAmoebaHarmonicAngleForce(ii, positions, amoebaHarmonicAngleForce, expectedForces, expectedEnergy, log ); computeAmoebaAngleForce(ii, positions, AmoebaAngleForce, expectedForces, expectedEnergy, log );
} }
#ifdef AMOEBA_DEBUG #ifdef AMOEBA_DEBUG
if( log ){ if( log ){
(void) fprintf( log, "computeAmoebaHarmonicAngleForces: expected energy=%14.7e\n", *expectedEnergy ); (void) fprintf( log, "computeAmoebaAngleForces: expected energy=%14.7e\n", *expectedEnergy );
for( unsigned int ii = 0; ii < positions.size(); ii++ ){ for( unsigned int ii = 0; ii < positions.size(); ii++ ){
(void) fprintf( log, "%6u [%14.7e %14.7e %14.7e]\n", ii, expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2] ); (void) fprintf( log, "%6u [%14.7e %14.7e %14.7e]\n", ii, expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2] );
} }
...@@ -231,19 +231,19 @@ static void computeAmoebaHarmonicAngleForces( Context& context, AmoebaHarmonicAn ...@@ -231,19 +231,19 @@ static void computeAmoebaHarmonicAngleForces( Context& context, AmoebaHarmonicAn
} }
void compareWithExpectedForceAndEnergy( Context& context, AmoebaHarmonicAngleForce& amoebaHarmonicAngleForce, void compareWithExpectedForceAndEnergy( Context& context, AmoebaAngleForce& AmoebaAngleForce,
double tolerance, const std::string& idString, FILE* log) { double tolerance, const std::string& idString, FILE* log) {
std::vector<Vec3> expectedForces; std::vector<Vec3> expectedForces;
double expectedEnergy; double expectedEnergy;
computeAmoebaHarmonicAngleForces( context, amoebaHarmonicAngleForce, expectedForces, &expectedEnergy, log ); computeAmoebaAngleForces( context, AmoebaAngleForce, expectedForces, &expectedEnergy, log );
State state = context.getState(State::Forces | State::Energy); State state = context.getState(State::Forces | State::Energy);
const std::vector<Vec3> forces = state.getForces(); const std::vector<Vec3> forces = state.getForces();
#ifdef AMOEBA_DEBUG #ifdef AMOEBA_DEBUG
if( log ){ if( log ){
(void) fprintf( log, "computeAmoebaHarmonicAngleForces: expected energy=%14.7e %14.7e\n", expectedEnergy, state.getPotentialEnergy() ); (void) fprintf( log, "computeAmoebaAngleForces: expected energy=%14.7e %14.7e\n", expectedEnergy, state.getPotentialEnergy() );
for( unsigned int ii = 0; ii < forces.size(); ii++ ){ for( unsigned int ii = 0; ii < forces.size(); ii++ ){
(void) fprintf( log, "%6u [%14.7e %14.7e %14.7e] [%14.7e %14.7e %14.7e]\n", ii, (void) fprintf( log, "%6u [%14.7e %14.7e %14.7e] [%14.7e %14.7e %14.7e]\n", ii,
expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2], forces[ii][0], forces[ii][1], forces[ii][2] ); expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2], forces[ii][0], forces[ii][1], forces[ii][2] );
...@@ -268,7 +268,7 @@ void testOneAngle( FILE* log ) { ...@@ -268,7 +268,7 @@ void testOneAngle( FILE* log ) {
LangevinIntegrator integrator(0.0, 0.1, 0.01); LangevinIntegrator integrator(0.0, 0.1, 0.01);
AmoebaHarmonicAngleForce* amoebaHarmonicAngleForce = new AmoebaHarmonicAngleForce(); AmoebaAngleForce* amoebaAngleForce = new AmoebaAngleForce();
double angle = 100.0; double angle = 100.0;
double quadraticK = 1.0; double quadraticK = 1.0;
...@@ -276,14 +276,14 @@ void testOneAngle( FILE* log ) { ...@@ -276,14 +276,14 @@ void testOneAngle( FILE* log ) {
double quarticK = 1.0e-02; double quarticK = 1.0e-02;
double penticK = 1.0e-03; double penticK = 1.0e-03;
double sexticK = 1.0e-04; double sexticK = 1.0e-04;
amoebaHarmonicAngleForce->addAngle(0, 1, 2, angle, quadraticK); amoebaAngleForce->addAngle(0, 1, 2, angle, quadraticK);
amoebaHarmonicAngleForce->setAmoebaGlobalHarmonicAngleCubic(cubicK); amoebaAngleForce->setAmoebaGlobalAngleCubic(cubicK);
amoebaHarmonicAngleForce->setAmoebaGlobalHarmonicAngleQuartic(quarticK); amoebaAngleForce->setAmoebaGlobalAngleQuartic(quarticK);
amoebaHarmonicAngleForce->setAmoebaGlobalHarmonicAnglePentic(penticK); amoebaAngleForce->setAmoebaGlobalAnglePentic(penticK);
amoebaHarmonicAngleForce->setAmoebaGlobalHarmonicAngleSextic(sexticK); amoebaAngleForce->setAmoebaGlobalAngleSextic(sexticK);
system.addForce(amoebaHarmonicAngleForce); system.addForce(amoebaAngleForce);
Context context(system, integrator, Platform::getPlatformByName( "Reference")); Context context(system, integrator, Platform::getPlatformByName( "Reference"));
std::vector<Vec3> positions(numberOfParticles); std::vector<Vec3> positions(numberOfParticles);
...@@ -293,16 +293,16 @@ void testOneAngle( FILE* log ) { ...@@ -293,16 +293,16 @@ void testOneAngle( FILE* log ) {
positions[2] = Vec3(0, 0, 1); positions[2] = Vec3(0, 0, 1);
context.setPositions(positions); context.setPositions(positions);
compareWithExpectedForceAndEnergy( context, *amoebaHarmonicAngleForce, TOL, "testOneAngle", log ); compareWithExpectedForceAndEnergy( context, *amoebaAngleForce, TOL, "testOneAngle", log );
} }
int main( int numberOfArguments, char* argv[] ) { int main( int numberOfArguments, char* argv[] ) {
try { try {
std::cout << "TestCudaAmoebaHarmonicAngleForce running test..." << std::endl; std::cout << "TestCudaAmoebaAngleForce running test..." << std::endl;
Platform::loadPluginsFromDirectory( Platform::getDefaultPluginsDirectory() ); Platform::loadPluginsFromDirectory( Platform::getDefaultPluginsDirectory() );
//FILE* log = fopen( "AmoebaHarmonicAngleForce.log", "w" );; //FILE* log = fopen( "AmoebaAngleForce.log", "w" );;
FILE* log = NULL; FILE* log = NULL;
//FILE* log = stderr; //FILE* log = stderr;
......
plugins/amoeba/platforms/reference/tests/TestReferenceAmoebaHarmonicBondForce.cpp → plugins/amoeba/platforms/reference/tests/TestReferenceAmoebaBondForce.cpp
View file @ c6ebf6e2
...@@ -30,7 +30,7 @@ ...@@ -30,7 +30,7 @@
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
/** /**
* This tests the Reference implementation of HarmonicBondForce. * This tests the Reference implementation of AmoebaBondForce.
*/ */
#include "openmm/internal/AssertionUtilities.h" #include "openmm/internal/AssertionUtilities.h"
...@@ -45,15 +45,15 @@ using namespace OpenMM; ...@@ -45,15 +45,15 @@ using namespace OpenMM;
const double TOL = 1e-5; const double TOL = 1e-5;
static void computeAmoebaHarmonicBondForce(int bondIndex, std::vector<Vec3>& positions, AmoebaHarmonicBondForce& amoebaHarmonicBondForce, static void computeAmoebaBondForce(int bondIndex, std::vector<Vec3>& positions, AmoebaBondForce& AmoebaBondForce,
std::vector<Vec3>& forces, double* energy ) { std::vector<Vec3>& forces, double* energy ) {
int particle1, particle2; int particle1, particle2;
double bondLength; double bondLength;
double quadraticK; double quadraticK;
double cubicK = amoebaHarmonicBondForce.getAmoebaGlobalHarmonicBondCubic(); double cubicK = AmoebaBondForce.getAmoebaGlobalBondCubic();
double quarticK = amoebaHarmonicBondForce.getAmoebaGlobalHarmonicBondQuartic(); double quarticK = AmoebaBondForce.getAmoebaGlobalBondQuartic();
amoebaHarmonicBondForce.getBondParameters(bondIndex, particle1, particle2, bondLength, quadraticK ); AmoebaBondForce.getBondParameters(bondIndex, particle1, particle2, bondLength, quadraticK );
double deltaR[3]; double deltaR[3];
double r2 = 0.0; double r2 = 0.0;
...@@ -81,7 +81,7 @@ static void computeAmoebaHarmonicBondForce(int bondIndex, std::vector<Vec3>& po ...@@ -81,7 +81,7 @@ static void computeAmoebaHarmonicBondForce(int bondIndex, std::vector<Vec3>& po
} }
static void computeAmoebaHarmonicBondForces( Context& context, AmoebaHarmonicBondForce& amoebaHarmonicBondForce, static void computeAmoebaBondForces( Context& context, AmoebaBondForce& AmoebaBondForce,
std::vector<Vec3>& expectedForces, double* expectedEnergy, FILE* log ) { std::vector<Vec3>& expectedForces, double* expectedEnergy, FILE* log ) {
// get positions and zero forces // get positions and zero forces
...@@ -97,12 +97,12 @@ static void computeAmoebaHarmonicBondForces( Context& context, AmoebaHarmonicBon ...@@ -97,12 +97,12 @@ static void computeAmoebaHarmonicBondForces( Context& context, AmoebaHarmonicBon
// calculates forces/energy // calculates forces/energy
*expectedEnergy = 0.0; *expectedEnergy = 0.0;
for( int ii = 0; ii < amoebaHarmonicBondForce.getNumBonds(); ii++ ){ for( int ii = 0; ii < AmoebaBondForce.getNumBonds(); ii++ ){
computeAmoebaHarmonicBondForce(ii, positions, amoebaHarmonicBondForce, expectedForces, expectedEnergy ); computeAmoebaBondForce(ii, positions, AmoebaBondForce, expectedForces, expectedEnergy );
} }
#ifdef AMOEBA_DEBUG #ifdef AMOEBA_DEBUG
if( log ){ if( log ){
(void) fprintf( log, "computeAmoebaHarmonicBondForces: expected energy=%15.7e\n", *expectedEnergy ); (void) fprintf( log, "computeAmoebaBondForces: expected energy=%15.7e\n", *expectedEnergy );
for( unsigned int ii = 0; ii < positions.size(); ii++ ){ for( unsigned int ii = 0; ii < positions.size(); ii++ ){
(void) fprintf( log, "%6u [%15.7e %15.7e %15.7e]\n", ii, expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2] ); (void) fprintf( log, "%6u [%15.7e %15.7e %15.7e]\n", ii, expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2] );
} }
...@@ -113,17 +113,17 @@ static void computeAmoebaHarmonicBondForces( Context& context, AmoebaHarmonicBon ...@@ -113,17 +113,17 @@ static void computeAmoebaHarmonicBondForces( Context& context, AmoebaHarmonicBon
} }
void compareWithExpectedForceAndEnergy( Context& context, AmoebaHarmonicBondForce& amoebaHarmonicBondForce, double tolerance, const std::string& idString, FILE* log) { void compareWithExpectedForceAndEnergy( Context& context, AmoebaBondForce& AmoebaBondForce, double tolerance, const std::string& idString, FILE* log) {
std::vector<Vec3> expectedForces; std::vector<Vec3> expectedForces;
double expectedEnergy; double expectedEnergy;
computeAmoebaHarmonicBondForces( context, amoebaHarmonicBondForce, expectedForces, &expectedEnergy, NULL ); computeAmoebaBondForces( context, AmoebaBondForce, expectedForces, &expectedEnergy, NULL );
State state = context.getState(State::Forces | State::Energy); State state = context.getState(State::Forces | State::Energy);
const std::vector<Vec3> forces = state.getForces(); const std::vector<Vec3> forces = state.getForces();
#ifdef AMOEBA_DEBUG #ifdef AMOEBA_DEBUG
if( log ){ if( log ){
(void) fprintf( log, "computeAmoebaHarmonicBondForces: expected energy=%15.7e %15.7e\n", expectedEnergy, state.getPotentialEnergy() ); (void) fprintf( log, "computeAmoebaBondForces: expected energy=%15.7e %15.7e\n", expectedEnergy, state.getPotentialEnergy() );
for( unsigned int ii = 0; ii < forces.size(); ii++ ){ for( unsigned int ii = 0; ii < forces.size(); ii++ ){
(void) fprintf( log, "%6u [%15.7e %15.7e %15.7e] [%15.7e %15.7e %15.7e]\n", ii, (void) fprintf( log, "%6u [%15.7e %15.7e %15.7e] [%15.7e %15.7e %15.7e]\n", ii,
expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2], forces[ii][0], forces[ii][1], forces[ii][2] ); expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2], forces[ii][0], forces[ii][1], forces[ii][2] );
...@@ -147,17 +147,17 @@ void testOneBond( FILE* log ) { ...@@ -147,17 +147,17 @@ void testOneBond( FILE* log ) {
LangevinIntegrator integrator(0.0, 0.1, 0.01); LangevinIntegrator integrator(0.0, 0.1, 0.01);
AmoebaHarmonicBondForce* amoebaHarmonicBondForce = new AmoebaHarmonicBondForce(); AmoebaBondForce* amoebaBondForce = new AmoebaBondForce();
double bondLength = 1.5; double bondLength = 1.5;
double quadraticK = 1.0; double quadraticK = 1.0;
double cubicK = 2.0; double cubicK = 2.0;
double quarticicK = 3.0; double quarticicK = 3.0;
amoebaHarmonicBondForce->setAmoebaGlobalHarmonicBondCubic( cubicK ); amoebaBondForce->setAmoebaGlobalBondCubic( cubicK );
amoebaHarmonicBondForce->setAmoebaGlobalHarmonicBondQuartic( quarticicK ); amoebaBondForce->setAmoebaGlobalBondQuartic( quarticicK );
amoebaHarmonicBondForce->addBond(0, 1, bondLength, quadraticK); amoebaBondForce->addBond(0, 1, bondLength, quadraticK);
system.addForce(amoebaHarmonicBondForce); system.addForce(amoebaBondForce);
Context context(system, integrator, Platform::getPlatformByName( "Reference")); Context context(system, integrator, Platform::getPlatformByName( "Reference"));
std::vector<Vec3> positions(2); std::vector<Vec3> positions(2);
...@@ -165,7 +165,7 @@ void testOneBond( FILE* log ) { ...@@ -165,7 +165,7 @@ void testOneBond( FILE* log ) {
positions[1] = Vec3(0, 0, 0); positions[1] = Vec3(0, 0, 0);
context.setPositions(positions); context.setPositions(positions);
compareWithExpectedForceAndEnergy( context, *amoebaHarmonicBondForce, TOL, "testOneBond", log ); compareWithExpectedForceAndEnergy( context, *amoebaBondForce, TOL, "testOneBond", log );
} }
void testTwoBond( FILE* log ) { void testTwoBond( FILE* log ) {
...@@ -178,18 +178,18 @@ void testTwoBond( FILE* log ) { ...@@ -178,18 +178,18 @@ void testTwoBond( FILE* log ) {
LangevinIntegrator integrator(0.0, 0.1, 0.01); LangevinIntegrator integrator(0.0, 0.1, 0.01);
AmoebaHarmonicBondForce* amoebaHarmonicBondForce = new AmoebaHarmonicBondForce(); AmoebaBondForce* amoebaBondForce = new AmoebaBondForce();
double bondLength = 1.5; double bondLength = 1.5;
double quadraticK = 1.0; double quadraticK = 1.0;
double cubicK = 2.0; double cubicK = 2.0;
double quarticicK = 3.0; double quarticicK = 3.0;
amoebaHarmonicBondForce->setAmoebaGlobalHarmonicBondCubic( cubicK ); amoebaBondForce->setAmoebaGlobalBondCubic( cubicK );
amoebaHarmonicBondForce->setAmoebaGlobalHarmonicBondQuartic( quarticicK ); amoebaBondForce->setAmoebaGlobalBondQuartic( quarticicK );
amoebaHarmonicBondForce->addBond(0, 1, bondLength, quadraticK); amoebaBondForce->addBond(0, 1, bondLength, quadraticK);
amoebaHarmonicBondForce->addBond(1, 2, bondLength, quadraticK); amoebaBondForce->addBond(1, 2, bondLength, quadraticK);
system.addForce(amoebaHarmonicBondForce); system.addForce(amoebaBondForce);
Context context(system, integrator, Platform::getPlatformByName( "Reference")); Context context(system, integrator, Platform::getPlatformByName( "Reference"));
std::vector<Vec3> positions(3); std::vector<Vec3> positions(3);
...@@ -198,13 +198,13 @@ void testTwoBond( FILE* log ) { ...@@ -198,13 +198,13 @@ void testTwoBond( FILE* log ) {
positions[2] = Vec3(1, 0, 1); positions[2] = Vec3(1, 0, 1);
context.setPositions(positions); context.setPositions(positions);
compareWithExpectedForceAndEnergy( context, *amoebaHarmonicBondForce, TOL, "testTwoBond", log ); compareWithExpectedForceAndEnergy( context, *amoebaBondForce, TOL, "testTwoBond", log );
} }
int main( int numberOfArguments, char* argv[] ) { int main( int numberOfArguments, char* argv[] ) {
try { try {
std::cout << "TestReferenceAmoebaHarmonicBondForce running test..." << std::endl; std::cout << "TestReferenceAmoebaBondForce running test..." << std::endl;
Platform::loadPluginsFromDirectory( Platform::getDefaultPluginsDirectory() ); Platform::loadPluginsFromDirectory( Platform::getDefaultPluginsDirectory() );
FILE* log = NULL; FILE* log = NULL;
//FILE* log = stderr; //FILE* log = stderr;
......
plugins/amoeba/platforms/reference/tests/TestReferenceAmoebaHarmonicInPlaneAngleForce.cpp → plugins/amoeba/platforms/reference/tests/TestReferenceAmoebaInPlaneAngleForce.cpp
View file @ c6ebf6e2
...@@ -30,7 +30,7 @@ ...@@ -30,7 +30,7 @@
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
/** /**
* This tests the Reference implementation of ReferenceAmoebaHarmonicInPlaneAngleForce. * This tests the Reference implementation of ReferenceAmoebaInPlaneAngleForce.
*/ */
#include "openmm/internal/AssertionUtilities.h" #include "openmm/internal/AssertionUtilities.h"
...@@ -119,21 +119,21 @@ static void getPrefactorsGivenInPlaneAngleCosine( double cosine, double idealInP ...@@ -119,21 +119,21 @@ static void getPrefactorsGivenInPlaneAngleCosine( double cosine, double idealInP
return; return;
} }
static void computeAmoebaHarmonicInPlaneAngleForce(int bondIndex, std::vector<Vec3>& positions, AmoebaHarmonicInPlaneAngleForce& amoebaHarmonicInPlaneAngleForce, static void computeAmoebaInPlaneAngleForce(int bondIndex, std::vector<Vec3>& positions, AmoebaInPlaneAngleForce& AmoebaInPlaneAngleForce,
std::vector<Vec3>& forces, double* energy, FILE* log ) { std::vector<Vec3>& forces, double* energy, FILE* log ) {
int particle1, particle2, particle3, particle4; int particle1, particle2, particle3, particle4;
double idealInPlaneAngle; double idealInPlaneAngle;
double quadraticK; double quadraticK;
amoebaHarmonicInPlaneAngleForce.getAngleParameters(bondIndex, particle1, particle2, particle3, particle4, idealInPlaneAngle, quadraticK ); AmoebaInPlaneAngleForce.getAngleParameters(bondIndex, particle1, particle2, particle3, particle4, idealInPlaneAngle, quadraticK );
double cubicK = amoebaHarmonicInPlaneAngleForce.getAmoebaGlobalHarmonicInPlaneAngleCubic(); double cubicK = AmoebaInPlaneAngleForce.getAmoebaGlobalInPlaneAngleCubic();
double quarticK = amoebaHarmonicInPlaneAngleForce.getAmoebaGlobalHarmonicInPlaneAngleQuartic(); double quarticK = AmoebaInPlaneAngleForce.getAmoebaGlobalInPlaneAngleQuartic();
double penticK = amoebaHarmonicInPlaneAngleForce.getAmoebaGlobalHarmonicInPlaneAnglePentic(); double penticK = AmoebaInPlaneAngleForce.getAmoebaGlobalInPlaneAnglePentic();
double sexticK = amoebaHarmonicInPlaneAngleForce.getAmoebaGlobalHarmonicInPlaneAngleSextic(); double sexticK = AmoebaInPlaneAngleForce.getAmoebaGlobalInPlaneAngleSextic();
#ifdef AMOEBA_DEBUG #ifdef AMOEBA_DEBUG
if( log ){ if( log ){
(void) fprintf( log, "computeAmoebaHarmonicInPlaneAngleForce: bond %d [%d %d %d %d] ang=%10.3f k=%10.3f [%10.3e %10.3e %10.3e %10.3e]\n", (void) fprintf( log, "computeAmoebaInPlaneAngleForce: bond %d [%d %d %d %d] ang=%10.3f k=%10.3f [%10.3e %10.3e %10.3e %10.3e]\n",
bondIndex, particle1, particle2, particle3, particle4, idealInPlaneAngle, quadraticK, cubicK, quarticK, penticK, sexticK ); bondIndex, particle1, particle2, particle3, particle4, idealInPlaneAngle, quadraticK, cubicK, quarticK, penticK, sexticK );
(void) fflush( log ); (void) fflush( log );
} }
...@@ -180,7 +180,7 @@ static void computeAmoebaHarmonicInPlaneAngleForce(int bondIndex, std::vector<V ...@@ -180,7 +180,7 @@ static void computeAmoebaHarmonicInPlaneAngleForce(int bondIndex, std::vector<V
if( rAp2 <= 0.0 && rCp2 <= 0.0 ){ if( rAp2 <= 0.0 && rCp2 <= 0.0 ){
#ifdef AMOEBA_DEBUG #ifdef AMOEBA_DEBUG
if( log ){ if( log ){
(void) fprintf( log, "computeAmoebaHarmonicInPlaneAngleForce: rAp2 or rCp2 <= 0.0\n" ); (void) fprintf( log, "computeAmoebaInPlaneAngleForce: rAp2 or rCp2 <= 0.0\n" );
(void) fflush( log ); (void) fflush( log );
} }
#endif #endif
...@@ -275,7 +275,7 @@ static void computeAmoebaHarmonicInPlaneAngleForce(int bondIndex, std::vector<V ...@@ -275,7 +275,7 @@ static void computeAmoebaHarmonicInPlaneAngleForce(int bondIndex, std::vector<V
} }
static void computeAmoebaHarmonicInPlaneAngleForces( Context& context, AmoebaHarmonicInPlaneAngleForce& amoebaHarmonicInPlaneAngleForce, static void computeAmoebaInPlaneAngleForces( Context& context, AmoebaInPlaneAngleForce& AmoebaInPlaneAngleForce,
std::vector<Vec3>& expectedForces, double* expectedEnergy, FILE* log ) { std::vector<Vec3>& expectedForces, double* expectedEnergy, FILE* log ) {
// get positions and zero forces // get positions and zero forces
...@@ -291,12 +291,12 @@ static void computeAmoebaHarmonicInPlaneAngleForces( Context& context, AmoebaHar ...@@ -291,12 +291,12 @@ static void computeAmoebaHarmonicInPlaneAngleForces( Context& context, AmoebaHar
// calculates forces/energy // calculates forces/energy
*expectedEnergy = 0.0; *expectedEnergy = 0.0;
for( int ii = 0; ii < amoebaHarmonicInPlaneAngleForce.getNumAngles(); ii++ ){ for( int ii = 0; ii < AmoebaInPlaneAngleForce.getNumAngles(); ii++ ){
computeAmoebaHarmonicInPlaneAngleForce(ii, positions, amoebaHarmonicInPlaneAngleForce, expectedForces, expectedEnergy, log ); computeAmoebaInPlaneAngleForce(ii, positions, AmoebaInPlaneAngleForce, expectedForces, expectedEnergy, log );
} }
#ifdef AMOEBA_DEBUG #ifdef AMOEBA_DEBUG
if( log ){ if( log ){
(void) fprintf( log, "computeAmoebaHarmonicInPlaneAngleForces: expected energy=%14.7e\n", *expectedEnergy ); (void) fprintf( log, "computeAmoebaInPlaneAngleForces: expected energy=%14.7e\n", *expectedEnergy );
for( unsigned int ii = 0; ii < positions.size(); ii++ ){ for( unsigned int ii = 0; ii < positions.size(); ii++ ){
(void) fprintf( log, "%6u [%14.7e %14.7e %14.7e]\n", ii, expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2] ); (void) fprintf( log, "%6u [%14.7e %14.7e %14.7e]\n", ii, expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2] );
} }
...@@ -307,18 +307,18 @@ static void computeAmoebaHarmonicInPlaneAngleForces( Context& context, AmoebaHar ...@@ -307,18 +307,18 @@ static void computeAmoebaHarmonicInPlaneAngleForces( Context& context, AmoebaHar
} }
void compareWithExpectedForceAndEnergy( Context& context, AmoebaHarmonicInPlaneAngleForce& amoebaHarmonicInPlaneAngleForce, void compareWithExpectedForceAndEnergy( Context& context, AmoebaInPlaneAngleForce& AmoebaInPlaneAngleForce,
double tolerance, const std::string& idString, FILE* log) { double tolerance, const std::string& idString, FILE* log) {
std::vector<Vec3> expectedForces; std::vector<Vec3> expectedForces;
double expectedEnergy; double expectedEnergy;
computeAmoebaHarmonicInPlaneAngleForces( context, amoebaHarmonicInPlaneAngleForce, expectedForces, &expectedEnergy, log ); computeAmoebaInPlaneAngleForces( context, AmoebaInPlaneAngleForce, expectedForces, &expectedEnergy, log );
State state = context.getState(State::Forces | State::Energy); State state = context.getState(State::Forces | State::Energy);
const std::vector<Vec3> forces = state.getForces(); const std::vector<Vec3> forces = state.getForces();
#ifdef AMOEBA_DEBUG #ifdef AMOEBA_DEBUG
if( log ){ if( log ){
(void) fprintf( log, "computeAmoebaHarmonicInPlaneAngleForces: expected energy=%14.7e %14.7e\n", expectedEnergy, state.getPotentialEnergy() ); (void) fprintf( log, "computeAmoebaInPlaneAngleForces: expected energy=%14.7e %14.7e\n", expectedEnergy, state.getPotentialEnergy() );
for( unsigned int ii = 0; ii < forces.size(); ii++ ){ for( unsigned int ii = 0; ii < forces.size(); ii++ ){
(void) fprintf( log, "%6u [%14.7e %14.7e %14.7e] [%14.7e %14.7e %14.7e]\n", ii, (void) fprintf( log, "%6u [%14.7e %14.7e %14.7e] [%14.7e %14.7e %14.7e]\n", ii,
expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2], forces[ii][0], forces[ii][1], forces[ii][2] ); expectedForces[ii][0], expectedForces[ii][1], expectedForces[ii][2], forces[ii][0], forces[ii][1], forces[ii][2] );
...@@ -343,7 +343,7 @@ void testOneAngle( FILE* log ) { ...@@ -343,7 +343,7 @@ void testOneAngle( FILE* log ) {
LangevinIntegrator integrator(0.0, 0.1, 0.01); LangevinIntegrator integrator(0.0, 0.1, 0.01);
AmoebaHarmonicInPlaneAngleForce* amoebaHarmonicInPlaneAngleForce = new AmoebaHarmonicInPlaneAngleForce(); AmoebaInPlaneAngleForce* amoebaInPlaneAngleForce = new AmoebaInPlaneAngleForce();
double angle = 65.0; double angle = 65.0;
double quadraticK = 1.0; double quadraticK = 1.0;
...@@ -351,14 +351,14 @@ void testOneAngle( FILE* log ) { ...@@ -351,14 +351,14 @@ void testOneAngle( FILE* log ) {
double quarticK = 0.0e-02; double quarticK = 0.0e-02;
double penticK = 0.0e-03; double penticK = 0.0e-03;
double sexticK = 0.0e-04; double sexticK = 0.0e-04;
amoebaHarmonicInPlaneAngleForce->addAngle(0, 1, 2, 3, angle, quadraticK); amoebaInPlaneAngleForce->addAngle(0, 1, 2, 3, angle, quadraticK);
amoebaHarmonicInPlaneAngleForce->setAmoebaGlobalHarmonicInPlaneAngleCubic(cubicK); amoebaInPlaneAngleForce->setAmoebaGlobalInPlaneAngleCubic(cubicK);
amoebaHarmonicInPlaneAngleForce->setAmoebaGlobalHarmonicInPlaneAngleQuartic(quarticK); amoebaInPlaneAngleForce->setAmoebaGlobalInPlaneAngleQuartic(quarticK);
amoebaHarmonicInPlaneAngleForce->setAmoebaGlobalHarmonicInPlaneAnglePentic(penticK); amoebaInPlaneAngleForce->setAmoebaGlobalInPlaneAnglePentic(penticK);
amoebaHarmonicInPlaneAngleForce->setAmoebaGlobalHarmonicInPlaneAngleSextic(sexticK); amoebaInPlaneAngleForce->setAmoebaGlobalInPlaneAngleSextic(sexticK);
system.addForce(amoebaHarmonicInPlaneAngleForce); system.addForce(amoebaInPlaneAngleForce);
Context context(system, integrator, Platform::getPlatformByName( "Reference")); Context context(system, integrator, Platform::getPlatformByName( "Reference"));
std::vector<Vec3> positions(numberOfParticles); std::vector<Vec3> positions(numberOfParticles);
...@@ -369,18 +369,18 @@ void testOneAngle( FILE* log ) { ...@@ -369,18 +369,18 @@ void testOneAngle( FILE* log ) {
positions[3] = Vec3(1, 1, 1); positions[3] = Vec3(1, 1, 1);
context.setPositions(positions); context.setPositions(positions);
compareWithExpectedForceAndEnergy( context, *amoebaHarmonicInPlaneAngleForce, TOL, "testOneInPlaneAngle", log ); compareWithExpectedForceAndEnergy( context, *amoebaInPlaneAngleForce, TOL, "testOneInPlaneAngle", log );
} }
int main( int numberOfArguments, char* argv[] ) { int main( int numberOfArguments, char* argv[] ) {
try { try {
std::cout << "TestReferenceAmoebaHarmonicInPlaneAngleForce running test..." << std::endl; std::cout << "TestReferenceAmoebaInPlaneAngleForce running test..." << std::endl;
Platform::loadPluginsFromDirectory( Platform::getDefaultPluginsDirectory() ); Platform::loadPluginsFromDirectory( Platform::getDefaultPluginsDirectory() );
FILE* log = NULL; FILE* log = NULL;
//FILE* log = stderr; //FILE* log = stderr;
//FILE* log = fopen( "AmoebaHarmonicInPlaneAngleForce.log", "w" );; //FILE* log = fopen( "AmoebaInPlaneAngleForce.log", "w" );;
testOneAngle( NULL ); testOneAngle( NULL );
#ifdef AMOEBA_DEBUG #ifdef AMOEBA_DEBUG
......
plugins/amoeba/serialization/include/openmm/serialization/AmoebaHarmonicAngleForceProxy.h → plugins/amoeba/serialization/include/openmm/serialization/AmoebaAngleForceProxy.h
View file @ c6ebf6e2
#ifndef OPENMM_AMOEBA_HARMONIC_ANGLE_FORCE_PROXY_H_ #ifndef OPENMM_AMOEBA_ANGLE_FORCE_PROXY_H_
#define OPENMM_AMOEBA_HARMONIC_ANGLE_FORCE_PROXY_H_ #define OPENMM_AMOEBA_ANGLE_FORCE_PROXY_H_
/* -------------------------------------------------------------------------- * /* -------------------------------------------------------------------------- *
* OpenMMAmoeba * * OpenMMAmoeba *
...@@ -38,16 +38,16 @@ ...@@ -38,16 +38,16 @@
namespace OpenMM { namespace OpenMM {
/** /**
* This is a proxy for serializing AmoebaHarmonicAngleForce objects. * This is a proxy for serializing AmoebaAngleForce objects.
*/ */
class OPENMM_EXPORT AmoebaHarmonicAngleForceProxy : public SerializationProxy { class OPENMM_EXPORT AmoebaAngleForceProxy : public SerializationProxy {
public: public:
AmoebaHarmonicAngleForceProxy(); AmoebaAngleForceProxy();
void serialize(const void* object, SerializationNode& node) const; void serialize(const void* object, SerializationNode& node) const;
void* deserialize(const SerializationNode& node) const; void* deserialize(const SerializationNode& node) const;
}; };
} // namespace OpenMM } // namespace OpenMM
#endif /*OPENMM_AMOEBA_HARMONIC_ANGLE_FORCE_PROXY_H_*/ #endif /*OPENMM_AMOEBA_ANGLE_FORCE_PROXY_H_*/
plugins/amoeba/serialization/include/openmm/serialization/AmoebaHarmonicInPlaneAngleForceProxy.h → plugins/amoeba/serialization/include/openmm/serialization/AmoebaBondForceProxy.h
View file @ c6ebf6e2
#ifndef OPENMM_AMOEBA_HARMONIC_IN_PLANE_ANGLE_FORCE_PROXY_H_ #ifndef OPENMM_AMOEBA_BOND_FORCE_PROXY_H_
#define OPENMM_AMOEBA_HARMONIC_IN_PLANE_ANGLE_FORCE_PROXY_H_ #define OPENMM_AMOEBA_BOND_FORCE_PROXY_H_
/* -------------------------------------------------------------------------- * /* -------------------------------------------------------------------------- *
* OpenMMAmoeba * * OpenMMAmoeba *
...@@ -38,16 +38,16 @@ ...@@ -38,16 +38,16 @@
namespace OpenMM { namespace OpenMM {
/** /**
* This is a proxy for serializing AmoebaHarmonicInPlaneAngleForce objects. * This is a proxy for serializing AmoebaBondForce objects.
*/ */
class OPENMM_EXPORT AmoebaHarmonicInPlaneAngleForceProxy : public SerializationProxy { class OPENMM_EXPORT AmoebaBondForceProxy : public SerializationProxy {
public: public:
AmoebaHarmonicInPlaneAngleForceProxy(); AmoebaBondForceProxy();
void serialize(const void* object, SerializationNode& node) const; void serialize(const void* object, SerializationNode& node) const;
void* deserialize(const SerializationNode& node) const; void* deserialize(const SerializationNode& node) const;
}; };
} // namespace OpenMM } // namespace OpenMM
#endif /*OPENMM_AMOEBA_HARMONIC_IN_PLANE_ANGLE_FORCE_PROXY_H_*/ #endif /*OPENMM_AMOEBA_BOND_FORCE_PROXY_H_*/
plugins/amoeba/serialization/include/openmm/serialization/AmoebaHarmonicBondForceProxy.h → plugins/amoeba/serialization/include/openmm/serialization/AmoebaInPlaneAngleForceProxy.h
View file @ c6ebf6e2
#ifndef OPENMM_AMOEBA_HARMONIC_BOND_FORCE_PROXY_H_ #ifndef OPENMM_AMOEBA_IN_PLANE_ANGLE_FORCE_PROXY_H_
#define OPENMM_AMOEBA_HARMONIC_BOND_FORCE_PROXY_H_ #define OPENMM_AMOEBA_IN_PLANE_ANGLE_FORCE_PROXY_H_
/* -------------------------------------------------------------------------- * /* -------------------------------------------------------------------------- *
* OpenMMAmoeba * * OpenMMAmoeba *
...@@ -38,16 +38,16 @@ ...@@ -38,16 +38,16 @@
namespace OpenMM { namespace OpenMM {
/** /**
* This is a proxy for serializing AmoebaHarmonicBondForce objects. * This is a proxy for serializing AmoebaInPlaneAngleForce objects.
*/ */
class OPENMM_EXPORT AmoebaHarmonicBondForceProxy : public SerializationProxy { class OPENMM_EXPORT AmoebaInPlaneAngleForceProxy : public SerializationProxy {
public: public:
AmoebaHarmonicBondForceProxy(); AmoebaInPlaneAngleForceProxy();
void serialize(const void* object, SerializationNode& node) const; void serialize(const void* object, SerializationNode& node) const;
void* deserialize(const SerializationNode& node) const; void* deserialize(const SerializationNode& node) const;
}; };
} // namespace OpenMM } // namespace OpenMM
#endif /*OPENMM_AMOEBA_HARMONIC_BOND_FORCE_PROXY_H_*/ #endif /*OPENMM_AMOEBA_IN_PLANE_ANGLE_FORCE_PROXY_H_*/
plugins/amoeba/serialization/src/AmoebaHarmonicAngleForceProxy.cpp → plugins/amoeba/serialization/src/AmoebaAngleForceProxy.cpp
View file @ c6ebf6e2
...@@ -29,27 +29,27 @@ ...@@ -29,27 +29,27 @@
* USE OR OTHER DEALINGS IN THE SOFTWARE. * * USE OR OTHER DEALINGS IN THE SOFTWARE. *
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
#include "openmm/serialization/AmoebaHarmonicAngleForceProxy.h" #include "openmm/serialization/AmoebaAngleForceProxy.h"
#include "openmm/serialization/SerializationNode.h" #include "openmm/serialization/SerializationNode.h"
#include "openmm/Force.h" #include "openmm/Force.h"
#include "openmm/AmoebaHarmonicAngleForce.h" #include "openmm/AmoebaAngleForce.h"
#include <sstream> #include <sstream>
using namespace OpenMM; using namespace OpenMM;
using namespace std; using namespace std;
AmoebaHarmonicAngleForceProxy::AmoebaHarmonicAngleForceProxy() : SerializationProxy("AmoebaHarmonicAngleForce") { AmoebaAngleForceProxy::AmoebaAngleForceProxy() : SerializationProxy("AmoebaAngleForce") {
} }
void AmoebaHarmonicAngleForceProxy::serialize(const void* object, SerializationNode& node) const { void AmoebaAngleForceProxy::serialize(const void* object, SerializationNode& node) const {
node.setIntProperty("version", 1); node.setIntProperty("version", 1);
const AmoebaHarmonicAngleForce& force = *reinterpret_cast<const AmoebaHarmonicAngleForce*>(object); const AmoebaAngleForce& force = *reinterpret_cast<const AmoebaAngleForce*>(object);
node.setDoubleProperty("HarmonicAngleCubic", force.getAmoebaGlobalHarmonicAngleCubic()); node.setDoubleProperty("cubic", force.getAmoebaGlobalAngleCubic());
node.setDoubleProperty("HarmonicAngleQuartic", force.getAmoebaGlobalHarmonicAngleQuartic()); node.setDoubleProperty("quartic", force.getAmoebaGlobalAngleQuartic());
node.setDoubleProperty("HarmonicAnglePentic", force.getAmoebaGlobalHarmonicAnglePentic()); node.setDoubleProperty("pentic", force.getAmoebaGlobalAnglePentic());
node.setDoubleProperty("HarmonicAngleSextic", force.getAmoebaGlobalHarmonicAngleSextic()); node.setDoubleProperty("sextic", force.getAmoebaGlobalAngleSextic());
SerializationNode& bonds = node.createChildNode("Angles").setIntProperty( "size", force.getNumAngles() ); SerializationNode& bonds = node.createChildNode("Angles").setIntProperty( "size", force.getNumAngles() );
for (unsigned int ii = 0; ii < static_cast<unsigned int>(force.getNumAngles()); ii++) { for (unsigned int ii = 0; ii < static_cast<unsigned int>(force.getNumAngles()); ii++) {
...@@ -60,16 +60,16 @@ void AmoebaHarmonicAngleForceProxy::serialize(const void* object, SerializationN ...@@ -60,16 +60,16 @@ void AmoebaHarmonicAngleForceProxy::serialize(const void* object, SerializationN
} }
} }
void* AmoebaHarmonicAngleForceProxy::deserialize(const SerializationNode& node) const { void* AmoebaAngleForceProxy::deserialize(const SerializationNode& node) const {
if (node.getIntProperty("version") != 1) if (node.getIntProperty("version") != 1)
throw OpenMMException("Unsupported version number"); throw OpenMMException("Unsupported version number");
AmoebaHarmonicAngleForce* force = new AmoebaHarmonicAngleForce(); AmoebaAngleForce* force = new AmoebaAngleForce();
try { try {
force->setAmoebaGlobalHarmonicAngleCubic(node.getDoubleProperty( "HarmonicAngleCubic")); force->setAmoebaGlobalAngleCubic(node.getDoubleProperty( "cubic"));
force->setAmoebaGlobalHarmonicAngleQuartic(node.getDoubleProperty("HarmonicAngleQuartic")); force->setAmoebaGlobalAngleQuartic(node.getDoubleProperty("quartic"));
force->setAmoebaGlobalHarmonicAnglePentic(node.getDoubleProperty( "HarmonicAnglePentic")); force->setAmoebaGlobalAnglePentic(node.getDoubleProperty( "pentic"));
force->setAmoebaGlobalHarmonicAngleSextic(node.getDoubleProperty( "HarmonicAngleSextic")); force->setAmoebaGlobalAngleSextic(node.getDoubleProperty( "sextic"));
const SerializationNode& bonds = node.getChildNode("Angles"); const SerializationNode& bonds = node.getChildNode("Angles");
for ( unsigned int ii = 0; ii < bonds.getChildren().size(); ii++) { for ( unsigned int ii = 0; ii < bonds.getChildren().size(); ii++) {
......
plugins/amoeba/serialization/src/AmoebaHarmonicBondForceProxy.cpp → plugins/amoeba/serialization/src/AmoebaBondForceProxy.cpp
View file @ c6ebf6e2
...@@ -29,24 +29,24 @@ ...@@ -29,24 +29,24 @@
* USE OR OTHER DEALINGS IN THE SOFTWARE. * * USE OR OTHER DEALINGS IN THE SOFTWARE. *
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
#include "openmm/serialization/AmoebaHarmonicBondForceProxy.h" #include "openmm/serialization/AmoebaBondForceProxy.h"
#include "openmm/serialization/SerializationNode.h" #include "openmm/serialization/SerializationNode.h"
#include "openmm/Force.h" #include "openmm/Force.h"
#include "openmm/AmoebaHarmonicBondForce.h" #include "openmm/AmoebaBondForce.h"
#include <sstream> #include <sstream>
using namespace OpenMM; using namespace OpenMM;
using namespace std; using namespace std;
AmoebaHarmonicBondForceProxy::AmoebaHarmonicBondForceProxy() : SerializationProxy("AmoebaHarmonicBondForce") { AmoebaBondForceProxy::AmoebaBondForceProxy() : SerializationProxy("AmoebaBondForce") {
} }
void AmoebaHarmonicBondForceProxy::serialize(const void* object, SerializationNode& node) const { void AmoebaBondForceProxy::serialize(const void* object, SerializationNode& node) const {
node.setIntProperty("version", 1); node.setIntProperty("version", 1);
const AmoebaHarmonicBondForce& force = *reinterpret_cast<const AmoebaHarmonicBondForce*>(object); const AmoebaBondForce& force = *reinterpret_cast<const AmoebaBondForce*>(object);
node.setDoubleProperty("HarmonicBondCubic", force.getAmoebaGlobalHarmonicBondCubic()); node.setDoubleProperty("cubic", force.getAmoebaGlobalBondCubic());
node.setDoubleProperty("HarmonicBondQuartic", force.getAmoebaGlobalHarmonicBondQuartic()); node.setDoubleProperty("quartic", force.getAmoebaGlobalBondQuartic());
SerializationNode& bonds = node.createChildNode("Bonds").setIntProperty( "size", force.getNumBonds() ); SerializationNode& bonds = node.createChildNode("Bonds").setIntProperty( "size", force.getNumBonds() );
for (unsigned int ii = 0; ii < static_cast<unsigned int>(force.getNumBonds()); ii++) { for (unsigned int ii = 0; ii < static_cast<unsigned int>(force.getNumBonds()); ii++) {
...@@ -57,13 +57,13 @@ void AmoebaHarmonicBondForceProxy::serialize(const void* object, SerializationNo ...@@ -57,13 +57,13 @@ void AmoebaHarmonicBondForceProxy::serialize(const void* object, SerializationNo
} }
} }
void* AmoebaHarmonicBondForceProxy::deserialize(const SerializationNode& node) const { void* AmoebaBondForceProxy::deserialize(const SerializationNode& node) const {
if (node.getIntProperty("version") != 1) if (node.getIntProperty("version") != 1)
throw OpenMMException("Unsupported version number"); throw OpenMMException("Unsupported version number");
AmoebaHarmonicBondForce* force = new AmoebaHarmonicBondForce(); AmoebaBondForce* force = new AmoebaBondForce();
try { try {
force->setAmoebaGlobalHarmonicBondCubic(node.getDoubleProperty("HarmonicBondCubic")); force->setAmoebaGlobalBondCubic(node.getDoubleProperty("condCubic"));
force->setAmoebaGlobalHarmonicBondQuartic(node.getDoubleProperty("HarmonicBondQuartic")); force->setAmoebaGlobalBondQuartic(node.getDoubleProperty("quartic"));
const SerializationNode& bonds = node.getChildNode("Bonds"); const SerializationNode& bonds = node.getChildNode("Bonds");
for ( unsigned int ii = 0; ii < (int) bonds.getChildren().size(); ii++) { for ( unsigned int ii = 0; ii < (int) bonds.getChildren().size(); ii++) {
const SerializationNode& bond = bonds.getChildren()[ii]; const SerializationNode& bond = bonds.getChildren()[ii];
......
plugins/amoeba/serialization/src/AmoebaHarmonicInPlaneAngleForceProxy.cpp → plugins/amoeba/serialization/src/AmoebaInPlaneAngleForceProxy.cpp
View file @ c6ebf6e2
...@@ -29,27 +29,27 @@ ...@@ -29,27 +29,27 @@
* USE OR OTHER DEALINGS IN THE SOFTWARE. * * USE OR OTHER DEALINGS IN THE SOFTWARE. *
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
#include "openmm/serialization/AmoebaHarmonicInPlaneAngleForceProxy.h" #include "openmm/serialization/AmoebaInPlaneAngleForceProxy.h"
#include "openmm/serialization/SerializationNode.h" #include "openmm/serialization/SerializationNode.h"
#include "openmm/Force.h" #include "openmm/Force.h"
#include "openmm/AmoebaHarmonicInPlaneAngleForce.h" #include "openmm/AmoebaInPlaneAngleForce.h"
#include <sstream> #include <sstream>
using namespace OpenMM; using namespace OpenMM;
using namespace std; using namespace std;
AmoebaHarmonicInPlaneAngleForceProxy::AmoebaHarmonicInPlaneAngleForceProxy() : SerializationProxy("AmoebaHarmonicInPlaneAngleForce") { AmoebaInPlaneAngleForceProxy::AmoebaInPlaneAngleForceProxy() : SerializationProxy("AmoebaInPlaneAngleForce") {
} }
void AmoebaHarmonicInPlaneAngleForceProxy::serialize(const void* object, SerializationNode& node) const { void AmoebaInPlaneAngleForceProxy::serialize(const void* object, SerializationNode& node) const {
node.setIntProperty("version", 1); node.setIntProperty("version", 1);
const AmoebaHarmonicInPlaneAngleForce& force = *reinterpret_cast<const AmoebaHarmonicInPlaneAngleForce*>(object); const AmoebaInPlaneAngleForce& force = *reinterpret_cast<const AmoebaInPlaneAngleForce*>(object);
node.setDoubleProperty("HarmonicInPlaneAngleCubic", force.getAmoebaGlobalHarmonicInPlaneAngleCubic()); node.setDoubleProperty("cubic", force.getAmoebaGlobalInPlaneAngleCubic());
node.setDoubleProperty("HarmonicInPlaneAngleQuartic", force.getAmoebaGlobalHarmonicInPlaneAngleQuartic()); node.setDoubleProperty("quartic", force.getAmoebaGlobalInPlaneAngleQuartic());
node.setDoubleProperty("HarmonicInPlaneAnglePentic", force.getAmoebaGlobalHarmonicInPlaneAnglePentic()); node.setDoubleProperty("pentic", force.getAmoebaGlobalInPlaneAnglePentic());
node.setDoubleProperty("HarmonicInPlaneAngleSextic", force.getAmoebaGlobalHarmonicInPlaneAngleSextic()); node.setDoubleProperty("sextic", force.getAmoebaGlobalInPlaneAngleSextic());
SerializationNode& bonds = node.createChildNode("InPlaneAngles").setIntProperty( "size", force.getNumAngles() ); SerializationNode& bonds = node.createChildNode("InPlaneAngles").setIntProperty( "size", force.getNumAngles() );
for ( unsigned int ii = 0; ii < static_cast<unsigned int>(force.getNumAngles()); ii++) { for ( unsigned int ii = 0; ii < static_cast<unsigned int>(force.getNumAngles()); ii++) {
...@@ -60,16 +60,16 @@ void AmoebaHarmonicInPlaneAngleForceProxy::serialize(const void* object, Seriali ...@@ -60,16 +60,16 @@ void AmoebaHarmonicInPlaneAngleForceProxy::serialize(const void* object, Seriali
} }
} }
void* AmoebaHarmonicInPlaneAngleForceProxy::deserialize(const SerializationNode& node) const { void* AmoebaInPlaneAngleForceProxy::deserialize(const SerializationNode& node) const {
if (node.getIntProperty("version") != 1) if (node.getIntProperty("version") != 1)
throw OpenMMException("Unsupported version number"); throw OpenMMException("Unsupported version number");
AmoebaHarmonicInPlaneAngleForce* force = new AmoebaHarmonicInPlaneAngleForce(); AmoebaInPlaneAngleForce* force = new AmoebaInPlaneAngleForce();
try { try {
force->setAmoebaGlobalHarmonicInPlaneAngleCubic( node.getDoubleProperty("HarmonicInPlaneAngleCubic")); force->setAmoebaGlobalInPlaneAngleCubic( node.getDoubleProperty("cubic"));
force->setAmoebaGlobalHarmonicInPlaneAngleQuartic(node.getDoubleProperty("HarmonicInPlaneAngleQuartic")); force->setAmoebaGlobalInPlaneAngleQuartic(node.getDoubleProperty("quartic"));
force->setAmoebaGlobalHarmonicInPlaneAnglePentic( node.getDoubleProperty("HarmonicInPlaneAnglePentic")); force->setAmoebaGlobalInPlaneAnglePentic( node.getDoubleProperty("pentic"));
force->setAmoebaGlobalHarmonicInPlaneAngleSextic( node.getDoubleProperty("HarmonicInPlaneAngleSextic")); force->setAmoebaGlobalInPlaneAngleSextic( node.getDoubleProperty("sextic"));
const SerializationNode& bonds = node.getChildNode("InPlaneAngles"); const SerializationNode& bonds = node.getChildNode("InPlaneAngles");
for (unsigned int ii = 0; ii < bonds.getChildren().size(); ii++) { for (unsigned int ii = 0; ii < bonds.getChildren().size(); ii++) {
......
plugins/amoeba/serialization/src/AmoebaSerializationProxyRegistration.cpp
View file @ c6ebf6e2
...@@ -41,9 +41,9 @@ ...@@ -41,9 +41,9 @@
#include "openmm/OpenMMException.h" #include "openmm/OpenMMException.h"
#include "openmm/AmoebaGeneralizedKirkwoodForce.h" #include "openmm/AmoebaGeneralizedKirkwoodForce.h"
#include "openmm/AmoebaHarmonicBondForce.h" #include "openmm/AmoebaBondForce.h"
#include "openmm/AmoebaHarmonicAngleForce.h" #include "openmm/AmoebaAngleForce.h"
#include "openmm/AmoebaHarmonicInPlaneAngleForce.h" #include "openmm/AmoebaInPlaneAngleForce.h"
#include "openmm/AmoebaMultipoleForce.h" #include "openmm/AmoebaMultipoleForce.h"
#include "openmm/AmoebaOutOfPlaneBendForce.h" #include "openmm/AmoebaOutOfPlaneBendForce.h"
#include "openmm/AmoebaPiTorsionForce.h" #include "openmm/AmoebaPiTorsionForce.h"
...@@ -55,9 +55,9 @@ ...@@ -55,9 +55,9 @@
#include "openmm/serialization/SerializationProxy.h" #include "openmm/serialization/SerializationProxy.h"
#include "openmm/serialization/AmoebaGeneralizedKirkwoodForceProxy.h" #include "openmm/serialization/AmoebaGeneralizedKirkwoodForceProxy.h"
#include "openmm/serialization/AmoebaHarmonicBondForceProxy.h" #include "openmm/serialization/AmoebaBondForceProxy.h"
#include "openmm/serialization/AmoebaHarmonicAngleForceProxy.h" #include "openmm/serialization/AmoebaAngleForceProxy.h"
#include "openmm/serialization/AmoebaHarmonicInPlaneAngleForceProxy.h" #include "openmm/serialization/AmoebaInPlaneAngleForceProxy.h"
#include "openmm/serialization/AmoebaMultipoleForceProxy.h" #include "openmm/serialization/AmoebaMultipoleForceProxy.h"
#include "openmm/serialization/AmoebaOutOfPlaneBendForceProxy.h" #include "openmm/serialization/AmoebaOutOfPlaneBendForceProxy.h"
#include "openmm/serialization/AmoebaPiTorsionForceProxy.h" #include "openmm/serialization/AmoebaPiTorsionForceProxy.h"
...@@ -82,9 +82,9 @@ using namespace OpenMM; ...@@ -82,9 +82,9 @@ using namespace OpenMM;
extern "C" void registerAmoebaSerializationProxies() { extern "C" void registerAmoebaSerializationProxies() {
SerializationProxy::registerProxy(typeid(AmoebaGeneralizedKirkwoodForce), new AmoebaGeneralizedKirkwoodForceProxy()); SerializationProxy::registerProxy(typeid(AmoebaGeneralizedKirkwoodForce), new AmoebaGeneralizedKirkwoodForceProxy());
SerializationProxy::registerProxy(typeid(AmoebaHarmonicBondForce), new AmoebaHarmonicBondForceProxy()); SerializationProxy::registerProxy(typeid(AmoebaBondForce), new AmoebaBondForceProxy());
SerializationProxy::registerProxy(typeid(AmoebaHarmonicAngleForce), new AmoebaHarmonicAngleForceProxy()); SerializationProxy::registerProxy(typeid(AmoebaAngleForce), new AmoebaAngleForceProxy());
SerializationProxy::registerProxy(typeid(AmoebaHarmonicInPlaneAngleForce), new AmoebaHarmonicInPlaneAngleForceProxy()); SerializationProxy::registerProxy(typeid(AmoebaInPlaneAngleForce), new AmoebaInPlaneAngleForceProxy());
SerializationProxy::registerProxy(typeid(AmoebaMultipoleForce), new AmoebaMultipoleForceProxy()); SerializationProxy::registerProxy(typeid(AmoebaMultipoleForce), new AmoebaMultipoleForceProxy());
SerializationProxy::registerProxy(typeid(AmoebaOutOfPlaneBendForce), new AmoebaOutOfPlaneBendForceProxy()); SerializationProxy::registerProxy(typeid(AmoebaOutOfPlaneBendForce), new AmoebaOutOfPlaneBendForceProxy());
SerializationProxy::registerProxy(typeid(AmoebaPiTorsionForce), new AmoebaPiTorsionForceProxy()); SerializationProxy::registerProxy(typeid(AmoebaPiTorsionForce), new AmoebaPiTorsionForceProxy());
......
plugins/amoeba/serialization/tests/TestSerializeAmoebaHarmonicAngleForce.cpp → plugins/amoeba/serialization/tests/TestSerializeAmoebaAngleForce.cpp
View file @ c6ebf6e2
...@@ -30,7 +30,7 @@ ...@@ -30,7 +30,7 @@
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
#include "openmm/internal/AssertionUtilities.h" #include "openmm/internal/AssertionUtilities.h"
#include "openmm/AmoebaHarmonicAngleForce.h" #include "openmm/AmoebaAngleForce.h"
#include "openmm/serialization/XmlSerializer.h" #include "openmm/serialization/XmlSerializer.h"
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
...@@ -41,11 +41,11 @@ using namespace std; ...@@ -41,11 +41,11 @@ using namespace std;
void testSerialization() { void testSerialization() {
// Create a Force. // Create a Force.
AmoebaHarmonicAngleForce force1; AmoebaAngleForce force1;
force1.setAmoebaGlobalHarmonicAngleCubic( 12.3 ); force1.setAmoebaGlobalAngleCubic( 12.3 );
force1.setAmoebaGlobalHarmonicAngleQuartic( 98.7 ); force1.setAmoebaGlobalAngleQuartic( 98.7 );
force1.setAmoebaGlobalHarmonicAnglePentic( 91.7 ); force1.setAmoebaGlobalAnglePentic( 91.7 );
force1.setAmoebaGlobalHarmonicAngleSextic( 93.7 ); force1.setAmoebaGlobalAngleSextic( 93.7 );
force1.addAngle(0, 1, 3, 1.0, 2.0); force1.addAngle(0, 1, 3, 1.0, 2.0);
force1.addAngle(0, 2, 3, 2.0, 2.1); force1.addAngle(0, 2, 3, 2.0, 2.1);
force1.addAngle(2, 3, 5, 3.0, 2.2); force1.addAngle(2, 3, 5, 3.0, 2.2);
...@@ -54,15 +54,15 @@ void testSerialization() { ...@@ -54,15 +54,15 @@ void testSerialization() {
// Serialize and then deserialize it. // Serialize and then deserialize it.
stringstream buffer; stringstream buffer;
XmlSerializer::serialize<AmoebaHarmonicAngleForce>(&force1, "Force", buffer); XmlSerializer::serialize<AmoebaAngleForce>(&force1, "Force", buffer);
AmoebaHarmonicAngleForce* copy = XmlSerializer::deserialize<AmoebaHarmonicAngleForce>(buffer); AmoebaAngleForce* copy = XmlSerializer::deserialize<AmoebaAngleForce>(buffer);
// Compare the two forces to see if they are identical. // Compare the two forces to see if they are identical.
AmoebaHarmonicAngleForce& force2 = *copy; AmoebaAngleForce& force2 = *copy;
ASSERT_EQUAL(force1.getAmoebaGlobalHarmonicAngleCubic(), force2.getAmoebaGlobalHarmonicAngleCubic()); ASSERT_EQUAL(force1.getAmoebaGlobalAngleCubic(), force2.getAmoebaGlobalAngleCubic());
ASSERT_EQUAL(force1.getAmoebaGlobalHarmonicAngleQuartic(), force2.getAmoebaGlobalHarmonicAngleQuartic()); ASSERT_EQUAL(force1.getAmoebaGlobalAngleQuartic(), force2.getAmoebaGlobalAngleQuartic());
ASSERT_EQUAL(force1.getAmoebaGlobalHarmonicAnglePentic(), force2.getAmoebaGlobalHarmonicAnglePentic()); ASSERT_EQUAL(force1.getAmoebaGlobalAnglePentic(), force2.getAmoebaGlobalAnglePentic());
ASSERT_EQUAL(force1.getAmoebaGlobalHarmonicAngleSextic(), force2.getAmoebaGlobalHarmonicAngleSextic()); ASSERT_EQUAL(force1.getAmoebaGlobalAngleSextic(), force2.getAmoebaGlobalAngleSextic());
ASSERT_EQUAL(force1.getNumAngles(), force2.getNumAngles()); ASSERT_EQUAL(force1.getNumAngles(), force2.getNumAngles());
for (unsigned int ii = 0; ii < static_cast<unsigned int>(force1.getNumAngles()); ii++) { for (unsigned int ii = 0; ii < static_cast<unsigned int>(force1.getNumAngles()); ii++) {
int a1, a2, a3, b1, b2, b3; int a1, a2, a3, b1, b2, b3;
......
plugins/amoeba/serialization/tests/TestSerializeAmoebaHarmonicBondForce.cpp → plugins/amoeba/serialization/tests/TestSerializeAmoebaBondForce.cpp
View file @ c6ebf6e2
...@@ -30,7 +30,7 @@ ...@@ -30,7 +30,7 @@
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
#include "openmm/internal/AssertionUtilities.h" #include "openmm/internal/AssertionUtilities.h"
#include "openmm/AmoebaHarmonicBondForce.h" #include "openmm/AmoebaBondForce.h"
#include "openmm/serialization/XmlSerializer.h" #include "openmm/serialization/XmlSerializer.h"
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
...@@ -41,9 +41,9 @@ using namespace std; ...@@ -41,9 +41,9 @@ using namespace std;
void testSerialization() { void testSerialization() {
// Create a Force. // Create a Force.
AmoebaHarmonicBondForce force1; AmoebaBondForce force1;
force1.setAmoebaGlobalHarmonicBondCubic( 12.3 ); force1.setAmoebaGlobalBondCubic( 12.3 );
force1.setAmoebaGlobalHarmonicBondQuartic( 98.7 ); force1.setAmoebaGlobalBondQuartic( 98.7 );
force1.addBond(0, 1, 1.0, 2.0); force1.addBond(0, 1, 1.0, 2.0);
force1.addBond(0, 2, 2.0, 2.1); force1.addBond(0, 2, 2.0, 2.1);
force1.addBond(2, 3, 3.0, 2.2); force1.addBond(2, 3, 3.0, 2.2);
...@@ -52,13 +52,13 @@ void testSerialization() { ...@@ -52,13 +52,13 @@ void testSerialization() {
// Serialize and then deserialize it. // Serialize and then deserialize it.
stringstream buffer; stringstream buffer;
XmlSerializer::serialize<AmoebaHarmonicBondForce>(&force1, "Force", buffer); XmlSerializer::serialize<AmoebaBondForce>(&force1, "Force", buffer);
AmoebaHarmonicBondForce* copy = XmlSerializer::deserialize<AmoebaHarmonicBondForce>(buffer); AmoebaBondForce* copy = XmlSerializer::deserialize<AmoebaBondForce>(buffer);
// Compare the two forces to see if they are identical. // Compare the two forces to see if they are identical.
AmoebaHarmonicBondForce& force2 = *copy; AmoebaBondForce& force2 = *copy;
ASSERT_EQUAL(force1.getAmoebaGlobalHarmonicBondCubic(), force2.getAmoebaGlobalHarmonicBondCubic()); ASSERT_EQUAL(force1.getAmoebaGlobalBondCubic(), force2.getAmoebaGlobalBondCubic());
ASSERT_EQUAL(force1.getAmoebaGlobalHarmonicBondQuartic(), force2.getAmoebaGlobalHarmonicBondQuartic()); ASSERT_EQUAL(force1.getAmoebaGlobalBondQuartic(), force2.getAmoebaGlobalBondQuartic());
ASSERT_EQUAL(force1.getNumBonds(), force2.getNumBonds()); ASSERT_EQUAL(force1.getNumBonds(), force2.getNumBonds());
for (unsigned int ii = 0; ii < static_cast<unsigned int>(force1.getNumBonds()); ii++) { for (unsigned int ii = 0; ii < static_cast<unsigned int>(force1.getNumBonds()); ii++) {
int a1, a2, b1, b2; int a1, a2, b1, b2;
......
plugins/amoeba/serialization/tests/TestSerializeAmoebaHarmonicInPlaneAngleForce.cpp → plugins/amoeba/serialization/tests/TestSerializeAmoebaInPlaneAngleForce.cpp
View file @ c6ebf6e2
...@@ -30,7 +30,7 @@ ...@@ -30,7 +30,7 @@
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
#include "openmm/internal/AssertionUtilities.h" #include "openmm/internal/AssertionUtilities.h"
#include "openmm/AmoebaHarmonicInPlaneAngleForce.h" #include "openmm/AmoebaInPlaneAngleForce.h"
#include "openmm/serialization/XmlSerializer.h" #include "openmm/serialization/XmlSerializer.h"
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
...@@ -41,12 +41,12 @@ using namespace std; ...@@ -41,12 +41,12 @@ using namespace std;
void testSerialization() { void testSerialization() {
// Create a Force. // Create a Force.
AmoebaHarmonicInPlaneAngleForce force1; AmoebaInPlaneAngleForce force1;
force1.setAmoebaGlobalHarmonicInPlaneAngleCubic( 12.3 ); force1.setAmoebaGlobalInPlaneAngleCubic( 12.3 );
force1.setAmoebaGlobalHarmonicInPlaneAngleQuartic( 98.7 ); force1.setAmoebaGlobalInPlaneAngleQuartic( 98.7 );
force1.setAmoebaGlobalHarmonicInPlaneAnglePentic( 91.7 ); force1.setAmoebaGlobalInPlaneAnglePentic( 91.7 );
force1.setAmoebaGlobalHarmonicInPlaneAngleSextic( 93.7 ); force1.setAmoebaGlobalInPlaneAngleSextic( 93.7 );
force1.addAngle(0, 1, 3, 4, 1.0, 2.0); force1.addAngle(0, 1, 3, 4, 1.0, 2.0);
force1.addAngle(0, 2, 3, 5, 2.0, 2.1); force1.addAngle(0, 2, 3, 5, 2.0, 2.1);
...@@ -56,16 +56,16 @@ void testSerialization() { ...@@ -56,16 +56,16 @@ void testSerialization() {
// Serialize and then deserialize it. // Serialize and then deserialize it.
stringstream buffer; stringstream buffer;
XmlSerializer::serialize<AmoebaHarmonicInPlaneAngleForce>(&force1, "Force", buffer); XmlSerializer::serialize<AmoebaInPlaneAngleForce>(&force1, "Force", buffer);
AmoebaHarmonicInPlaneAngleForce* copy = XmlSerializer::deserialize<AmoebaHarmonicInPlaneAngleForce>(buffer); AmoebaInPlaneAngleForce* copy = XmlSerializer::deserialize<AmoebaInPlaneAngleForce>(buffer);
// Compare the two forces to see if they are identical. // Compare the two forces to see if they are identical.
AmoebaHarmonicInPlaneAngleForce& force2 = *copy; AmoebaInPlaneAngleForce& force2 = *copy;
ASSERT_EQUAL(force1.getAmoebaGlobalHarmonicInPlaneAngleCubic(), force2.getAmoebaGlobalHarmonicInPlaneAngleCubic()); ASSERT_EQUAL(force1.getAmoebaGlobalInPlaneAngleCubic(), force2.getAmoebaGlobalInPlaneAngleCubic());
ASSERT_EQUAL(force1.getAmoebaGlobalHarmonicInPlaneAngleQuartic(), force2.getAmoebaGlobalHarmonicInPlaneAngleQuartic()); ASSERT_EQUAL(force1.getAmoebaGlobalInPlaneAngleQuartic(), force2.getAmoebaGlobalInPlaneAngleQuartic());
ASSERT_EQUAL(force1.getAmoebaGlobalHarmonicInPlaneAnglePentic(), force2.getAmoebaGlobalHarmonicInPlaneAnglePentic()); ASSERT_EQUAL(force1.getAmoebaGlobalInPlaneAnglePentic(), force2.getAmoebaGlobalInPlaneAnglePentic());
ASSERT_EQUAL(force1.getAmoebaGlobalHarmonicInPlaneAngleSextic(), force2.getAmoebaGlobalHarmonicInPlaneAngleSextic()); ASSERT_EQUAL(force1.getAmoebaGlobalInPlaneAngleSextic(), force2.getAmoebaGlobalInPlaneAngleSextic());
ASSERT_EQUAL(force1.getNumAngles(), force2.getNumAngles()); ASSERT_EQUAL(force1.getNumAngles(), force2.getNumAngles());
for ( unsigned int ii = 0; ii < static_cast<unsigned int>(force1.getNumAngles()); ii++) { for ( unsigned int ii = 0; ii < static_cast<unsigned int>(force1.getNumAngles()); ii++) {
......
wrappers/python/simtk/openmm/app/data/amoeba2009.xml
View file @ c6ebf6e2
...@@ -3543,7 +3543,7 @@ ...@@ -3543,7 +3543,7 @@
<Atom name="LI" type="382"/> <Atom name="LI" type="382"/>
</Residue> </Residue>
</Residues> </Residues>
<AmoebaHarmonicBondForce bond-cubic="-25.5" bond-quartic="379.3125"> <AmoebaBondForce bond-cubic="-25.5" bond-quartic="379.3125">
<Bond class1="1" class2="2" length="0.1437" k="156900.0"/> <Bond class1="1" class2="2" length="0.1437" k="156900.0"/>
<Bond class1="1" class2="3" length="0.1345" k="201668.8"/> <Bond class1="1" class2="3" length="0.1345" k="201668.8"/>
<Bond class1="1" class2="4" length="0.1028" k="203760.8"/> <Bond class1="1" class2="4" length="0.1028" k="203760.8"/>
...@@ -3664,8 +3664,8 @@ ...@@ -3664,8 +3664,8 @@
<Bond class1="69" class2="69" length="0.1513" k="133929.84"/> <Bond class1="69" class2="69" length="0.1513" k="133929.84"/>
<Bond class1="70" class2="71" length="0.148" k="325054.96"/> <Bond class1="70" class2="71" length="0.148" k="325054.96"/>
<Bond class1="73" class2="74" length="0.09572" k="221584.64"/> <Bond class1="73" class2="74" length="0.09572" k="221584.64"/>
</AmoebaHarmonicBondForce> </AmoebaBondForce>
<AmoebaHarmonicAngleForce angle-cubic="-0.014" angle-quartic="5.6e-05" angle-pentic="-7e-07" angle-sextic="2.2e-08"> <AmoebaAngleForce angle-cubic="-0.014" angle-quartic="5.6e-05" angle-pentic="-7e-07" angle-sextic="2.2e-08">
<Angle class1="2" class2="1" class3="3" k="0.0637259642196" angle1="122.00" /> <Angle class1="2" class2="1" class3="3" k="0.0637259642196" angle1="122.00" />
<Angle class1="2" class2="1" class3="4" k="0.0407846171005" angle1="117.00" /> <Angle class1="2" class2="1" class3="4" k="0.0407846171005" angle1="117.00" />
<Angle class1="3" class2="1" class3="4" k="0.0458826942381" angle1="121.00" /> <Angle class1="3" class2="1" class3="4" k="0.0458826942381" angle1="121.00" />
...@@ -3962,7 +3962,7 @@ ...@@ -3962,7 +3962,7 @@
<Angle class1="62" class2="70" class3="71" k="0.0966850329139" angle1="110.00" /> <Angle class1="62" class2="70" class3="71" k="0.0966850329139" angle1="110.00" />
<Angle class1="71" class2="70" class3="71" k="0.114553793281" angle1="121.20" /> <Angle class1="71" class2="70" class3="71" k="0.114553793281" angle1="121.20" />
<Angle class1="74" class2="73" class3="74" k="0.0433973816335" angle1="108.50" /> <Angle class1="74" class2="73" class3="74" k="0.0433973816335" angle1="108.50" />
</AmoebaHarmonicAngleForce> </AmoebaAngleForce>
<AmoebaOutOfPlaneBendForce type="ALLINGER" opbend-cubic="-0.014" opbend-quartic="5.6e-05" opbend-pentic="-7e-07" opbend-sextic="2.2e-08"> <AmoebaOutOfPlaneBendForce type="ALLINGER" opbend-cubic="-0.014" opbend-quartic="5.6e-05" opbend-pentic="-7e-07" opbend-sextic="2.2e-08">
<Angle class1="2" class2="1" class3="0" class4="0" k="0.0531474541591"/> <Angle class1="2" class2="1" class3="0" class4="0" k="0.0531474541591"/>
<Angle class1="3" class2="1" class3="0" class4="0" k="0.0898536095496"/> <Angle class1="3" class2="1" class3="0" class4="0" k="0.0898536095496"/>
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