Skip to content

GitLab

"vscode:/vscode.git/clone" did not exist on "feec33e61c8cd75d0ae4c2bf92ce381994ce3ad2"
Commit 8469621f authored by peastman's avatar peastman Committed by GitHub
Browse files

Merge pull request #1747 from peastman/realtype 

Eliminated RealOpenMM
parents b84e22ba 6813ca57
Hide whitespace changes
Inline Side-by-side
Showing with 474 additions and 650 deletions
platforms/reference/include/ReferencePME.h
View file @ 8469621f
...@@ -32,13 +32,13 @@ ...@@ -32,13 +32,13 @@
#ifndef __ReferencePME_H__ #ifndef __ReferencePME_H__
#define __ReferencePME_H__ #define __ReferencePME_H__
#include "RealVec.h" #include "openmm/Vec3.h"
#include "openmm/internal/windowsExport.h" #include "openmm/internal/windowsExport.h"
#include <vector> #include <vector>
namespace OpenMM { namespace OpenMM {
typedef RealOpenMM rvec[3]; typedef double rvec[3];
typedef struct pme * typedef struct pme *
...@@ -59,12 +59,12 @@ pme_t; ...@@ -59,12 +59,12 @@ pme_t;
* epsilon_r Dielectric coefficient, typically 1.0. * epsilon_r Dielectric coefficient, typically 1.0.
*/ */
int OPENMM_EXPORT int OPENMM_EXPORT
pme_init(pme_t * ppme, pme_init(pme_t* ppme,
RealOpenMM ewaldcoeff, double ewaldcoeff,
int natoms, int natoms,
const int ngrid[3], const int ngrid[3],
int pme_order, int pme_order,
RealOpenMM epsilon_r); double epsilon_r);
/* /*
* Evaluate reciprocal space PME energy and forces. * Evaluate reciprocal space PME energy and forces.
...@@ -79,15 +79,15 @@ pme_init(pme_t * ppme, ...@@ -79,15 +79,15 @@ pme_init(pme_t * ppme,
* energy Total energy (will be written in units of kJ/mol) * energy Total energy (will be written in units of kJ/mol)
*/ */
int OPENMM_EXPORT int OPENMM_EXPORT
pme_exec(pme_t pme, pme_exec(pme_t pme,
const std::vector<OpenMM::RealVec>& atomCoordinates, const std::vector<OpenMM::Vec3>& atomCoordinates,
std::vector<OpenMM::RealVec>& forces, std::vector<OpenMM::Vec3>& forces,
const std::vector<RealOpenMM>& charges, const std::vector<double>& charges,
const OpenMM::RealVec periodicBoxVectors[3], const OpenMM::Vec3 periodicBoxVectors[3],
RealOpenMM * energy); double* energy);
/* /**
* Evaluate reciprocal space PME dispersion energy and forces. * Evaluate reciprocal space PME dispersion energy and forces.
* *
* Args: * Args:
...@@ -100,12 +100,12 @@ pme_exec(pme_t pme, ...@@ -100,12 +100,12 @@ pme_exec(pme_t pme,
* energy Total energy (will be written in units of kJ/mol) * energy Total energy (will be written in units of kJ/mol)
*/ */
int OPENMM_EXPORT int OPENMM_EXPORT
pme_exec_dpme(pme_t pme, pme_exec_dpme(pme_t pme,
const std::vector<OpenMM::RealVec>& atomCoordinates, const std::vector<OpenMM::Vec3>& atomCoordinates,
std::vector<OpenMM::RealVec>& forces, std::vector<OpenMM::Vec3>& forces,
const std::vector<RealOpenMM>& c6s, const std::vector<double>& c6s,
const OpenMM::RealVec periodicBoxVectors[3], const OpenMM::Vec3 periodicBoxVectors[3],
RealOpenMM * energy); double* energy);
......
platforms/reference/include/ReferencePairIxn.h
View file @ 8469621f
...@@ -25,7 +25,7 @@ ...@@ -25,7 +25,7 @@
#ifndef __ReferencePairIxn_H__ #ifndef __ReferencePairIxn_H__
#define __ReferencePairIxn_H__ #define __ReferencePairIxn_H__
#include "RealVec.h" #include "openmm/Vec3.h"
#include "openmm/internal/windowsExport.h" #include "openmm/internal/windowsExport.h"
#include <vector> #include <vector>
...@@ -68,10 +68,10 @@ class OPENMM_EXPORT ReferencePairIxn { ...@@ -68,10 +68,10 @@ class OPENMM_EXPORT ReferencePairIxn {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
virtual void calculatePairIxn(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, virtual void calculatePairIxn(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates,
RealOpenMM** atomParameters, int** exclusions, double** atomParameters, int** exclusions,
RealOpenMM* fixedParameters, std::vector<OpenMM::RealVec>& forces, double* fixedParameters, std::vector<OpenMM::Vec3>& forces,
RealOpenMM* energyByAtom, RealOpenMM* totalEnergy) const = 0; double* energyByAtom, double* totalEnergy) const = 0;
}; };
......
platforms/reference/include/ReferenceProperDihedralBond.h
View file @ 8469621f
...@@ -34,7 +34,7 @@ class OPENMM_EXPORT ReferenceProperDihedralBond : public ReferenceBondIxn { ...@@ -34,7 +34,7 @@ class OPENMM_EXPORT ReferenceProperDihedralBond : public ReferenceBondIxn {
private: private:
bool usePeriodic; bool usePeriodic;
RealVec boxVectors[3]; Vec3 boxVectors[3];
public: public:
...@@ -62,7 +62,7 @@ class OPENMM_EXPORT ReferenceProperDihedralBond : public ReferenceBondIxn { ...@@ -62,7 +62,7 @@ class OPENMM_EXPORT ReferenceProperDihedralBond : public ReferenceBondIxn {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void setPeriodic(OpenMM::RealVec* vectors); void setPeriodic(OpenMM::Vec3* vectors);
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -78,9 +78,9 @@ class OPENMM_EXPORT ReferenceProperDihedralBond : public ReferenceBondIxn { ...@@ -78,9 +78,9 @@ class OPENMM_EXPORT ReferenceProperDihedralBond : public ReferenceBondIxn {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void calculateBondIxn(int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates, void calculateBondIxn(int* atomIndices, std::vector<OpenMM::Vec3>& atomCoordinates,
RealOpenMM* parameters, std::vector<OpenMM::RealVec>& forces, double* parameters, std::vector<OpenMM::Vec3>& forces,
RealOpenMM* totalEnergy, double* energyParamDerivs); double* totalEnergy, double* energyParamDerivs);
}; };
......
platforms/reference/include/ReferenceRbDihedralBond.h
View file @ 8469621f
...@@ -34,7 +34,7 @@ class OPENMM_EXPORT ReferenceRbDihedralBond : public ReferenceBondIxn { ...@@ -34,7 +34,7 @@ class OPENMM_EXPORT ReferenceRbDihedralBond : public ReferenceBondIxn {
private: private:
bool usePeriodic; bool usePeriodic;
RealVec boxVectors[3]; Vec3 boxVectors[3];
public: public:
...@@ -62,7 +62,7 @@ class OPENMM_EXPORT ReferenceRbDihedralBond : public ReferenceBondIxn { ...@@ -62,7 +62,7 @@ class OPENMM_EXPORT ReferenceRbDihedralBond : public ReferenceBondIxn {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void setPeriodic(OpenMM::RealVec* vectors); void setPeriodic(OpenMM::Vec3* vectors);
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -76,9 +76,9 @@ class OPENMM_EXPORT ReferenceRbDihedralBond : public ReferenceBondIxn { ...@@ -76,9 +76,9 @@ class OPENMM_EXPORT ReferenceRbDihedralBond : public ReferenceBondIxn {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void calculateBondIxn(int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates, void calculateBondIxn(int* atomIndices, std::vector<OpenMM::Vec3>& atomCoordinates,
RealOpenMM* parameters, std::vector<OpenMM::RealVec>& forces, double* parameters, std::vector<OpenMM::Vec3>& forces,
RealOpenMM* totalEnergy, double* energyParamDerivs); double* totalEnergy, double* energyParamDerivs);
}; };
......
platforms/reference/include/ReferenceSETTLEAlgorithm.h
View file @ 8469621f
...@@ -44,7 +44,7 @@ namespace OpenMM { ...@@ -44,7 +44,7 @@ namespace OpenMM {
class OPENMM_EXPORT ReferenceSETTLEAlgorithm : public ReferenceConstraintAlgorithm { class OPENMM_EXPORT ReferenceSETTLEAlgorithm : public ReferenceConstraintAlgorithm {
public: public:
ReferenceSETTLEAlgorithm(const std::vector<int>& atom1, const std::vector<int>& atom2, const std::vector<int>& atom3, ReferenceSETTLEAlgorithm(const std::vector<int>& atom1, const std::vector<int>& atom2, const std::vector<int>& atom3,
const std::vector<RealOpenMM>& distance1, const std::vector<RealOpenMM>& distance2, std::vector<RealOpenMM>& masses); const std::vector<double>& distance1, const std::vector<double>& distance2, std::vector<double>& masses);
/** /**
* Get the number of clusters. * Get the number of clusters.
...@@ -60,7 +60,7 @@ public: ...@@ -60,7 +60,7 @@ public:
* @param distance1 the distance between atoms 1 and 2 * @param distance1 the distance between atoms 1 and 2
* @param distance2 the distance between atoms 2 and 3 * @param distance2 the distance between atoms 2 and 3
*/ */
void getClusterParameters(int index, int& atom1, int& atom2, int& atom3, RealOpenMM& distance1, RealOpenMM& distance2) const; void getClusterParameters(int index, int& atom1, int& atom2, int& atom3, double& distance1, double& distance2) const;
/** /**
* Apply the constraint algorithm. * Apply the constraint algorithm.
* *
...@@ -69,7 +69,7 @@ public: ...@@ -69,7 +69,7 @@ public:
* @param inverseMasses 1/mass * @param inverseMasses 1/mass
* @param tolerance the constraint tolerance * @param tolerance the constraint tolerance
*/ */
void apply(std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& atomCoordinatesP, std::vector<RealOpenMM>& inverseMasses, RealOpenMM tolerance); void apply(std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& atomCoordinatesP, std::vector<double>& inverseMasses, double tolerance);
/** /**
* Apply the constraint algorithm to velocities. * Apply the constraint algorithm to velocities.
...@@ -79,14 +79,14 @@ public: ...@@ -79,14 +79,14 @@ public:
* @param inverseMasses 1/mass * @param inverseMasses 1/mass
* @param tolerance the constraint tolerance * @param tolerance the constraint tolerance
*/ */
void applyToVelocities(std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities, std::vector<RealOpenMM>& inverseMasses, RealOpenMM tolerance); void applyToVelocities(std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities, std::vector<double>& inverseMasses, double tolerance);
private: private:
std::vector<int> atom1; std::vector<int> atom1;
std::vector<int> atom2; std::vector<int> atom2;
std::vector<int> atom3; std::vector<int> atom3;
std::vector<RealOpenMM> distance1; std::vector<double> distance1;
std::vector<RealOpenMM> distance2; std::vector<double> distance2;
std::vector<RealOpenMM> masses; std::vector<double> masses;
}; };
} // namespace OpenMM } // namespace OpenMM
......
platforms/reference/include/ReferenceStochasticDynamics.h
View file @ 8469621f
...@@ -34,9 +34,9 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics { ...@@ -34,9 +34,9 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
protected: protected:
std::vector<OpenMM::RealVec> xPrime; std::vector<OpenMM::Vec3> xPrime;
std::vector<RealOpenMM> inverseMasses; std::vector<double> inverseMasses;
RealOpenMM friction; double friction;
public: public:
...@@ -51,7 +51,7 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics { ...@@ -51,7 +51,7 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceStochasticDynamics(int numberOfAtoms, RealOpenMM deltaT, RealOpenMM friction, RealOpenMM temperature); ReferenceStochasticDynamics(int numberOfAtoms, double deltaT, double friction, double temperature);
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -67,7 +67,7 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics { ...@@ -67,7 +67,7 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM getFriction() const; double getFriction() const;
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -82,8 +82,8 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics { ...@@ -82,8 +82,8 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void update(const OpenMM::System& system, std::vector<OpenMM::RealVec>& atomCoordinates, void update(const OpenMM::System& system, std::vector<OpenMM::Vec3>& atomCoordinates,
std::vector<OpenMM::RealVec>& velocities, std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, RealOpenMM tolerance); std::vector<OpenMM::Vec3>& velocities, std::vector<OpenMM::Vec3>& forces, std::vector<double>& masses, double tolerance);
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -98,8 +98,8 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics { ...@@ -98,8 +98,8 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
virtual void updatePart1(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities, virtual void updatePart1(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities,
std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& inverseMasses, std::vector<OpenMM::RealVec>& xPrime); std::vector<OpenMM::Vec3>& forces, std::vector<double>& inverseMasses, std::vector<OpenMM::Vec3>& xPrime);
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -113,8 +113,8 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics { ...@@ -113,8 +113,8 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
virtual void updatePart2(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities, virtual void updatePart2(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities,
std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& inverseMasses, std::vector<OpenMM::RealVec>& xPrime); std::vector<OpenMM::Vec3>& forces, std::vector<double>& inverseMasses, std::vector<OpenMM::Vec3>& xPrime);
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -127,8 +127,8 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics { ...@@ -127,8 +127,8 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
virtual void updatePart3(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities, virtual void updatePart3(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities,
std::vector<RealOpenMM>& inverseMasses, std::vector<OpenMM::RealVec>& xPrime); std::vector<double>& inverseMasses, std::vector<OpenMM::Vec3>& xPrime);
}; };
} // namespace OpenMM } // namespace OpenMM
......
platforms/reference/include/ReferenceVariableStochasticDynamics.h
View file @ 8469621f
...@@ -33,9 +33,9 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics { ...@@ -33,9 +33,9 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
private: private:
std::vector<OpenMM::RealVec> xPrime; std::vector<OpenMM::Vec3> xPrime;
std::vector<RealOpenMM> inverseMasses; std::vector<double> inverseMasses;
RealOpenMM friction, _accuracy; double friction, _accuracy;
public: public:
...@@ -50,7 +50,7 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics { ...@@ -50,7 +50,7 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceVariableStochasticDynamics(int numberOfAtoms, RealOpenMM friction, RealOpenMM temperature, RealOpenMM accuracy); ReferenceVariableStochasticDynamics(int numberOfAtoms, double friction, double temperature, double accuracy);
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -66,7 +66,7 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics { ...@@ -66,7 +66,7 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM getFriction() const; double getFriction() const;
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -76,7 +76,7 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics { ...@@ -76,7 +76,7 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM getAccuracy() const; double getAccuracy() const;
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -84,7 +84,7 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics { ...@@ -84,7 +84,7 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void setAccuracy(RealOpenMM accuracy); void setAccuracy(double accuracy);
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -100,8 +100,8 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics { ...@@ -100,8 +100,8 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void update(const OpenMM::System& system, std::vector<OpenMM::RealVec>& atomCoordinates, void update(const OpenMM::System& system, std::vector<OpenMM::Vec3>& atomCoordinates,
std::vector<OpenMM::RealVec>& velocities, std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, RealOpenMM maxStepSize, RealOpenMM tolerance); std::vector<OpenMM::Vec3>& velocities, std::vector<OpenMM::Vec3>& forces, std::vector<double>& masses, double maxStepSize, double tolerance);
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -118,9 +118,9 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics { ...@@ -118,9 +118,9 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void updatePart1(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities, void updatePart1(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities,
std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, std::vector<RealOpenMM>& inverseMasses, std::vector<OpenMM::Vec3>& forces, std::vector<double>& masses, std::vector<double>& inverseMasses,
std::vector<OpenMM::RealVec>& xPrime, RealOpenMM maxStepSize); std::vector<OpenMM::Vec3>& xPrime, double maxStepSize);
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -134,9 +134,9 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics { ...@@ -134,9 +134,9 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void updatePart2(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities, void updatePart2(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities,
std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& inverseMasses, std::vector<OpenMM::Vec3>& forces, std::vector<double>& inverseMasses,
std::vector<OpenMM::RealVec>& xPrime); std::vector<OpenMM::Vec3>& xPrime);
}; };
......
platforms/reference/include/ReferenceVariableVerletDynamics.h
View file @ 8469621f
...@@ -33,9 +33,9 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics { ...@@ -33,9 +33,9 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics {
private: private:
std::vector<OpenMM::RealVec> xPrime; std::vector<OpenMM::Vec3> xPrime;
std::vector<RealOpenMM> inverseMasses; std::vector<double> inverseMasses;
RealOpenMM _accuracy; double _accuracy;
public: public:
...@@ -48,7 +48,7 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics { ...@@ -48,7 +48,7 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceVariableVerletDynamics(int numberOfAtoms, RealOpenMM accuracy); ReferenceVariableVerletDynamics(int numberOfAtoms, double accuracy);
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -66,7 +66,7 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics { ...@@ -66,7 +66,7 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM getAccuracy() const; double getAccuracy() const;
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -74,7 +74,7 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics { ...@@ -74,7 +74,7 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void setAccuracy(RealOpenMM accuracy); void setAccuracy(double accuracy);
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -90,8 +90,8 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics { ...@@ -90,8 +90,8 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void update(const OpenMM::System& system, std::vector<OpenMM::RealVec>& atomCoordinates, void update(const OpenMM::System& system, std::vector<OpenMM::Vec3>& atomCoordinates,
std::vector<OpenMM::RealVec>& velocities, std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, RealOpenMM maxStepSize, RealOpenMM tolerance); std::vector<OpenMM::Vec3>& velocities, std::vector<OpenMM::Vec3>& forces, std::vector<double>& masses, double maxStepSize, double tolerance);
}; };
......
platforms/reference/include/ReferenceVerletDynamics.h
View file @ 8469621f
...@@ -33,8 +33,8 @@ class ReferenceVerletDynamics : public ReferenceDynamics { ...@@ -33,8 +33,8 @@ class ReferenceVerletDynamics : public ReferenceDynamics {
private: private:
std::vector<OpenMM::RealVec> xPrime; std::vector<OpenMM::Vec3> xPrime;
std::vector<RealOpenMM> inverseMasses; std::vector<double> inverseMasses;
public: public:
...@@ -49,7 +49,7 @@ class ReferenceVerletDynamics : public ReferenceDynamics { ...@@ -49,7 +49,7 @@ class ReferenceVerletDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceVerletDynamics(int numberOfAtoms, RealOpenMM deltaT); ReferenceVerletDynamics(int numberOfAtoms, double deltaT);
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -72,8 +72,8 @@ class ReferenceVerletDynamics : public ReferenceDynamics { ...@@ -72,8 +72,8 @@ class ReferenceVerletDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void update(const OpenMM::System& system, std::vector<OpenMM::RealVec>& atomCoordinates, void update(const OpenMM::System& system, std::vector<OpenMM::Vec3>& atomCoordinates,
std::vector<OpenMM::RealVec>& velocities, std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, RealOpenMM tolerance); std::vector<OpenMM::Vec3>& velocities, std::vector<OpenMM::Vec3>& forces, std::vector<double>& masses, double tolerance);
}; };
......
platforms/reference/include/ReferenceVirtualSites.h
View file @ 8469621f
...@@ -33,7 +33,7 @@ ...@@ -33,7 +33,7 @@
#define __ReferenceVirtualSites_H__ #define __ReferenceVirtualSites_H__
#include "openmm/System.h" #include "openmm/System.h"
#include "RealVec.h" #include "openmm/Vec3.h"
#include <vector> #include <vector>
namespace OpenMM { namespace OpenMM {
...@@ -43,11 +43,11 @@ public: ...@@ -43,11 +43,11 @@ public:
/** /**
* Compute the positions of all virtual sites. * Compute the positions of all virtual sites.
*/ */
static void computePositions(const OpenMM::System& system, std::vector<OpenMM::RealVec>& atomCoordinates); static void computePositions(const OpenMM::System& system, std::vector<OpenMM::Vec3>& atomCoordinates);
/** /**
* Distribute forces from virtual sites to the atoms they are based on. * Distribute forces from virtual sites to the atoms they are based on.
*/ */
static void distributeForces(const OpenMM::System& system, const std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& forces); static void distributeForces(const OpenMM::System& system, const std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& forces);
}; };
} // namespace OpenMM } // namespace OpenMM
......
platforms/reference/include/SimTKOpenMMRealType.h
View file @ 8469621f
/* Portions copyright (c) 2006 Stanford University and Simbios. /* Portions copyright (c) 2006-2017 Stanford University and Simbios.
* Contributors: Pande Group * Contributors: Pande Group
* *
* Permission is hereby granted, free of charge, to any person obtaining * Permission is hereby granted, free of charge, to any person obtaining
...@@ -28,46 +28,6 @@ ...@@ -28,46 +28,6 @@
#include <cmath> #include <cmath>
// Set RealOpenMMType to 2 for double precision, 1 for float
#ifndef RealOpenMMType
#define RealOpenMMType 2
#endif
#if RealOpenMMType == 1
#define RealOpenMM float
#define SQRT sqrtf
#define POW powf
#define SIN sinf
#define COS cosf
#define TAN tanf
// LOG is used in Vishal's gpu code; modifying LOG -> LN
#define LN logf
#define EXP expf
#define FABS fabsf
#define ACOS acosf
#define ASIN asinf
#define ATAN atanf
#define TANH tanhf
#define FLOOR floorf
#define ATOF atoff
#define PI_M 3.141592653589f
#define TWO_SIX 1.122462048309372981f
#define RADIAN 57.29577951308f
#define RADIAN_TO_DEGREE 57.29577951308f
#define LOG_TEN 2.302585092994045684f
#define SQRT_TWO 1.41421356237309504f
#define DEGREE_TO_RADIAN 0.01745329252f
#define RADIAN_INVERSE 0.01745329252f
#else
#define RealOpenMM double #define RealOpenMM double
#define SQRT sqrt #define SQRT sqrt
#define POW pow #define POW pow
...@@ -98,8 +58,6 @@ ...@@ -98,8 +58,6 @@
#define DEGREE_TO_RADIAN 0.01745329252 #define DEGREE_TO_RADIAN 0.01745329252
#define RADIAN_INVERSE 0.01745329252 #define RADIAN_INVERSE 0.01745329252
#endif
#define DOT3(u,v) ((u[0])*(v[0]) + (u[1])*(v[1]) + (u[2])*(v[2])) #define DOT3(u,v) ((u[0])*(v[0]) + (u[1])*(v[1]) + (u[2])*(v[2]))
#define MATRIXDOT3(u,v) u[0]*v[0] + u[1]*v[1] + u[2]*v[2] + \ #define MATRIXDOT3(u,v) u[0]*v[0] + u[1]*v[1] + u[2]*v[2] + \
......
platforms/reference/include/SimTKOpenMMUtilities.h
View file @ 8469621f
...@@ -27,7 +27,7 @@ ...@@ -27,7 +27,7 @@
// class of shared, static utility methods // class of shared, static utility methods
#include "RealVec.h" #include "SimTKOpenMMRealType.h"
#include "sfmt/SFMT.h" #include "sfmt/SFMT.h"
#include "openmm/internal/windowsExport.h" #include "openmm/internal/windowsExport.h"
...@@ -49,7 +49,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities { ...@@ -49,7 +49,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
static uint32_t _randomNumberSeed; static uint32_t _randomNumberSeed;
static bool _randomInitialized; static bool _randomInitialized;
static bool nextGaussianIsValid; static bool nextGaussianIsValid;
static RealOpenMM nextGaussian; static double nextGaussian;
static OpenMM_SFMT::SFMT sfmt; static OpenMM_SFMT::SFMT sfmt;
public: public:
...@@ -61,7 +61,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities { ...@@ -61,7 +61,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
Allocate 1D RealOpenMM array (Simbios) Allocate 1D double array (Simbios)
array[i] array[i]
...@@ -75,13 +75,13 @@ class OPENMM_EXPORT SimTKOpenMMUtilities { ...@@ -75,13 +75,13 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
static RealOpenMM* allocateOneDRealOpenMMArray(int iSize, RealOpenMM* array1D, int initialize, static double* allocateOneDRealOpenMMArray(int iSize, double* array1D, int initialize,
RealOpenMM initialValue, double initialValue,
const std::string& idString = std::string("1DArray")); const std::string& idString = std::string("1DArray"));
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
Allocate 2D RealOpenMM array (Simbios) Allocate 2D double array (Simbios)
array[i][j] array[i][j]
...@@ -96,14 +96,14 @@ class OPENMM_EXPORT SimTKOpenMMUtilities { ...@@ -96,14 +96,14 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
static RealOpenMM** allocateTwoDRealOpenMMArray(int iSize, int jSize, static double** allocateTwoDRealOpenMMArray(int iSize, int jSize,
RealOpenMM** array2D, int initialize, double** array2D, int initialize,
RealOpenMM initialValue, double initialValue,
const std::string& idString = std::string("2DArray")); const std::string& idString = std::string("2DArray"));
/* --------------------------------------------------------------------------------------- /* ---------------------------------------------------------------------------------------
Free 2D RealOpenMM array (Simbios) Free 2D double array (Simbios)
array[i][j] array[i][j]
...@@ -112,12 +112,12 @@ class OPENMM_EXPORT SimTKOpenMMUtilities { ...@@ -112,12 +112,12 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
static void freeOneDRealOpenMMArray(RealOpenMM* array1D, static void freeOneDRealOpenMMArray(double* array1D,
const std::string& idString = std::string("1DArray")); const std::string& idString = std::string("1DArray"));
/* --------------------------------------------------------------------------------------- /* ---------------------------------------------------------------------------------------
Free 2D RealOpenMM array (Simbios) Free 2D double array (Simbios)
array[i][j] array[i][j]
...@@ -126,12 +126,12 @@ class OPENMM_EXPORT SimTKOpenMMUtilities { ...@@ -126,12 +126,12 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
static void freeTwoDRealOpenMMArray(RealOpenMM** array2D, static void freeTwoDRealOpenMMArray(double** array2D,
const std::string& idString = std::string("2DArray")); const std::string& idString = std::string("2DArray"));
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
Initialize 2D RealOpenMM array (Simbios) Initialize 2D double array (Simbios)
array[i][j] array[i][j]
...@@ -143,7 +143,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities { ...@@ -143,7 +143,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
static void initialize2DRealOpenMMArray(int iSize, int jSize, static void initialize2DRealOpenMMArray(int iSize, int jSize,
RealOpenMM** array2D, RealOpenMM initialValue); double** array2D, double initialValue);
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -159,7 +159,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities { ...@@ -159,7 +159,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
static void crossProductVector3(RealOpenMM* vectorX, RealOpenMM* vectorY, RealOpenMM* vectorZ); static void crossProductVector3(double* vectorX, double* vectorY, double* vectorZ);
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -169,7 +169,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities { ...@@ -169,7 +169,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
static RealOpenMM getNormallyDistributedRandomNumber(); static double getNormallyDistributedRandomNumber();
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -179,7 +179,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities { ...@@ -179,7 +179,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
static RealOpenMM getUniformlyDistributedRandomNumber(); static double getUniformlyDistributedRandomNumber();
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
......
platforms/reference/include/fftpack.h
View file @ 8469621f
...@@ -20,7 +20,6 @@ ...@@ -20,7 +20,6 @@
#include <stdio.h> #include <stdio.h>
#include "RealVec.h"
#include "openmm/internal/windowsExport.h" #include "openmm/internal/windowsExport.h"
#ifdef __cplusplus #ifdef __cplusplus
...@@ -33,15 +32,15 @@ extern "C" { ...@@ -33,15 +32,15 @@ extern "C" {
class t_complex { class t_complex {
public: public:
RealOpenMM re; double re;
RealOpenMM im; double im;
t_complex() : re(0.0), im(0.0) { t_complex() : re(0.0), im(0.0) {
} }
t_complex(RealOpenMM re, RealOpenMM im) : re(re), im(im) { t_complex(double re, double im) : re(re), im(im) {
} }
t_complex(const t_complex& c) : re(c.re), im(c.im) { t_complex(const t_complex& c) : re(c.re), im(c.im) {
} }
t_complex operator*(RealOpenMM r) { t_complex operator*(double r) {
return t_complex(re*r, im*r); return t_complex(re*r, im*r);
} }
t_complex operator+(const t_complex& c) const { t_complex operator+(const t_complex& c) const {
......
platforms/reference/src/ReferenceKernels.cpp
View file @ 8469621f
...@@ -94,10 +94,10 @@ static int** allocateIntArray(int length, int width) { ...@@ -94,10 +94,10 @@ static int** allocateIntArray(int length, int width) {
return array; return array;
} }
static RealOpenMM** allocateRealArray(int length, int width) { static double** allocateRealArray(int length, int width) {
RealOpenMM** array = new RealOpenMM*[length]; double** array = new double*[length];
for (int i = 0; i < length; ++i) for (int i = 0; i < length; ++i)
array[i] = new RealOpenMM[width]; array[i] = new double[width];
return array; return array;
} }
...@@ -109,7 +109,7 @@ static void disposeIntArray(int** array, int size) { ...@@ -109,7 +109,7 @@ static void disposeIntArray(int** array, int size) {
} }
} }
static void disposeRealArray(RealOpenMM** array, int size) { static void disposeRealArray(double** array, int size) {
if (array) { if (array) {
for (int i = 0; i < size; ++i) for (int i = 0; i < size; ++i)
delete[] array[i]; delete[] array[i];
...@@ -117,29 +117,29 @@ static void disposeRealArray(RealOpenMM** array, int size) { ...@@ -117,29 +117,29 @@ static void disposeRealArray(RealOpenMM** array, int size) {
} }
} }
static vector<RealVec>& extractPositions(ContextImpl& context) { static vector<Vec3>& extractPositions(ContextImpl& context) {
ReferencePlatform::PlatformData* data = reinterpret_cast<ReferencePlatform::PlatformData*>(context.getPlatformData()); ReferencePlatform::PlatformData* data = reinterpret_cast<ReferencePlatform::PlatformData*>(context.getPlatformData());
return *((vector<RealVec>*) data->positions); return *((vector<Vec3>*) data->positions);
} }
static vector<RealVec>& extractVelocities(ContextImpl& context) { static vector<Vec3>& extractVelocities(ContextImpl& context) {
ReferencePlatform::PlatformData* data = reinterpret_cast<ReferencePlatform::PlatformData*>(context.getPlatformData()); ReferencePlatform::PlatformData* data = reinterpret_cast<ReferencePlatform::PlatformData*>(context.getPlatformData());
return *((vector<RealVec>*) data->velocities); return *((vector<Vec3>*) data->velocities);
} }
static vector<RealVec>& extractForces(ContextImpl& context) { static vector<Vec3>& extractForces(ContextImpl& context) {
ReferencePlatform::PlatformData* data = reinterpret_cast<ReferencePlatform::PlatformData*>(context.getPlatformData()); ReferencePlatform::PlatformData* data = reinterpret_cast<ReferencePlatform::PlatformData*>(context.getPlatformData());
return *((vector<RealVec>*) data->forces); return *((vector<Vec3>*) data->forces);
} }
static RealVec& extractBoxSize(ContextImpl& context) { static Vec3& extractBoxSize(ContextImpl& context) {
ReferencePlatform::PlatformData* data = reinterpret_cast<ReferencePlatform::PlatformData*>(context.getPlatformData()); ReferencePlatform::PlatformData* data = reinterpret_cast<ReferencePlatform::PlatformData*>(context.getPlatformData());
return *(RealVec*) data->periodicBoxSize; return *(Vec3*) data->periodicBoxSize;
} }
static RealVec* extractBoxVectors(ContextImpl& context) { static Vec3* extractBoxVectors(ContextImpl& context) {
ReferencePlatform::PlatformData* data = reinterpret_cast<ReferencePlatform::PlatformData*>(context.getPlatformData()); ReferencePlatform::PlatformData* data = reinterpret_cast<ReferencePlatform::PlatformData*>(context.getPlatformData());
return (RealVec*) data->periodicBoxVectors; return (Vec3*) data->periodicBoxVectors;
} }
static ReferenceConstraints& extractConstraints(ContextImpl& context) { static ReferenceConstraints& extractConstraints(ContextImpl& context) {
...@@ -168,14 +168,14 @@ static void validateVariables(const Lepton::ExpressionTreeNode& node, const set< ...@@ -168,14 +168,14 @@ static void validateVariables(const Lepton::ExpressionTreeNode& node, const set<
* for a leapfrog integrator. * for a leapfrog integrator.
*/ */
static double computeShiftedKineticEnergy(ContextImpl& context, vector<double>& masses, double timeShift) { static double computeShiftedKineticEnergy(ContextImpl& context, vector<double>& masses, double timeShift) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context); vector<Vec3>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
int numParticles = context.getSystem().getNumParticles(); int numParticles = context.getSystem().getNumParticles();
// Compute the shifted velocities. // Compute the shifted velocities.
vector<RealVec> shiftedVel(numParticles); vector<Vec3> shiftedVel(numParticles);
for (int i = 0; i < numParticles; ++i) { for (int i = 0; i < numParticles; ++i) {
if (masses[i] > 0) if (masses[i] > 0)
shiftedVel[i] = velData[i]+forceData[i]*(timeShift/masses[i]); shiftedVel[i] = velData[i]+forceData[i]*(timeShift/masses[i]);
...@@ -203,13 +203,13 @@ void ReferenceCalcForcesAndEnergyKernel::initialize(const System& system) { ...@@ -203,13 +203,13 @@ void ReferenceCalcForcesAndEnergyKernel::initialize(const System& system) {
} }
void ReferenceCalcForcesAndEnergyKernel::beginComputation(ContextImpl& context, bool includeForces, bool includeEnergy, int groups) { void ReferenceCalcForcesAndEnergyKernel::beginComputation(ContextImpl& context, bool includeForces, bool includeEnergy, int groups) {
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
if (includeForces) { if (includeForces) {
int numParticles = context.getSystem().getNumParticles(); int numParticles = context.getSystem().getNumParticles();
for (int i = 0; i < numParticles; ++i) { for (int i = 0; i < numParticles; ++i) {
forceData[i][0] = (RealOpenMM) 0.0; forceData[i][0] = 0.0;
forceData[i][1] = (RealOpenMM) 0.0; forceData[i][1] = 0.0;
forceData[i][2] = (RealOpenMM) 0.0; forceData[i][2] = 0.0;
} }
} }
else else
...@@ -239,7 +239,7 @@ void ReferenceUpdateStateDataKernel::setTime(ContextImpl& context, double time) ...@@ -239,7 +239,7 @@ void ReferenceUpdateStateDataKernel::setTime(ContextImpl& context, double time)
void ReferenceUpdateStateDataKernel::getPositions(ContextImpl& context, std::vector<Vec3>& positions) { void ReferenceUpdateStateDataKernel::getPositions(ContextImpl& context, std::vector<Vec3>& positions) {
int numParticles = context.getSystem().getNumParticles(); int numParticles = context.getSystem().getNumParticles();
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
positions.resize(numParticles); positions.resize(numParticles);
for (int i = 0; i < numParticles; ++i) for (int i = 0; i < numParticles; ++i)
positions[i] = Vec3(posData[i][0], posData[i][1], posData[i][2]); positions[i] = Vec3(posData[i][0], posData[i][1], posData[i][2]);
...@@ -247,17 +247,17 @@ void ReferenceUpdateStateDataKernel::getPositions(ContextImpl& context, std::vec ...@@ -247,17 +247,17 @@ void ReferenceUpdateStateDataKernel::getPositions(ContextImpl& context, std::vec
void ReferenceUpdateStateDataKernel::setPositions(ContextImpl& context, const std::vector<Vec3>& positions) { void ReferenceUpdateStateDataKernel::setPositions(ContextImpl& context, const std::vector<Vec3>& positions) {
int numParticles = context.getSystem().getNumParticles(); int numParticles = context.getSystem().getNumParticles();
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
for (int i = 0; i < numParticles; ++i) { for (int i = 0; i < numParticles; ++i) {
posData[i][0] = (RealOpenMM) positions[i][0]; posData[i][0] = positions[i][0];
posData[i][1] = (RealOpenMM) positions[i][1]; posData[i][1] = positions[i][1];
posData[i][2] = (RealOpenMM) positions[i][2]; posData[i][2] = positions[i][2];
} }
} }
void ReferenceUpdateStateDataKernel::getVelocities(ContextImpl& context, std::vector<Vec3>& velocities) { void ReferenceUpdateStateDataKernel::getVelocities(ContextImpl& context, std::vector<Vec3>& velocities) {
int numParticles = context.getSystem().getNumParticles(); int numParticles = context.getSystem().getNumParticles();
vector<RealVec>& velData = extractVelocities(context); vector<Vec3>& velData = extractVelocities(context);
velocities.resize(numParticles); velocities.resize(numParticles);
for (int i = 0; i < numParticles; ++i) for (int i = 0; i < numParticles; ++i)
velocities[i] = Vec3(velData[i][0], velData[i][1], velData[i][2]); velocities[i] = Vec3(velData[i][0], velData[i][1], velData[i][2]);
...@@ -265,17 +265,17 @@ void ReferenceUpdateStateDataKernel::getVelocities(ContextImpl& context, std::ve ...@@ -265,17 +265,17 @@ void ReferenceUpdateStateDataKernel::getVelocities(ContextImpl& context, std::ve
void ReferenceUpdateStateDataKernel::setVelocities(ContextImpl& context, const std::vector<Vec3>& velocities) { void ReferenceUpdateStateDataKernel::setVelocities(ContextImpl& context, const std::vector<Vec3>& velocities) {
int numParticles = context.getSystem().getNumParticles(); int numParticles = context.getSystem().getNumParticles();
vector<RealVec>& velData = extractVelocities(context); vector<Vec3>& velData = extractVelocities(context);
for (int i = 0; i < numParticles; ++i) { for (int i = 0; i < numParticles; ++i) {
velData[i][0] = (RealOpenMM) velocities[i][0]; velData[i][0] = velocities[i][0];
velData[i][1] = (RealOpenMM) velocities[i][1]; velData[i][1] = velocities[i][1];
velData[i][2] = (RealOpenMM) velocities[i][2]; velData[i][2] = velocities[i][2];
} }
} }
void ReferenceUpdateStateDataKernel::getForces(ContextImpl& context, std::vector<Vec3>& forces) { void ReferenceUpdateStateDataKernel::getForces(ContextImpl& context, std::vector<Vec3>& forces) {
int numParticles = context.getSystem().getNumParticles(); int numParticles = context.getSystem().getNumParticles();
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
forces.resize(numParticles); forces.resize(numParticles);
for (int i = 0; i < numParticles; ++i) for (int i = 0; i < numParticles; ++i)
forces[i] = Vec3(forceData[i][0], forceData[i][1], forceData[i][2]); forces[i] = Vec3(forceData[i][0], forceData[i][1], forceData[i][2]);
...@@ -286,18 +286,18 @@ void ReferenceUpdateStateDataKernel::getEnergyParameterDerivatives(ContextImpl& ...@@ -286,18 +286,18 @@ void ReferenceUpdateStateDataKernel::getEnergyParameterDerivatives(ContextImpl&
} }
void ReferenceUpdateStateDataKernel::getPeriodicBoxVectors(ContextImpl& context, Vec3& a, Vec3& b, Vec3& c) const { void ReferenceUpdateStateDataKernel::getPeriodicBoxVectors(ContextImpl& context, Vec3& a, Vec3& b, Vec3& c) const {
RealVec* vectors = extractBoxVectors(context); Vec3* vectors = extractBoxVectors(context);
a = vectors[0]; a = vectors[0];
b = vectors[1]; b = vectors[1];
c = vectors[2]; c = vectors[2];
} }
void ReferenceUpdateStateDataKernel::setPeriodicBoxVectors(ContextImpl& context, const Vec3& a, const Vec3& b, const Vec3& c) { void ReferenceUpdateStateDataKernel::setPeriodicBoxVectors(ContextImpl& context, const Vec3& a, const Vec3& b, const Vec3& c) {
RealVec& box = extractBoxSize(context); Vec3& box = extractBoxSize(context);
box[0] = (RealOpenMM) a[0]; box[0] = a[0];
box[1] = (RealOpenMM) b[1]; box[1] = b[1];
box[2] = (RealOpenMM) c[2]; box[2] = c[2];
RealVec* vectors = extractBoxVectors(context); Vec3* vectors = extractBoxVectors(context);
vectors[0] = a; vectors[0] = a;
vectors[1] = b; vectors[1] = b;
vectors[2] = c; vectors[2] = c;
...@@ -307,12 +307,12 @@ void ReferenceUpdateStateDataKernel::createCheckpoint(ContextImpl& context, ostr ...@@ -307,12 +307,12 @@ void ReferenceUpdateStateDataKernel::createCheckpoint(ContextImpl& context, ostr
int version = 2; int version = 2;
stream.write((char*) &version, sizeof(int)); stream.write((char*) &version, sizeof(int));
stream.write((char*) &data.time, sizeof(data.time)); stream.write((char*) &data.time, sizeof(data.time));
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
stream.write((char*) &posData[0], sizeof(RealVec)*posData.size()); stream.write((char*) &posData[0], sizeof(Vec3)*posData.size());
vector<RealVec>& velData = extractVelocities(context); vector<Vec3>& velData = extractVelocities(context);
stream.write((char*) &velData[0], sizeof(RealVec)*velData.size()); stream.write((char*) &velData[0], sizeof(Vec3)*velData.size());
RealVec* vectors = extractBoxVectors(context); Vec3* vectors = extractBoxVectors(context);
stream.write((char*) vectors, 3*sizeof(RealVec)); stream.write((char*) vectors, 3*sizeof(Vec3));
SimTKOpenMMUtilities::createCheckpoint(stream); SimTKOpenMMUtilities::createCheckpoint(stream);
} }
...@@ -322,12 +322,12 @@ void ReferenceUpdateStateDataKernel::loadCheckpoint(ContextImpl& context, istrea ...@@ -322,12 +322,12 @@ void ReferenceUpdateStateDataKernel::loadCheckpoint(ContextImpl& context, istrea
if (version != 2) if (version != 2)
throw OpenMMException("Checkpoint was created with a different version of OpenMM"); throw OpenMMException("Checkpoint was created with a different version of OpenMM");
stream.read((char*) &data.time, sizeof(data.time)); stream.read((char*) &data.time, sizeof(data.time));
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
stream.read((char*) &posData[0], sizeof(RealVec)*posData.size()); stream.read((char*) &posData[0], sizeof(Vec3)*posData.size());
vector<RealVec>& velData = extractVelocities(context); vector<Vec3>& velData = extractVelocities(context);
stream.read((char*) &velData[0], sizeof(RealVec)*velData.size()); stream.read((char*) &velData[0], sizeof(Vec3)*velData.size());
RealVec* vectors = extractBoxVectors(context); Vec3* vectors = extractBoxVectors(context);
stream.read((char*) vectors, 3*sizeof(RealVec)); stream.read((char*) vectors, 3*sizeof(Vec3));
SimTKOpenMMUtilities::loadCheckpoint(stream); SimTKOpenMMUtilities::loadCheckpoint(stream);
} }
...@@ -336,7 +336,7 @@ void ReferenceApplyConstraintsKernel::initialize(const System& system) { ...@@ -336,7 +336,7 @@ void ReferenceApplyConstraintsKernel::initialize(const System& system) {
masses.resize(numParticles); masses.resize(numParticles);
inverseMasses.resize(numParticles); inverseMasses.resize(numParticles);
for (int i = 0; i < numParticles; ++i) { for (int i = 0; i < numParticles; ++i) {
masses[i] = static_cast<RealOpenMM>(system.getParticleMass(i)); masses[i] = system.getParticleMass(i);
inverseMasses[i] = 1.0/masses[i]; inverseMasses[i] = 1.0/masses[i];
} }
} }
...@@ -345,14 +345,14 @@ ReferenceApplyConstraintsKernel::~ReferenceApplyConstraintsKernel() { ...@@ -345,14 +345,14 @@ ReferenceApplyConstraintsKernel::~ReferenceApplyConstraintsKernel() {
} }
void ReferenceApplyConstraintsKernel::apply(ContextImpl& context, double tol) { void ReferenceApplyConstraintsKernel::apply(ContextImpl& context, double tol) {
vector<RealVec>& positions = extractPositions(context); vector<Vec3>& positions = extractPositions(context);
extractConstraints(context).apply(positions, positions, inverseMasses, tol); extractConstraints(context).apply(positions, positions, inverseMasses, tol);
ReferenceVirtualSites::computePositions(context.getSystem(), positions); ReferenceVirtualSites::computePositions(context.getSystem(), positions);
} }
void ReferenceApplyConstraintsKernel::applyToVelocities(ContextImpl& context, double tol) { void ReferenceApplyConstraintsKernel::applyToVelocities(ContextImpl& context, double tol) {
vector<RealVec>& positions = extractPositions(context); vector<Vec3>& positions = extractPositions(context);
vector<RealVec>& velocities = extractVelocities(context); vector<Vec3>& velocities = extractVelocities(context);
extractConstraints(context).applyToVelocities(positions, velocities, inverseMasses, tol); extractConstraints(context).applyToVelocities(positions, velocities, inverseMasses, tol);
} }
...@@ -360,7 +360,7 @@ void ReferenceVirtualSitesKernel::initialize(const System& system) { ...@@ -360,7 +360,7 @@ void ReferenceVirtualSitesKernel::initialize(const System& system) {
} }
void ReferenceVirtualSitesKernel::computePositions(ContextImpl& context) { void ReferenceVirtualSitesKernel::computePositions(ContextImpl& context) {
vector<RealVec>& positions = extractPositions(context); vector<Vec3>& positions = extractPositions(context);
ReferenceVirtualSites::computePositions(context.getSystem(), positions); ReferenceVirtualSites::computePositions(context.getSystem(), positions);
} }
...@@ -379,16 +379,16 @@ void ReferenceCalcHarmonicBondForceKernel::initialize(const System& system, cons ...@@ -379,16 +379,16 @@ void ReferenceCalcHarmonicBondForceKernel::initialize(const System& system, cons
force.getBondParameters(i, particle1, particle2, length, k); force.getBondParameters(i, particle1, particle2, length, k);
bondIndexArray[i][0] = particle1; bondIndexArray[i][0] = particle1;
bondIndexArray[i][1] = particle2; bondIndexArray[i][1] = particle2;
bondParamArray[i][0] = (RealOpenMM) length; bondParamArray[i][0] = length;
bondParamArray[i][1] = (RealOpenMM) k; bondParamArray[i][1] = k;
} }
usePeriodic = force.usesPeriodicBoundaryConditions(); usePeriodic = force.usesPeriodicBoundaryConditions();
} }
double ReferenceCalcHarmonicBondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcHarmonicBondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
RealOpenMM energy = 0; double energy = 0;
ReferenceBondForce refBondForce; ReferenceBondForce refBondForce;
ReferenceHarmonicBondIxn harmonicBond; ReferenceHarmonicBondIxn harmonicBond;
if (usePeriodic) if (usePeriodic)
...@@ -411,8 +411,8 @@ void ReferenceCalcHarmonicBondForceKernel::copyParametersToContext(ContextImpl& ...@@ -411,8 +411,8 @@ void ReferenceCalcHarmonicBondForceKernel::copyParametersToContext(ContextImpl&
throw OpenMMException("updateParametersInContext: The set of particles in a bond has changed"); throw OpenMMException("updateParametersInContext: The set of particles in a bond has changed");
bondIndexArray[i][0] = particle1; bondIndexArray[i][0] = particle1;
bondIndexArray[i][1] = particle2; bondIndexArray[i][1] = particle2;
bondParamArray[i][0] = (RealOpenMM) length; bondParamArray[i][0] = length;
bondParamArray[i][1] = (RealOpenMM) k; bondParamArray[i][1] = k;
} }
} }
...@@ -437,7 +437,7 @@ void ReferenceCalcCustomBondForceKernel::initialize(const System& system, const ...@@ -437,7 +437,7 @@ void ReferenceCalcCustomBondForceKernel::initialize(const System& system, const
bondIndexArray[i][0] = particle1; bondIndexArray[i][0] = particle1;
bondIndexArray[i][1] = particle2; bondIndexArray[i][1] = particle2;
for (int j = 0; j < numParameters; j++) for (int j = 0; j < numParameters; j++)
bondParamArray[i][j] = (RealOpenMM) params[j]; bondParamArray[i][j] = params[j];
} }
// Parse the expression used to calculate the force. // Parse the expression used to calculate the force.
...@@ -462,9 +462,9 @@ void ReferenceCalcCustomBondForceKernel::initialize(const System& system, const ...@@ -462,9 +462,9 @@ void ReferenceCalcCustomBondForceKernel::initialize(const System& system, const
} }
double ReferenceCalcCustomBondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcCustomBondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
RealOpenMM energy = 0; double energy = 0;
map<string, double> globalParameters; map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++) for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]); globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
...@@ -494,7 +494,7 @@ void ReferenceCalcCustomBondForceKernel::copyParametersToContext(ContextImpl& co ...@@ -494,7 +494,7 @@ void ReferenceCalcCustomBondForceKernel::copyParametersToContext(ContextImpl& co
if (particle1 != bondIndexArray[i][0] || particle2 != bondIndexArray[i][1]) if (particle1 != bondIndexArray[i][0] || particle2 != bondIndexArray[i][1])
throw OpenMMException("updateParametersInContext: The set of particles in a bond has changed"); throw OpenMMException("updateParametersInContext: The set of particles in a bond has changed");
for (int j = 0; j < numParameters; j++) for (int j = 0; j < numParameters; j++)
bondParamArray[i][j] = (RealOpenMM) params[j]; bondParamArray[i][j] = params[j];
} }
} }
...@@ -514,16 +514,16 @@ void ReferenceCalcHarmonicAngleForceKernel::initialize(const System& system, con ...@@ -514,16 +514,16 @@ void ReferenceCalcHarmonicAngleForceKernel::initialize(const System& system, con
angleIndexArray[i][0] = particle1; angleIndexArray[i][0] = particle1;
angleIndexArray[i][1] = particle2; angleIndexArray[i][1] = particle2;
angleIndexArray[i][2] = particle3; angleIndexArray[i][2] = particle3;
angleParamArray[i][0] = (RealOpenMM) angle; angleParamArray[i][0] = angle;
angleParamArray[i][1] = (RealOpenMM) k; angleParamArray[i][1] = k;
} }
usePeriodic = force.usesPeriodicBoundaryConditions(); usePeriodic = force.usesPeriodicBoundaryConditions();
} }
double ReferenceCalcHarmonicAngleForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcHarmonicAngleForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
RealOpenMM energy = 0; double energy = 0;
ReferenceBondForce refBondForce; ReferenceBondForce refBondForce;
ReferenceAngleBondIxn angleBond; ReferenceAngleBondIxn angleBond;
if (usePeriodic) if (usePeriodic)
...@@ -544,8 +544,8 @@ void ReferenceCalcHarmonicAngleForceKernel::copyParametersToContext(ContextImpl& ...@@ -544,8 +544,8 @@ void ReferenceCalcHarmonicAngleForceKernel::copyParametersToContext(ContextImpl&
force.getAngleParameters(i, particle1, particle2, particle3, angle, k); force.getAngleParameters(i, particle1, particle2, particle3, angle, k);
if (particle1 != angleIndexArray[i][0] || particle2 != angleIndexArray[i][1] || particle3 != angleIndexArray[i][2]) if (particle1 != angleIndexArray[i][0] || particle2 != angleIndexArray[i][1] || particle3 != angleIndexArray[i][2])
throw OpenMMException("updateParametersInContext: The set of particles in an angle has changed"); throw OpenMMException("updateParametersInContext: The set of particles in an angle has changed");
angleParamArray[i][0] = (RealOpenMM) angle; angleParamArray[i][0] = angle;
angleParamArray[i][1] = (RealOpenMM) k; angleParamArray[i][1] = k;
} }
} }
...@@ -571,7 +571,7 @@ void ReferenceCalcCustomAngleForceKernel::initialize(const System& system, const ...@@ -571,7 +571,7 @@ void ReferenceCalcCustomAngleForceKernel::initialize(const System& system, const
angleIndexArray[i][1] = particle2; angleIndexArray[i][1] = particle2;
angleIndexArray[i][2] = particle3; angleIndexArray[i][2] = particle3;
for (int j = 0; j < numParameters; j++) for (int j = 0; j < numParameters; j++)
angleParamArray[i][j] = (RealOpenMM) params[j]; angleParamArray[i][j] = params[j];
} }
// Parse the expression used to calculate the force. // Parse the expression used to calculate the force.
...@@ -596,9 +596,9 @@ void ReferenceCalcCustomAngleForceKernel::initialize(const System& system, const ...@@ -596,9 +596,9 @@ void ReferenceCalcCustomAngleForceKernel::initialize(const System& system, const
} }
double ReferenceCalcCustomAngleForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcCustomAngleForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
RealOpenMM energy = 0; double energy = 0;
map<string, double> globalParameters; map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++) for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]); globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
...@@ -628,7 +628,7 @@ void ReferenceCalcCustomAngleForceKernel::copyParametersToContext(ContextImpl& c ...@@ -628,7 +628,7 @@ void ReferenceCalcCustomAngleForceKernel::copyParametersToContext(ContextImpl& c
if (particle1 != angleIndexArray[i][0] || particle2 != angleIndexArray[i][1] || particle3 != angleIndexArray[i][2]) if (particle1 != angleIndexArray[i][0] || particle2 != angleIndexArray[i][1] || particle3 != angleIndexArray[i][2])
throw OpenMMException("updateParametersInContext: The set of particles in an angle has changed"); throw OpenMMException("updateParametersInContext: The set of particles in an angle has changed");
for (int j = 0; j < numParameters; j++) for (int j = 0; j < numParameters; j++)
angleParamArray[i][j] = (RealOpenMM) params[j]; angleParamArray[i][j] = params[j];
} }
} }
...@@ -649,17 +649,17 @@ void ReferenceCalcPeriodicTorsionForceKernel::initialize(const System& system, c ...@@ -649,17 +649,17 @@ void ReferenceCalcPeriodicTorsionForceKernel::initialize(const System& system, c
torsionIndexArray[i][1] = particle2; torsionIndexArray[i][1] = particle2;
torsionIndexArray[i][2] = particle3; torsionIndexArray[i][2] = particle3;
torsionIndexArray[i][3] = particle4; torsionIndexArray[i][3] = particle4;
torsionParamArray[i][0] = (RealOpenMM) k; torsionParamArray[i][0] = k;
torsionParamArray[i][1] = (RealOpenMM) phase; torsionParamArray[i][1] = phase;
torsionParamArray[i][2] = (RealOpenMM) periodicity; torsionParamArray[i][2] = periodicity;
} }
usePeriodic = force.usesPeriodicBoundaryConditions(); usePeriodic = force.usesPeriodicBoundaryConditions();
} }
double ReferenceCalcPeriodicTorsionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcPeriodicTorsionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
RealOpenMM energy = 0; double energy = 0;
ReferenceBondForce refBondForce; ReferenceBondForce refBondForce;
ReferenceProperDihedralBond periodicTorsionBond; ReferenceProperDihedralBond periodicTorsionBond;
if (usePeriodic) if (usePeriodic)
...@@ -680,9 +680,9 @@ void ReferenceCalcPeriodicTorsionForceKernel::copyParametersToContext(ContextImp ...@@ -680,9 +680,9 @@ void ReferenceCalcPeriodicTorsionForceKernel::copyParametersToContext(ContextImp
force.getTorsionParameters(i, particle1, particle2, particle3, particle4, periodicity, phase, k); force.getTorsionParameters(i, particle1, particle2, particle3, particle4, periodicity, phase, k);
if (particle1 != torsionIndexArray[i][0] || particle2 != torsionIndexArray[i][1] || particle3 != torsionIndexArray[i][2] || particle4 != torsionIndexArray[i][3]) if (particle1 != torsionIndexArray[i][0] || particle2 != torsionIndexArray[i][1] || particle3 != torsionIndexArray[i][2] || particle4 != torsionIndexArray[i][3])
throw OpenMMException("updateParametersInContext: The set of particles in a torsion has changed"); throw OpenMMException("updateParametersInContext: The set of particles in a torsion has changed");
torsionParamArray[i][0] = (RealOpenMM) k; torsionParamArray[i][0] = k;
torsionParamArray[i][1] = (RealOpenMM) phase; torsionParamArray[i][1] = phase;
torsionParamArray[i][2] = (RealOpenMM) periodicity; torsionParamArray[i][2] = periodicity;
} }
} }
...@@ -703,20 +703,20 @@ void ReferenceCalcRBTorsionForceKernel::initialize(const System& system, const R ...@@ -703,20 +703,20 @@ void ReferenceCalcRBTorsionForceKernel::initialize(const System& system, const R
torsionIndexArray[i][1] = particle2; torsionIndexArray[i][1] = particle2;
torsionIndexArray[i][2] = particle3; torsionIndexArray[i][2] = particle3;
torsionIndexArray[i][3] = particle4; torsionIndexArray[i][3] = particle4;
torsionParamArray[i][0] = (RealOpenMM) c0; torsionParamArray[i][0] = c0;
torsionParamArray[i][1] = (RealOpenMM) c1; torsionParamArray[i][1] = c1;
torsionParamArray[i][2] = (RealOpenMM) c2; torsionParamArray[i][2] = c2;
torsionParamArray[i][3] = (RealOpenMM) c3; torsionParamArray[i][3] = c3;
torsionParamArray[i][4] = (RealOpenMM) c4; torsionParamArray[i][4] = c4;
torsionParamArray[i][5] = (RealOpenMM) c5; torsionParamArray[i][5] = c5;
} }
usePeriodic = force.usesPeriodicBoundaryConditions(); usePeriodic = force.usesPeriodicBoundaryConditions();
} }
double ReferenceCalcRBTorsionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcRBTorsionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
RealOpenMM energy = 0; double energy = 0;
ReferenceBondForce refBondForce; ReferenceBondForce refBondForce;
ReferenceRbDihedralBond rbTorsionBond; ReferenceRbDihedralBond rbTorsionBond;
if (usePeriodic) if (usePeriodic)
...@@ -737,12 +737,12 @@ void ReferenceCalcRBTorsionForceKernel::copyParametersToContext(ContextImpl& con ...@@ -737,12 +737,12 @@ void ReferenceCalcRBTorsionForceKernel::copyParametersToContext(ContextImpl& con
force.getTorsionParameters(i, particle1, particle2, particle3, particle4, c0, c1, c2, c3, c4, c5); force.getTorsionParameters(i, particle1, particle2, particle3, particle4, c0, c1, c2, c3, c4, c5);
if (particle1 != torsionIndexArray[i][0] || particle2 != torsionIndexArray[i][1] || particle3 != torsionIndexArray[i][2] || particle4 != torsionIndexArray[i][3]) if (particle1 != torsionIndexArray[i][0] || particle2 != torsionIndexArray[i][1] || particle3 != torsionIndexArray[i][2] || particle4 != torsionIndexArray[i][3])
throw OpenMMException("updateParametersInContext: The set of particles in a torsion has changed"); throw OpenMMException("updateParametersInContext: The set of particles in a torsion has changed");
torsionParamArray[i][0] = (RealOpenMM) c0; torsionParamArray[i][0] = c0;
torsionParamArray[i][1] = (RealOpenMM) c1; torsionParamArray[i][1] = c1;
torsionParamArray[i][2] = (RealOpenMM) c2; torsionParamArray[i][2] = c2;
torsionParamArray[i][3] = (RealOpenMM) c3; torsionParamArray[i][3] = c3;
torsionParamArray[i][4] = (RealOpenMM) c4; torsionParamArray[i][4] = c4;
torsionParamArray[i][5] = (RealOpenMM) c5; torsionParamArray[i][5] = c5;
} }
} }
...@@ -774,9 +774,9 @@ void ReferenceCalcCMAPTorsionForceKernel::initialize(const System& system, const ...@@ -774,9 +774,9 @@ void ReferenceCalcCMAPTorsionForceKernel::initialize(const System& system, const
} }
double ReferenceCalcCMAPTorsionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcCMAPTorsionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
RealOpenMM totalEnergy = 0; double totalEnergy = 0;
ReferenceCMAPTorsionIxn torsion(coeff, torsionMaps, torsionIndices); ReferenceCMAPTorsionIxn torsion(coeff, torsionMaps, torsionIndices);
if (usePeriodic) if (usePeriodic)
torsion.setPeriodic(extractBoxVectors(context)); torsion.setPeriodic(extractBoxVectors(context));
...@@ -841,7 +841,7 @@ void ReferenceCalcCustomTorsionForceKernel::initialize(const System& system, con ...@@ -841,7 +841,7 @@ void ReferenceCalcCustomTorsionForceKernel::initialize(const System& system, con
torsionIndexArray[i][2] = particle3; torsionIndexArray[i][2] = particle3;
torsionIndexArray[i][3] = particle4; torsionIndexArray[i][3] = particle4;
for (int j = 0; j < numParameters; j++) for (int j = 0; j < numParameters; j++)
torsionParamArray[i][j] = (RealOpenMM) params[j]; torsionParamArray[i][j] = params[j];
} }
// Parse the expression used to calculate the force. // Parse the expression used to calculate the force.
...@@ -866,9 +866,9 @@ void ReferenceCalcCustomTorsionForceKernel::initialize(const System& system, con ...@@ -866,9 +866,9 @@ void ReferenceCalcCustomTorsionForceKernel::initialize(const System& system, con
} }
double ReferenceCalcCustomTorsionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcCustomTorsionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
RealOpenMM energy = 0; double energy = 0;
map<string, double> globalParameters; map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++) for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]); globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
...@@ -898,7 +898,7 @@ void ReferenceCalcCustomTorsionForceKernel::copyParametersToContext(ContextImpl& ...@@ -898,7 +898,7 @@ void ReferenceCalcCustomTorsionForceKernel::copyParametersToContext(ContextImpl&
if (particle1 != torsionIndexArray[i][0] || particle2 != torsionIndexArray[i][1] || particle3 != torsionIndexArray[i][2] || particle4 != torsionIndexArray[i][3]) if (particle1 != torsionIndexArray[i][0] || particle2 != torsionIndexArray[i][1] || particle3 != torsionIndexArray[i][2] || particle4 != torsionIndexArray[i][3])
throw OpenMMException("updateParametersInContext: The set of particles in a torsion has changed"); throw OpenMMException("updateParametersInContext: The set of particles in a torsion has changed");
for (int j = 0; j < numParameters; j++) for (int j = 0; j < numParameters; j++)
torsionParamArray[i][j] = (RealOpenMM) params[j]; torsionParamArray[i][j] = params[j];
} }
} }
...@@ -936,9 +936,9 @@ void ReferenceCalcNonbondedForceKernel::initialize(const System& system, const N ...@@ -936,9 +936,9 @@ void ReferenceCalcNonbondedForceKernel::initialize(const System& system, const N
for (int i = 0; i < numParticles; ++i) { for (int i = 0; i < numParticles; ++i) {
double charge, radius, depth; double charge, radius, depth;
force.getParticleParameters(i, charge, radius, depth); force.getParticleParameters(i, charge, radius, depth);
particleParamArray[i][0] = static_cast<RealOpenMM>(0.5*radius); particleParamArray[i][0] = 0.5*radius;
particleParamArray[i][1] = static_cast<RealOpenMM>(2.0*sqrt(depth)); particleParamArray[i][1] = 2.0*sqrt(depth);
particleParamArray[i][2] = static_cast<RealOpenMM>(charge); particleParamArray[i][2] = charge;
} }
this->exclusions = exclusions; this->exclusions = exclusions;
for (int i = 0; i < num14; ++i) { for (int i = 0; i < num14; ++i) {
...@@ -947,12 +947,12 @@ void ReferenceCalcNonbondedForceKernel::initialize(const System& system, const N ...@@ -947,12 +947,12 @@ void ReferenceCalcNonbondedForceKernel::initialize(const System& system, const N
force.getExceptionParameters(nb14s[i], particle1, particle2, charge, radius, depth); force.getExceptionParameters(nb14s[i], particle1, particle2, charge, radius, depth);
bonded14IndexArray[i][0] = particle1; bonded14IndexArray[i][0] = particle1;
bonded14IndexArray[i][1] = particle2; bonded14IndexArray[i][1] = particle2;
bonded14ParamArray[i][0] = static_cast<RealOpenMM>(radius); bonded14ParamArray[i][0] = radius;
bonded14ParamArray[i][1] = static_cast<RealOpenMM>(4.0*depth); bonded14ParamArray[i][1] = 4.0*depth;
bonded14ParamArray[i][2] = static_cast<RealOpenMM>(charge); bonded14ParamArray[i][2] = charge;
} }
nonbondedMethod = CalcNonbondedForceKernel::NonbondedMethod(force.getNonbondedMethod()); nonbondedMethod = CalcNonbondedForceKernel::NonbondedMethod(force.getNonbondedMethod());
nonbondedCutoff = (RealOpenMM) force.getCutoffDistance(); nonbondedCutoff = force.getCutoffDistance();
if (nonbondedMethod == NoCutoff) { if (nonbondedMethod == NoCutoff) {
neighborList = NULL; neighborList = NULL;
useSwitchingFunction = false; useSwitchingFunction = false;
...@@ -965,22 +965,22 @@ void ReferenceCalcNonbondedForceKernel::initialize(const System& system, const N ...@@ -965,22 +965,22 @@ void ReferenceCalcNonbondedForceKernel::initialize(const System& system, const N
if (nonbondedMethod == Ewald) { if (nonbondedMethod == Ewald) {
double alpha; double alpha;
NonbondedForceImpl::calcEwaldParameters(system, force, alpha, kmax[0], kmax[1], kmax[2]); NonbondedForceImpl::calcEwaldParameters(system, force, alpha, kmax[0], kmax[1], kmax[2]);
ewaldAlpha = (RealOpenMM) alpha; ewaldAlpha = alpha;
} }
else if (nonbondedMethod == PME) { else if (nonbondedMethod == PME) {
double alpha; double alpha;
NonbondedForceImpl::calcPMEParameters(system, force, alpha, gridSize[0], gridSize[1], gridSize[2], false); NonbondedForceImpl::calcPMEParameters(system, force, alpha, gridSize[0], gridSize[1], gridSize[2], false);
ewaldAlpha = (RealOpenMM) alpha; ewaldAlpha = alpha;
} }
else if (nonbondedMethod == LJPME) { else if (nonbondedMethod == LJPME) {
double alpha; double alpha;
NonbondedForceImpl::calcPMEParameters(system, force, alpha, gridSize[0], gridSize[1], gridSize[2], false); NonbondedForceImpl::calcPMEParameters(system, force, alpha, gridSize[0], gridSize[1], gridSize[2], false);
ewaldAlpha = (RealOpenMM) alpha; ewaldAlpha = alpha;
NonbondedForceImpl::calcPMEParameters(system, force, alpha, dispersionGridSize[0], dispersionGridSize[1], dispersionGridSize[2], true); NonbondedForceImpl::calcPMEParameters(system, force, alpha, dispersionGridSize[0], dispersionGridSize[1], dispersionGridSize[2], true);
ewaldDispersionAlpha = (RealOpenMM) alpha; ewaldDispersionAlpha = alpha;
useSwitchingFunction = false; useSwitchingFunction = false;
} }
rfDielectric = (RealOpenMM)force.getReactionFieldDielectric(); rfDielectric = force.getReactionFieldDielectric();
if (force.getUseDispersionCorrection()) if (force.getUseDispersionCorrection())
dispersionCoefficient = NonbondedForceImpl::calcDispersionCorrection(system, force); dispersionCoefficient = NonbondedForceImpl::calcDispersionCorrection(system, force);
else else
...@@ -988,9 +988,9 @@ void ReferenceCalcNonbondedForceKernel::initialize(const System& system, const N ...@@ -988,9 +988,9 @@ void ReferenceCalcNonbondedForceKernel::initialize(const System& system, const N
} }
double ReferenceCalcNonbondedForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy, bool includeDirect, bool includeReciprocal) { double ReferenceCalcNonbondedForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy, bool includeDirect, bool includeReciprocal) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
RealOpenMM energy = 0; double energy = 0;
ReferenceLJCoulombIxn clj; ReferenceLJCoulombIxn clj;
bool periodic = (nonbondedMethod == CutoffPeriodic); bool periodic = (nonbondedMethod == CutoffPeriodic);
bool ewald = (nonbondedMethod == Ewald); bool ewald = (nonbondedMethod == Ewald);
...@@ -1001,7 +1001,7 @@ double ReferenceCalcNonbondedForceKernel::execute(ContextImpl& context, bool inc ...@@ -1001,7 +1001,7 @@ double ReferenceCalcNonbondedForceKernel::execute(ContextImpl& context, bool inc
clj.setUseCutoff(nonbondedCutoff, *neighborList, rfDielectric); clj.setUseCutoff(nonbondedCutoff, *neighborList, rfDielectric);
} }
if (periodic || ewald || pme || ljpme) { if (periodic || ewald || pme || ljpme) {
RealVec* boxVectors = extractBoxVectors(context); Vec3* boxVectors = extractBoxVectors(context);
double minAllowedSize = 1.999999*nonbondedCutoff; double minAllowedSize = 1.999999*nonbondedCutoff;
if (boxVectors[0][0] < minAllowedSize || boxVectors[1][1] < minAllowedSize || boxVectors[2][2] < minAllowedSize) if (boxVectors[0][0] < minAllowedSize || boxVectors[1][1] < minAllowedSize || boxVectors[2][2] < minAllowedSize)
throw OpenMMException("The periodic box size has decreased to less than twice the nonbonded cutoff."); throw OpenMMException("The periodic box size has decreased to less than twice the nonbonded cutoff.");
...@@ -1023,7 +1023,7 @@ double ReferenceCalcNonbondedForceKernel::execute(ContextImpl& context, bool inc ...@@ -1023,7 +1023,7 @@ double ReferenceCalcNonbondedForceKernel::execute(ContextImpl& context, bool inc
ReferenceLJCoulomb14 nonbonded14; ReferenceLJCoulomb14 nonbonded14;
refBondForce.calculateForce(num14, bonded14IndexArray, posData, bonded14ParamArray, forceData, includeEnergy ? &energy : NULL, nonbonded14); refBondForce.calculateForce(num14, bonded14IndexArray, posData, bonded14ParamArray, forceData, includeEnergy ? &energy : NULL, nonbonded14);
if (periodic || ewald || pme) { if (periodic || ewald || pme) {
RealVec* boxVectors = extractBoxVectors(context); Vec3* boxVectors = extractBoxVectors(context);
energy += dispersionCoefficient/(boxVectors[0][0]*boxVectors[1][1]*boxVectors[2][2]); energy += dispersionCoefficient/(boxVectors[0][0]*boxVectors[1][1]*boxVectors[2][2]);
} }
} }
...@@ -1049,9 +1049,9 @@ void ReferenceCalcNonbondedForceKernel::copyParametersToContext(ContextImpl& con ...@@ -1049,9 +1049,9 @@ void ReferenceCalcNonbondedForceKernel::copyParametersToContext(ContextImpl& con
for (int i = 0; i < numParticles; ++i) { for (int i = 0; i < numParticles; ++i) {
double charge, radius, depth; double charge, radius, depth;
force.getParticleParameters(i, charge, radius, depth); force.getParticleParameters(i, charge, radius, depth);
particleParamArray[i][0] = static_cast<RealOpenMM>(0.5*radius); particleParamArray[i][0] = 0.5*radius;
particleParamArray[i][1] = static_cast<RealOpenMM>(2.0*sqrt(depth)); particleParamArray[i][1] = 2.0*sqrt(depth);
particleParamArray[i][2] = static_cast<RealOpenMM>(charge); particleParamArray[i][2] = charge;
} }
for (int i = 0; i < num14; ++i) { for (int i = 0; i < num14; ++i) {
int particle1, particle2; int particle1, particle2;
...@@ -1059,9 +1059,9 @@ void ReferenceCalcNonbondedForceKernel::copyParametersToContext(ContextImpl& con ...@@ -1059,9 +1059,9 @@ void ReferenceCalcNonbondedForceKernel::copyParametersToContext(ContextImpl& con
force.getExceptionParameters(nb14s[i], particle1, particle2, charge, radius, depth); force.getExceptionParameters(nb14s[i], particle1, particle2, charge, radius, depth);
bonded14IndexArray[i][0] = particle1; bonded14IndexArray[i][0] = particle1;
bonded14IndexArray[i][1] = particle2; bonded14IndexArray[i][1] = particle2;
bonded14ParamArray[i][0] = static_cast<RealOpenMM>(radius); bonded14ParamArray[i][0] = radius;
bonded14ParamArray[i][1] = static_cast<RealOpenMM>(4.0*depth); bonded14ParamArray[i][1] = 4.0*depth;
bonded14ParamArray[i][2] = static_cast<RealOpenMM>(charge); bonded14ParamArray[i][2] = charge;
} }
// Recompute the coefficient for the dispersion correction. // Recompute the coefficient for the dispersion correction.
...@@ -1118,10 +1118,10 @@ void ReferenceCalcCustomNonbondedForceKernel::initialize(const System& system, c ...@@ -1118,10 +1118,10 @@ void ReferenceCalcCustomNonbondedForceKernel::initialize(const System& system, c
vector<double> parameters; vector<double> parameters;
force.getParticleParameters(i, parameters); force.getParticleParameters(i, parameters);
for (int j = 0; j < numParameters; j++) for (int j = 0; j < numParameters; j++)
particleParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]); particleParamArray[i][j] = parameters[j];
} }
nonbondedMethod = CalcCustomNonbondedForceKernel::NonbondedMethod(force.getNonbondedMethod()); nonbondedMethod = CalcCustomNonbondedForceKernel::NonbondedMethod(force.getNonbondedMethod());
nonbondedCutoff = (RealOpenMM) force.getCutoffDistance(); nonbondedCutoff = force.getCutoffDistance();
if (nonbondedMethod == NoCutoff) { if (nonbondedMethod == NoCutoff) {
neighborList = NULL; neighborList = NULL;
useSwitchingFunction = false; useSwitchingFunction = false;
...@@ -1189,10 +1189,10 @@ void ReferenceCalcCustomNonbondedForceKernel::initialize(const System& system, c ...@@ -1189,10 +1189,10 @@ void ReferenceCalcCustomNonbondedForceKernel::initialize(const System& system, c
} }
double ReferenceCalcCustomNonbondedForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcCustomNonbondedForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
RealVec* boxVectors = extractBoxVectors(context); Vec3* boxVectors = extractBoxVectors(context);
RealOpenMM energy = 0; double energy = 0;
ReferenceCustomNonbondedIxn ixn(energyExpression, forceExpression, parameterNames, energyParamDerivExpressions); ReferenceCustomNonbondedIxn ixn(energyExpression, forceExpression, parameterNames, energyParamDerivExpressions);
bool periodic = (nonbondedMethod == CutoffPeriodic); bool periodic = (nonbondedMethod == CutoffPeriodic);
if (nonbondedMethod != NoCutoff) { if (nonbondedMethod != NoCutoff) {
...@@ -1247,7 +1247,7 @@ void ReferenceCalcCustomNonbondedForceKernel::copyParametersToContext(ContextImp ...@@ -1247,7 +1247,7 @@ void ReferenceCalcCustomNonbondedForceKernel::copyParametersToContext(ContextImp
vector<double> parameters; vector<double> parameters;
force.getParticleParameters(i, parameters); force.getParticleParameters(i, parameters);
for (int j = 0; j < numParameters; j++) for (int j = 0; j < numParameters; j++)
particleParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]); particleParamArray[i][j] = parameters[j];
} }
// If necessary, recompute the long range correction. // If necessary, recompute the long range correction.
...@@ -1269,31 +1269,31 @@ ReferenceCalcGBSAOBCForceKernel::~ReferenceCalcGBSAOBCForceKernel() { ...@@ -1269,31 +1269,31 @@ ReferenceCalcGBSAOBCForceKernel::~ReferenceCalcGBSAOBCForceKernel() {
void ReferenceCalcGBSAOBCForceKernel::initialize(const System& system, const GBSAOBCForce& force) { void ReferenceCalcGBSAOBCForceKernel::initialize(const System& system, const GBSAOBCForce& force) {
int numParticles = system.getNumParticles(); int numParticles = system.getNumParticles();
charges.resize(numParticles); charges.resize(numParticles);
vector<RealOpenMM> atomicRadii(numParticles); vector<double> atomicRadii(numParticles);
vector<RealOpenMM> scaleFactors(numParticles); vector<double> scaleFactors(numParticles);
for (int i = 0; i < numParticles; ++i) { for (int i = 0; i < numParticles; ++i) {
double charge, radius, scalingFactor; double charge, radius, scalingFactor;
force.getParticleParameters(i, charge, radius, scalingFactor); force.getParticleParameters(i, charge, radius, scalingFactor);
charges[i] = static_cast<RealOpenMM>(charge); charges[i] = charge;
atomicRadii[i] = static_cast<RealOpenMM>(radius); atomicRadii[i] = radius;
scaleFactors[i] = static_cast<RealOpenMM>(scalingFactor); scaleFactors[i] = scalingFactor;
} }
ObcParameters* obcParameters = new ObcParameters(numParticles, ObcParameters::ObcTypeII); ObcParameters* obcParameters = new ObcParameters(numParticles, ObcParameters::ObcTypeII);
obcParameters->setAtomicRadii(atomicRadii); obcParameters->setAtomicRadii(atomicRadii);
obcParameters->setScaledRadiusFactors(scaleFactors); obcParameters->setScaledRadiusFactors(scaleFactors);
obcParameters->setSolventDielectric(static_cast<RealOpenMM>(force.getSolventDielectric())); obcParameters->setSolventDielectric(force.getSolventDielectric());
obcParameters->setSoluteDielectric(static_cast<RealOpenMM>(force.getSoluteDielectric())); obcParameters->setSoluteDielectric(force.getSoluteDielectric());
obcParameters->setPi4Asolv(4*M_PI*force.getSurfaceAreaEnergy()); obcParameters->setPi4Asolv(4*M_PI*force.getSurfaceAreaEnergy());
if (force.getNonbondedMethod() != GBSAOBCForce::NoCutoff) if (force.getNonbondedMethod() != GBSAOBCForce::NoCutoff)
obcParameters->setUseCutoff(static_cast<RealOpenMM>(force.getCutoffDistance())); obcParameters->setUseCutoff(force.getCutoffDistance());
isPeriodic = (force.getNonbondedMethod() == GBSAOBCForce::CutoffPeriodic); isPeriodic = (force.getNonbondedMethod() == GBSAOBCForce::CutoffPeriodic);
obc = new ReferenceObc(obcParameters); obc = new ReferenceObc(obcParameters);
obc->setIncludeAceApproximation(true); obc->setIncludeAceApproximation(true);
} }
double ReferenceCalcGBSAOBCForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcGBSAOBCForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
if (isPeriodic) if (isPeriodic)
obc->getObcParameters()->setPeriodic(extractBoxVectors(context)); obc->getObcParameters()->setPeriodic(extractBoxVectors(context));
return obc->computeBornEnergyForces(posData, charges, forceData); return obc->computeBornEnergyForces(posData, charges, forceData);
...@@ -1307,14 +1307,14 @@ void ReferenceCalcGBSAOBCForceKernel::copyParametersToContext(ContextImpl& conte ...@@ -1307,14 +1307,14 @@ void ReferenceCalcGBSAOBCForceKernel::copyParametersToContext(ContextImpl& conte
// Record the values. // Record the values.
vector<RealOpenMM> atomicRadii(numParticles); vector<double> atomicRadii(numParticles);
vector<RealOpenMM> scaleFactors(numParticles); vector<double> scaleFactors(numParticles);
for (int i = 0; i < numParticles; ++i) { for (int i = 0; i < numParticles; ++i) {
double charge, radius, scalingFactor; double charge, radius, scalingFactor;
force.getParticleParameters(i, charge, radius, scalingFactor); force.getParticleParameters(i, charge, radius, scalingFactor);
charges[i] = (RealOpenMM) charge; charges[i] = charge;
atomicRadii[i] = (RealOpenMM) radius; atomicRadii[i] = radius;
scaleFactors[i] = (RealOpenMM) scalingFactor; scaleFactors[i] = scalingFactor;
} }
obcParameters->setAtomicRadii(atomicRadii); obcParameters->setAtomicRadii(atomicRadii);
obcParameters->setScaledRadiusFactors(scaleFactors); obcParameters->setScaledRadiusFactors(scaleFactors);
...@@ -1359,14 +1359,14 @@ void ReferenceCalcCustomGBForceKernel::initialize(const System& system, const Cu ...@@ -1359,14 +1359,14 @@ void ReferenceCalcCustomGBForceKernel::initialize(const System& system, const Cu
vector<double> parameters; vector<double> parameters;
force.getParticleParameters(i, parameters); force.getParticleParameters(i, parameters);
for (int j = 0; j < numPerParticleParameters; j++) for (int j = 0; j < numPerParticleParameters; j++)
particleParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]); particleParamArray[i][j] = parameters[j];
} }
for (int i = 0; i < numPerParticleParameters; i++) for (int i = 0; i < numPerParticleParameters; i++)
particleParameterNames.push_back(force.getPerParticleParameterName(i)); particleParameterNames.push_back(force.getPerParticleParameterName(i));
for (int i = 0; i < force.getNumGlobalParameters(); i++) for (int i = 0; i < force.getNumGlobalParameters(); i++)
globalParameterNames.push_back(force.getGlobalParameterName(i)); globalParameterNames.push_back(force.getGlobalParameterName(i));
nonbondedMethod = CalcCustomGBForceKernel::NonbondedMethod(force.getNonbondedMethod()); nonbondedMethod = CalcCustomGBForceKernel::NonbondedMethod(force.getNonbondedMethod());
nonbondedCutoff = (RealOpenMM) force.getCutoffDistance(); nonbondedCutoff = force.getCutoffDistance();
if (nonbondedMethod == NoCutoff) if (nonbondedMethod == NoCutoff)
neighborList = NULL; neighborList = NULL;
else else
...@@ -1464,9 +1464,9 @@ void ReferenceCalcCustomGBForceKernel::initialize(const System& system, const Cu ...@@ -1464,9 +1464,9 @@ void ReferenceCalcCustomGBForceKernel::initialize(const System& system, const Cu
} }
double ReferenceCalcCustomGBForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcCustomGBForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
RealOpenMM energy = 0; double energy = 0;
ReferenceCustomGBIxn ixn(valueExpressions, valueDerivExpressions, valueGradientExpressions, valueParamDerivExpressions, valueNames, valueTypes, ReferenceCustomGBIxn ixn(valueExpressions, valueDerivExpressions, valueGradientExpressions, valueParamDerivExpressions, valueNames, valueTypes,
energyExpressions, energyDerivExpressions, energyGradientExpressions, energyParamDerivExpressions, energyTypes, particleParameterNames); energyExpressions, energyDerivExpressions, energyGradientExpressions, energyParamDerivExpressions, energyTypes, particleParameterNames);
bool periodic = (nonbondedMethod == CutoffPeriodic); bool periodic = (nonbondedMethod == CutoffPeriodic);
...@@ -1499,11 +1499,11 @@ void ReferenceCalcCustomGBForceKernel::copyParametersToContext(ContextImpl& cont ...@@ -1499,11 +1499,11 @@ void ReferenceCalcCustomGBForceKernel::copyParametersToContext(ContextImpl& cont
vector<double> parameters; vector<double> parameters;
force.getParticleParameters(i, parameters); force.getParticleParameters(i, parameters);
for (int j = 0; j < numParameters; j++) for (int j = 0; j < numParameters; j++)
particleParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]); particleParamArray[i][j] = parameters[j];
} }
} }
ReferenceCalcCustomExternalForceKernel::PeriodicDistanceFunction::PeriodicDistanceFunction(RealVec** boxVectorHandle) : boxVectorHandle(boxVectorHandle) { ReferenceCalcCustomExternalForceKernel::PeriodicDistanceFunction::PeriodicDistanceFunction(Vec3** boxVectorHandle) : boxVectorHandle(boxVectorHandle) {
} }
int ReferenceCalcCustomExternalForceKernel::PeriodicDistanceFunction::getNumArguments() const { int ReferenceCalcCustomExternalForceKernel::PeriodicDistanceFunction::getNumArguments() const {
...@@ -1511,8 +1511,8 @@ int ReferenceCalcCustomExternalForceKernel::PeriodicDistanceFunction::getNumArgu ...@@ -1511,8 +1511,8 @@ int ReferenceCalcCustomExternalForceKernel::PeriodicDistanceFunction::getNumArgu
} }
double ReferenceCalcCustomExternalForceKernel::PeriodicDistanceFunction::evaluate(const double* arguments) const { double ReferenceCalcCustomExternalForceKernel::PeriodicDistanceFunction::evaluate(const double* arguments) const {
RealVec* boxVectors = *boxVectorHandle; Vec3* boxVectors = *boxVectorHandle;
RealVec delta = RealVec(arguments[0], arguments[1], arguments[2])-RealVec(arguments[3], arguments[4], arguments[5]); Vec3 delta = Vec3(arguments[0], arguments[1], arguments[2])-Vec3(arguments[3], arguments[4], arguments[5]);
delta -= boxVectors[2]*floor(delta[2]/boxVectors[2][2]+0.5); delta -= boxVectors[2]*floor(delta[2]/boxVectors[2][2]+0.5);
delta -= boxVectors[1]*floor(delta[1]/boxVectors[1][1]+0.5); delta -= boxVectors[1]*floor(delta[1]/boxVectors[1][1]+0.5);
delta -= boxVectors[0]*floor(delta[0]/boxVectors[0][0]+0.5); delta -= boxVectors[0]*floor(delta[0]/boxVectors[0][0]+0.5);
...@@ -1528,8 +1528,8 @@ double ReferenceCalcCustomExternalForceKernel::PeriodicDistanceFunction::evaluat ...@@ -1528,8 +1528,8 @@ double ReferenceCalcCustomExternalForceKernel::PeriodicDistanceFunction::evaluat
argIndex = i; argIndex = i;
} }
} }
RealVec* boxVectors = *boxVectorHandle; Vec3* boxVectors = *boxVectorHandle;
RealVec delta = RealVec(arguments[0], arguments[1], arguments[2])-RealVec(arguments[3], arguments[4], arguments[5]); Vec3 delta = Vec3(arguments[0], arguments[1], arguments[2])-Vec3(arguments[3], arguments[4], arguments[5]);
delta -= boxVectors[2]*floor(delta[2]/boxVectors[2][2]+0.5); delta -= boxVectors[2]*floor(delta[2]/boxVectors[2][2]+0.5);
delta -= boxVectors[1]*floor(delta[1]/boxVectors[1][1]+0.5); delta -= boxVectors[1]*floor(delta[1]/boxVectors[1][1]+0.5);
delta -= boxVectors[0]*floor(delta[0]/boxVectors[0][0]+0.5); delta -= boxVectors[0]*floor(delta[0]/boxVectors[0][0]+0.5);
...@@ -1561,7 +1561,7 @@ void ReferenceCalcCustomExternalForceKernel::initialize(const System& system, co ...@@ -1561,7 +1561,7 @@ void ReferenceCalcCustomExternalForceKernel::initialize(const System& system, co
for (int i = 0; i < numParticles; ++i) { for (int i = 0; i < numParticles; ++i) {
force.getParticleParameters(i, particles[i], params); force.getParticleParameters(i, particles[i], params);
for (int j = 0; j < numParameters; j++) for (int j = 0; j < numParameters; j++)
particleParamArray[i][j] = (RealOpenMM) params[j]; particleParamArray[i][j] = params[j];
} }
// Parse the expression used to calculate the force. // Parse the expression used to calculate the force.
...@@ -1588,10 +1588,10 @@ void ReferenceCalcCustomExternalForceKernel::initialize(const System& system, co ...@@ -1588,10 +1588,10 @@ void ReferenceCalcCustomExternalForceKernel::initialize(const System& system, co
} }
double ReferenceCalcCustomExternalForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcCustomExternalForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
boxVectors = extractBoxVectors(context); boxVectors = extractBoxVectors(context);
RealOpenMM energy = 0; double energy = 0;
map<string, double> globalParameters; map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++) for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]); globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
...@@ -1616,7 +1616,7 @@ void ReferenceCalcCustomExternalForceKernel::copyParametersToContext(ContextImpl ...@@ -1616,7 +1616,7 @@ void ReferenceCalcCustomExternalForceKernel::copyParametersToContext(ContextImpl
if (particle != particles[i]) if (particle != particles[i])
throw OpenMMException("updateParametersInContext: A particle index has changed"); throw OpenMMException("updateParametersInContext: A particle index has changed");
for (int j = 0; j < numParameters; j++) for (int j = 0; j < numParameters; j++)
particleParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]); particleParamArray[i][j] = parameters[j];
} }
} }
...@@ -1654,7 +1654,7 @@ void ReferenceCalcCustomHbondForceKernel::initialize(const System& system, const ...@@ -1654,7 +1654,7 @@ void ReferenceCalcCustomHbondForceKernel::initialize(const System& system, const
donorParticles[i].push_back(d2); donorParticles[i].push_back(d2);
donorParticles[i].push_back(d3); donorParticles[i].push_back(d3);
for (int j = 0; j < numDonorParameters; j++) for (int j = 0; j < numDonorParameters; j++)
donorParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]); donorParamArray[i][j] = parameters[j];
} }
vector<vector<int> > acceptorParticles(numAcceptors); vector<vector<int> > acceptorParticles(numAcceptors);
int numAcceptorParameters = force.getNumPerAcceptorParameters(); int numAcceptorParameters = force.getNumPerAcceptorParameters();
...@@ -1667,10 +1667,10 @@ void ReferenceCalcCustomHbondForceKernel::initialize(const System& system, const ...@@ -1667,10 +1667,10 @@ void ReferenceCalcCustomHbondForceKernel::initialize(const System& system, const
acceptorParticles[i].push_back(a2); acceptorParticles[i].push_back(a2);
acceptorParticles[i].push_back(a3); acceptorParticles[i].push_back(a3);
for (int j = 0; j < numAcceptorParameters; j++) for (int j = 0; j < numAcceptorParameters; j++)
acceptorParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]); acceptorParamArray[i][j] = parameters[j];
} }
NonbondedMethod nonbondedMethod = CalcCustomHbondForceKernel::NonbondedMethod(force.getNonbondedMethod()); NonbondedMethod nonbondedMethod = CalcCustomHbondForceKernel::NonbondedMethod(force.getNonbondedMethod());
nonbondedCutoff = (RealOpenMM) force.getCutoffDistance(); nonbondedCutoff = force.getCutoffDistance();
// Create custom functions for the tabulated functions. // Create custom functions for the tabulated functions.
...@@ -1704,11 +1704,11 @@ void ReferenceCalcCustomHbondForceKernel::initialize(const System& system, const ...@@ -1704,11 +1704,11 @@ void ReferenceCalcCustomHbondForceKernel::initialize(const System& system, const
} }
double ReferenceCalcCustomHbondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcCustomHbondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
if (isPeriodic) if (isPeriodic)
ixn->setPeriodic(extractBoxVectors(context)); ixn->setPeriodic(extractBoxVectors(context));
RealOpenMM energy = 0; double energy = 0;
map<string, double> globalParameters; map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++) for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]); globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
...@@ -1733,7 +1733,7 @@ void ReferenceCalcCustomHbondForceKernel::copyParametersToContext(ContextImpl& c ...@@ -1733,7 +1733,7 @@ void ReferenceCalcCustomHbondForceKernel::copyParametersToContext(ContextImpl& c
if (d1 != donorAtoms[i][0] || d2 != donorAtoms[i][1] || d3 != donorAtoms[i][2]) if (d1 != donorAtoms[i][0] || d2 != donorAtoms[i][1] || d3 != donorAtoms[i][2])
throw OpenMMException("updateParametersInContext: The set of particles in a donor group has changed"); throw OpenMMException("updateParametersInContext: The set of particles in a donor group has changed");
for (int j = 0; j < numDonorParameters; j++) for (int j = 0; j < numDonorParameters; j++)
donorParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]); donorParamArray[i][j] = parameters[j];
} }
int numAcceptorParameters = force.getNumPerAcceptorParameters(); int numAcceptorParameters = force.getNumPerAcceptorParameters();
const vector<vector<int> >& acceptorAtoms = ixn->getAcceptorAtoms(); const vector<vector<int> >& acceptorAtoms = ixn->getAcceptorAtoms();
...@@ -1743,7 +1743,7 @@ void ReferenceCalcCustomHbondForceKernel::copyParametersToContext(ContextImpl& c ...@@ -1743,7 +1743,7 @@ void ReferenceCalcCustomHbondForceKernel::copyParametersToContext(ContextImpl& c
if (a1 != acceptorAtoms[i][0] || a2 != acceptorAtoms[i][1] || a3 != acceptorAtoms[i][2]) if (a1 != acceptorAtoms[i][0] || a2 != acceptorAtoms[i][1] || a3 != acceptorAtoms[i][2])
throw OpenMMException("updateParametersInContext: The set of particles in an acceptor group has changed"); throw OpenMMException("updateParametersInContext: The set of particles in an acceptor group has changed");
for (int j = 0; j < numAcceptorParameters; j++) for (int j = 0; j < numAcceptorParameters; j++)
acceptorParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]); acceptorParamArray[i][j] = parameters[j];
} }
} }
...@@ -1773,7 +1773,7 @@ void ReferenceCalcCustomCentroidBondForceKernel::initialize(const System& system ...@@ -1773,7 +1773,7 @@ void ReferenceCalcCustomCentroidBondForceKernel::initialize(const System& system
vector<double> parameters; vector<double> parameters;
force.getBondParameters(i, bondGroups[i], parameters); force.getBondParameters(i, bondGroups[i], parameters);
for (int j = 0; j < numBondParameters; j++) for (int j = 0; j < numBondParameters; j++)
bondParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]); bondParamArray[i][j] = parameters[j];
} }
// Create custom functions for the tabulated functions. // Create custom functions for the tabulated functions.
...@@ -1808,9 +1808,9 @@ void ReferenceCalcCustomCentroidBondForceKernel::initialize(const System& system ...@@ -1808,9 +1808,9 @@ void ReferenceCalcCustomCentroidBondForceKernel::initialize(const System& system
} }
double ReferenceCalcCustomCentroidBondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcCustomCentroidBondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
RealOpenMM energy = 0; double energy = 0;
map<string, double> globalParameters; map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++) for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]); globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
...@@ -1840,7 +1840,7 @@ void ReferenceCalcCustomCentroidBondForceKernel::copyParametersToContext(Context ...@@ -1840,7 +1840,7 @@ void ReferenceCalcCustomCentroidBondForceKernel::copyParametersToContext(Context
if (groups[j] != bondGroups[i][j]) if (groups[j] != bondGroups[i][j])
throw OpenMMException("updateParametersInContext: The set of groups in a bond has changed"); throw OpenMMException("updateParametersInContext: The set of groups in a bond has changed");
for (int j = 0; j < numParameters; j++) for (int j = 0; j < numParameters; j++)
bondParamArray[i][j] = (RealOpenMM) params[j]; bondParamArray[i][j] = params[j];
} }
} }
...@@ -1863,7 +1863,7 @@ void ReferenceCalcCustomCompoundBondForceKernel::initialize(const System& system ...@@ -1863,7 +1863,7 @@ void ReferenceCalcCustomCompoundBondForceKernel::initialize(const System& system
vector<double> parameters; vector<double> parameters;
force.getBondParameters(i, bondParticles[i], parameters); force.getBondParameters(i, bondParticles[i], parameters);
for (int j = 0; j < numBondParameters; j++) for (int j = 0; j < numBondParameters; j++)
bondParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]); bondParamArray[i][j] = parameters[j];
} }
// Create custom functions for the tabulated functions. // Create custom functions for the tabulated functions.
...@@ -1898,9 +1898,9 @@ void ReferenceCalcCustomCompoundBondForceKernel::initialize(const System& system ...@@ -1898,9 +1898,9 @@ void ReferenceCalcCustomCompoundBondForceKernel::initialize(const System& system
} }
double ReferenceCalcCustomCompoundBondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcCustomCompoundBondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
RealOpenMM energy = 0; double energy = 0;
map<string, double> globalParameters; map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++) for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]); globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
...@@ -1930,7 +1930,7 @@ void ReferenceCalcCustomCompoundBondForceKernel::copyParametersToContext(Context ...@@ -1930,7 +1930,7 @@ void ReferenceCalcCustomCompoundBondForceKernel::copyParametersToContext(Context
if (particles[j] != bondAtoms[i][j]) if (particles[j] != bondAtoms[i][j])
throw OpenMMException("updateParametersInContext: The set of particles in a bond has changed"); throw OpenMMException("updateParametersInContext: The set of particles in a bond has changed");
for (int j = 0; j < numParameters; j++) for (int j = 0; j < numParameters; j++)
bondParamArray[i][j] = (RealOpenMM) params[j]; bondParamArray[i][j] = params[j];
} }
} }
...@@ -1962,14 +1962,14 @@ void ReferenceCalcCustomManyParticleForceKernel::initialize(const System& system ...@@ -1962,14 +1962,14 @@ void ReferenceCalcCustomManyParticleForceKernel::initialize(const System& system
} }
double ReferenceCalcCustomManyParticleForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) { double ReferenceCalcCustomManyParticleForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
RealOpenMM energy = 0; double energy = 0;
map<string, double> globalParameters; map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++) for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]); globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
if (nonbondedMethod == CutoffPeriodic) { if (nonbondedMethod == CutoffPeriodic) {
RealVec* boxVectors = extractBoxVectors(context); Vec3* boxVectors = extractBoxVectors(context);
double minAllowedSize = 2*cutoffDistance; double minAllowedSize = 2*cutoffDistance;
if (boxVectors[0][0] < minAllowedSize || boxVectors[1][1] < minAllowedSize || boxVectors[2][2] < minAllowedSize) if (boxVectors[0][0] < minAllowedSize || boxVectors[1][1] < minAllowedSize || boxVectors[2][2] < minAllowedSize)
throw OpenMMException("The periodic box size has decreased to less than twice the nonbonded cutoff."); throw OpenMMException("The periodic box size has decreased to less than twice the nonbonded cutoff.");
...@@ -1992,7 +1992,7 @@ void ReferenceCalcCustomManyParticleForceKernel::copyParametersToContext(Context ...@@ -1992,7 +1992,7 @@ void ReferenceCalcCustomManyParticleForceKernel::copyParametersToContext(Context
int type; int type;
force.getParticleParameters(i, parameters, type); force.getParticleParameters(i, parameters, type);
for (int j = 0; j < numParameters; j++) for (int j = 0; j < numParameters; j++)
particleParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]); particleParamArray[i][j] = parameters[j];
} }
} }
...@@ -2024,20 +2024,20 @@ void ReferenceIntegrateVerletStepKernel::initialize(const System& system, const ...@@ -2024,20 +2024,20 @@ void ReferenceIntegrateVerletStepKernel::initialize(const System& system, const
int numParticles = system.getNumParticles(); int numParticles = system.getNumParticles();
masses.resize(numParticles); masses.resize(numParticles);
for (int i = 0; i < numParticles; ++i) for (int i = 0; i < numParticles; ++i)
masses[i] = static_cast<RealOpenMM>(system.getParticleMass(i)); masses[i] = system.getParticleMass(i);
} }
void ReferenceIntegrateVerletStepKernel::execute(ContextImpl& context, const VerletIntegrator& integrator) { void ReferenceIntegrateVerletStepKernel::execute(ContextImpl& context, const VerletIntegrator& integrator) {
double stepSize = integrator.getStepSize(); double stepSize = integrator.getStepSize();
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context); vector<Vec3>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
if (dynamics == 0 || stepSize != prevStepSize) { if (dynamics == 0 || stepSize != prevStepSize) {
// Recreate the computation objects with the new parameters. // Recreate the computation objects with the new parameters.
if (dynamics) if (dynamics)
delete dynamics; delete dynamics;
dynamics = new ReferenceVerletDynamics(context.getSystem().getNumParticles(), static_cast<RealOpenMM>(stepSize)); dynamics = new ReferenceVerletDynamics(context.getSystem().getNumParticles(), stepSize);
dynamics->setReferenceConstraintAlgorithm(&extractConstraints(context)); dynamics->setReferenceConstraintAlgorithm(&extractConstraints(context));
prevStepSize = stepSize; prevStepSize = stepSize;
} }
...@@ -2059,7 +2059,7 @@ void ReferenceIntegrateLangevinStepKernel::initialize(const System& system, cons ...@@ -2059,7 +2059,7 @@ void ReferenceIntegrateLangevinStepKernel::initialize(const System& system, cons
int numParticles = system.getNumParticles(); int numParticles = system.getNumParticles();
masses.resize(numParticles); masses.resize(numParticles);
for (int i = 0; i < numParticles; ++i) for (int i = 0; i < numParticles; ++i)
masses[i] = static_cast<RealOpenMM>(system.getParticleMass(i)); masses[i] = system.getParticleMass(i);
SimTKOpenMMUtilities::setRandomNumberSeed((unsigned int) integrator.getRandomNumberSeed()); SimTKOpenMMUtilities::setRandomNumberSeed((unsigned int) integrator.getRandomNumberSeed());
} }
...@@ -2067,9 +2067,9 @@ void ReferenceIntegrateLangevinStepKernel::execute(ContextImpl& context, const L ...@@ -2067,9 +2067,9 @@ void ReferenceIntegrateLangevinStepKernel::execute(ContextImpl& context, const L
double temperature = integrator.getTemperature(); double temperature = integrator.getTemperature();
double friction = integrator.getFriction(); double friction = integrator.getFriction();
double stepSize = integrator.getStepSize(); double stepSize = integrator.getStepSize();
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context); vector<Vec3>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
if (dynamics == 0 || temperature != prevTemp || friction != prevFriction || stepSize != prevStepSize) { if (dynamics == 0 || temperature != prevTemp || friction != prevFriction || stepSize != prevStepSize) {
// Recreate the computation objects with the new parameters. // Recreate the computation objects with the new parameters.
...@@ -2077,9 +2077,9 @@ void ReferenceIntegrateLangevinStepKernel::execute(ContextImpl& context, const L ...@@ -2077,9 +2077,9 @@ void ReferenceIntegrateLangevinStepKernel::execute(ContextImpl& context, const L
delete dynamics; delete dynamics;
dynamics = new ReferenceStochasticDynamics( dynamics = new ReferenceStochasticDynamics(
context.getSystem().getNumParticles(), context.getSystem().getNumParticles(),
static_cast<RealOpenMM>(stepSize), stepSize,
static_cast<RealOpenMM>(friction), friction,
static_cast<RealOpenMM>(temperature)); temperature);
dynamics->setReferenceConstraintAlgorithm(&extractConstraints(context)); dynamics->setReferenceConstraintAlgorithm(&extractConstraints(context));
prevTemp = temperature; prevTemp = temperature;
prevFriction = friction; prevFriction = friction;
...@@ -2103,7 +2103,7 @@ void ReferenceIntegrateBrownianStepKernel::initialize(const System& system, cons ...@@ -2103,7 +2103,7 @@ void ReferenceIntegrateBrownianStepKernel::initialize(const System& system, cons
int numParticles = system.getNumParticles(); int numParticles = system.getNumParticles();
masses.resize(numParticles); masses.resize(numParticles);
for (int i = 0; i < numParticles; ++i) for (int i = 0; i < numParticles; ++i)
masses[i] = static_cast<RealOpenMM>(system.getParticleMass(i)); masses[i] = system.getParticleMass(i);
SimTKOpenMMUtilities::setRandomNumberSeed((unsigned int) integrator.getRandomNumberSeed()); SimTKOpenMMUtilities::setRandomNumberSeed((unsigned int) integrator.getRandomNumberSeed());
} }
...@@ -2111,9 +2111,9 @@ void ReferenceIntegrateBrownianStepKernel::execute(ContextImpl& context, const B ...@@ -2111,9 +2111,9 @@ void ReferenceIntegrateBrownianStepKernel::execute(ContextImpl& context, const B
double temperature = integrator.getTemperature(); double temperature = integrator.getTemperature();
double friction = integrator.getFriction(); double friction = integrator.getFriction();
double stepSize = integrator.getStepSize(); double stepSize = integrator.getStepSize();
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context); vector<Vec3>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
if (dynamics == 0 || temperature != prevTemp || friction != prevFriction || stepSize != prevStepSize) { if (dynamics == 0 || temperature != prevTemp || friction != prevFriction || stepSize != prevStepSize) {
// Recreate the computation objects with the new parameters. // Recreate the computation objects with the new parameters.
...@@ -2121,9 +2121,9 @@ void ReferenceIntegrateBrownianStepKernel::execute(ContextImpl& context, const B ...@@ -2121,9 +2121,9 @@ void ReferenceIntegrateBrownianStepKernel::execute(ContextImpl& context, const B
delete dynamics; delete dynamics;
dynamics = new ReferenceBrownianDynamics( dynamics = new ReferenceBrownianDynamics(
context.getSystem().getNumParticles(), context.getSystem().getNumParticles(),
static_cast<RealOpenMM>(stepSize), stepSize,
static_cast<RealOpenMM>(friction), friction,
static_cast<RealOpenMM>(temperature)); temperature);
dynamics->setReferenceConstraintAlgorithm(&extractConstraints(context)); dynamics->setReferenceConstraintAlgorithm(&extractConstraints(context));
prevTemp = temperature; prevTemp = temperature;
prevFriction = friction; prevFriction = friction;
...@@ -2147,7 +2147,7 @@ void ReferenceIntegrateVariableLangevinStepKernel::initialize(const System& syst ...@@ -2147,7 +2147,7 @@ void ReferenceIntegrateVariableLangevinStepKernel::initialize(const System& syst
int numParticles = system.getNumParticles(); int numParticles = system.getNumParticles();
masses.resize(numParticles); masses.resize(numParticles);
for (int i = 0; i < numParticles; ++i) for (int i = 0; i < numParticles; ++i)
masses[i] = static_cast<RealOpenMM>(system.getParticleMass(i)); masses[i] = system.getParticleMass(i);
SimTKOpenMMUtilities::setRandomNumberSeed((unsigned int) integrator.getRandomNumberSeed()); SimTKOpenMMUtilities::setRandomNumberSeed((unsigned int) integrator.getRandomNumberSeed());
} }
...@@ -2155,21 +2155,21 @@ double ReferenceIntegrateVariableLangevinStepKernel::execute(ContextImpl& contex ...@@ -2155,21 +2155,21 @@ double ReferenceIntegrateVariableLangevinStepKernel::execute(ContextImpl& contex
double temperature = integrator.getTemperature(); double temperature = integrator.getTemperature();
double friction = integrator.getFriction(); double friction = integrator.getFriction();
double errorTol = integrator.getErrorTolerance(); double errorTol = integrator.getErrorTolerance();
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context); vector<Vec3>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
if (dynamics == 0 || temperature != prevTemp || friction != prevFriction || errorTol != prevErrorTol) { if (dynamics == 0 || temperature != prevTemp || friction != prevFriction || errorTol != prevErrorTol) {
// Recreate the computation objects with the new parameters. // Recreate the computation objects with the new parameters.
if (dynamics) if (dynamics)
delete dynamics; delete dynamics;
dynamics = new ReferenceVariableStochasticDynamics(context.getSystem().getNumParticles(), (RealOpenMM) friction, (RealOpenMM) temperature, (RealOpenMM) errorTol); dynamics = new ReferenceVariableStochasticDynamics(context.getSystem().getNumParticles(), friction, temperature, errorTol);
dynamics->setReferenceConstraintAlgorithm(&extractConstraints(context)); dynamics->setReferenceConstraintAlgorithm(&extractConstraints(context));
prevTemp = temperature; prevTemp = temperature;
prevFriction = friction; prevFriction = friction;
prevErrorTol = errorTol; prevErrorTol = errorTol;
} }
RealOpenMM maxStepSize = (RealOpenMM) (maxTime-data.time); double maxStepSize = maxTime-data.time;
dynamics->update(context.getSystem(), posData, velData, forceData, masses, maxStepSize, integrator.getConstraintTolerance()); dynamics->update(context.getSystem(), posData, velData, forceData, masses, maxStepSize, integrator.getConstraintTolerance());
data.time += dynamics->getDeltaT(); data.time += dynamics->getDeltaT();
if (dynamics->getDeltaT() == maxStepSize) if (dynamics->getDeltaT() == maxStepSize)
...@@ -2191,24 +2191,24 @@ void ReferenceIntegrateVariableVerletStepKernel::initialize(const System& system ...@@ -2191,24 +2191,24 @@ void ReferenceIntegrateVariableVerletStepKernel::initialize(const System& system
int numParticles = system.getNumParticles(); int numParticles = system.getNumParticles();
masses.resize(numParticles); masses.resize(numParticles);
for (int i = 0; i < numParticles; ++i) for (int i = 0; i < numParticles; ++i)
masses[i] = static_cast<RealOpenMM>(system.getParticleMass(i)); masses[i] = system.getParticleMass(i);
} }
double ReferenceIntegrateVariableVerletStepKernel::execute(ContextImpl& context, const VariableVerletIntegrator& integrator, double maxTime) { double ReferenceIntegrateVariableVerletStepKernel::execute(ContextImpl& context, const VariableVerletIntegrator& integrator, double maxTime) {
double errorTol = integrator.getErrorTolerance(); double errorTol = integrator.getErrorTolerance();
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context); vector<Vec3>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
if (dynamics == 0 || errorTol != prevErrorTol) { if (dynamics == 0 || errorTol != prevErrorTol) {
// Recreate the computation objects with the new parameters. // Recreate the computation objects with the new parameters.
if (dynamics) if (dynamics)
delete dynamics; delete dynamics;
dynamics = new ReferenceVariableVerletDynamics(context.getSystem().getNumParticles(), (RealOpenMM) errorTol); dynamics = new ReferenceVariableVerletDynamics(context.getSystem().getNumParticles(), errorTol);
dynamics->setReferenceConstraintAlgorithm(&extractConstraints(context)); dynamics->setReferenceConstraintAlgorithm(&extractConstraints(context));
prevErrorTol = errorTol; prevErrorTol = errorTol;
} }
RealOpenMM maxStepSize = (RealOpenMM) (maxTime-data.time); double maxStepSize = maxTime-data.time;
dynamics->update(context.getSystem(), posData, velData, forceData, masses, maxStepSize, integrator.getConstraintTolerance()); dynamics->update(context.getSystem(), posData, velData, forceData, masses, maxStepSize, integrator.getConstraintTolerance());
data.time += dynamics->getDeltaT(); data.time += dynamics->getDeltaT();
if (dynamics->getDeltaT() == maxStepSize) if (dynamics->getDeltaT() == maxStepSize)
...@@ -2230,7 +2230,7 @@ void ReferenceIntegrateCustomStepKernel::initialize(const System& system, const ...@@ -2230,7 +2230,7 @@ void ReferenceIntegrateCustomStepKernel::initialize(const System& system, const
int numParticles = system.getNumParticles(); int numParticles = system.getNumParticles();
masses.resize(numParticles); masses.resize(numParticles);
for (int i = 0; i < numParticles; ++i) for (int i = 0; i < numParticles; ++i)
masses[i] = static_cast<RealOpenMM>(system.getParticleMass(i)); masses[i] = system.getParticleMass(i);
perDofValues.resize(integrator.getNumPerDofVariables()); perDofValues.resize(integrator.getNumPerDofVariables());
for (int i = 0; i < (int) perDofValues.size(); i++) for (int i = 0; i < (int) perDofValues.size(); i++)
perDofValues[i].resize(numParticles); perDofValues[i].resize(numParticles);
...@@ -2242,9 +2242,9 @@ void ReferenceIntegrateCustomStepKernel::initialize(const System& system, const ...@@ -2242,9 +2242,9 @@ void ReferenceIntegrateCustomStepKernel::initialize(const System& system, const
} }
void ReferenceIntegrateCustomStepKernel::execute(ContextImpl& context, CustomIntegrator& integrator, bool& forcesAreValid) { void ReferenceIntegrateCustomStepKernel::execute(ContextImpl& context, CustomIntegrator& integrator, bool& forcesAreValid) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context); vector<Vec3>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
// Record global variables. // Record global variables.
...@@ -2268,9 +2268,9 @@ void ReferenceIntegrateCustomStepKernel::execute(ContextImpl& context, CustomInt ...@@ -2268,9 +2268,9 @@ void ReferenceIntegrateCustomStepKernel::execute(ContextImpl& context, CustomInt
} }
double ReferenceIntegrateCustomStepKernel::computeKineticEnergy(ContextImpl& context, CustomIntegrator& integrator, bool& forcesAreValid) { double ReferenceIntegrateCustomStepKernel::computeKineticEnergy(ContextImpl& context, CustomIntegrator& integrator, bool& forcesAreValid) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context); vector<Vec3>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context); vector<Vec3>& forceData = extractForces(context);
// Record global variables. // Record global variables.
...@@ -2313,18 +2313,18 @@ void ReferenceApplyAndersenThermostatKernel::initialize(const System& system, co ...@@ -2313,18 +2313,18 @@ void ReferenceApplyAndersenThermostatKernel::initialize(const System& system, co
int numParticles = system.getNumParticles(); int numParticles = system.getNumParticles();
masses.resize(numParticles); masses.resize(numParticles);
for (int i = 0; i < numParticles; ++i) for (int i = 0; i < numParticles; ++i)
masses[i] = static_cast<RealOpenMM>(system.getParticleMass(i)); masses[i] = system.getParticleMass(i);
this->thermostat = new ReferenceAndersenThermostat(); this->thermostat = new ReferenceAndersenThermostat();
SimTKOpenMMUtilities::setRandomNumberSeed((unsigned int) thermostat.getRandomNumberSeed()); SimTKOpenMMUtilities::setRandomNumberSeed((unsigned int) thermostat.getRandomNumberSeed());
particleGroups = AndersenThermostatImpl::calcParticleGroups(system); particleGroups = AndersenThermostatImpl::calcParticleGroups(system);
} }
void ReferenceApplyAndersenThermostatKernel::execute(ContextImpl& context) { void ReferenceApplyAndersenThermostatKernel::execute(ContextImpl& context) {
vector<RealVec>& velData = extractVelocities(context); vector<Vec3>& velData = extractVelocities(context);
thermostat->applyThermostat(particleGroups, velData, masses, thermostat->applyThermostat(particleGroups, velData, masses,
static_cast<RealOpenMM>(context.getParameter(AndersenThermostat::Temperature())), context.getParameter(AndersenThermostat::Temperature()),
static_cast<RealOpenMM>(context.getParameter(AndersenThermostat::CollisionFrequency())), context.getParameter(AndersenThermostat::CollisionFrequency()),
static_cast<RealOpenMM>(context.getIntegrator().getStepSize())); context.getIntegrator().getStepSize());
} }
ReferenceApplyMonteCarloBarostatKernel::~ReferenceApplyMonteCarloBarostatKernel() { ReferenceApplyMonteCarloBarostatKernel::~ReferenceApplyMonteCarloBarostatKernel() {
...@@ -2338,13 +2338,13 @@ void ReferenceApplyMonteCarloBarostatKernel::initialize(const System& system, co ...@@ -2338,13 +2338,13 @@ void ReferenceApplyMonteCarloBarostatKernel::initialize(const System& system, co
void ReferenceApplyMonteCarloBarostatKernel::scaleCoordinates(ContextImpl& context, double scaleX, double scaleY, double scaleZ) { void ReferenceApplyMonteCarloBarostatKernel::scaleCoordinates(ContextImpl& context, double scaleX, double scaleY, double scaleZ) {
if (barostat == NULL) if (barostat == NULL)
barostat = new ReferenceMonteCarloBarostat(context.getSystem().getNumParticles(), context.getMolecules()); barostat = new ReferenceMonteCarloBarostat(context.getSystem().getNumParticles(), context.getMolecules());
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
RealVec* boxVectors = extractBoxVectors(context); Vec3* boxVectors = extractBoxVectors(context);
barostat->applyBarostat(posData, boxVectors, scaleX, scaleY, scaleZ); barostat->applyBarostat(posData, boxVectors, scaleX, scaleY, scaleZ);
} }
void ReferenceApplyMonteCarloBarostatKernel::restoreCoordinates(ContextImpl& context) { void ReferenceApplyMonteCarloBarostatKernel::restoreCoordinates(ContextImpl& context) {
vector<RealVec>& posData = extractPositions(context); vector<Vec3>& posData = extractPositions(context);
barostat->restorePositions(posData); barostat->restorePositions(posData);
} }
...@@ -2358,17 +2358,17 @@ void ReferenceRemoveCMMotionKernel::initialize(const System& system, const CMMot ...@@ -2358,17 +2358,17 @@ void ReferenceRemoveCMMotionKernel::initialize(const System& system, const CMMot
void ReferenceRemoveCMMotionKernel::execute(ContextImpl& context) { void ReferenceRemoveCMMotionKernel::execute(ContextImpl& context) {
if (data.stepCount%frequency != 0) if (data.stepCount%frequency != 0)
return; return;
vector<RealVec>& velData = extractVelocities(context); vector<Vec3>& velData = extractVelocities(context);
// Calculate the center of mass momentum. // Calculate the center of mass momentum.
RealOpenMM momentum[] = {0.0, 0.0, 0.0}; double momentum[] = {0.0, 0.0, 0.0};
RealOpenMM mass = 0.0; double mass = 0.0;
for (size_t i = 0; i < masses.size(); ++i) { for (size_t i = 0; i < masses.size(); ++i) {
momentum[0] += static_cast<RealOpenMM>(masses[i]*velData[i][0]); momentum[0] += masses[i]*velData[i][0];
momentum[1] += static_cast<RealOpenMM>(masses[i]*velData[i][1]); momentum[1] += masses[i]*velData[i][1];
momentum[2] += static_cast<RealOpenMM>(masses[i]*velData[i][2]); momentum[2] += masses[i]*velData[i][2];
mass += static_cast<RealOpenMM>(masses[i]); mass += masses[i];
} }
// Adjust the particle velocities. // Adjust the particle velocities.
......
platforms/reference/src/ReferencePlatform.cpp
View file @ 8469621f
...@@ -35,7 +35,7 @@ ...@@ -35,7 +35,7 @@
#include "ReferenceKernels.h" #include "ReferenceKernels.h"
#include "openmm/internal/ContextImpl.h" #include "openmm/internal/ContextImpl.h"
#include "SimTKOpenMMRealType.h" #include "SimTKOpenMMRealType.h"
#include "RealVec.h" #include "openmm/Vec3.h"
#include <map> #include <map>
#include <vector> #include <vector>
...@@ -82,7 +82,7 @@ double ReferencePlatform::getSpeed() const { ...@@ -82,7 +82,7 @@ double ReferencePlatform::getSpeed() const {
} }
bool ReferencePlatform::supportsDoublePrecision() const { bool ReferencePlatform::supportsDoublePrecision() const {
return (sizeof(RealOpenMM) >= sizeof(double)); return true;
} }
void ReferencePlatform::contextCreated(ContextImpl& context, const map<string, string>& properties) const { void ReferencePlatform::contextCreated(ContextImpl& context, const map<string, string>& properties) const {
...@@ -95,21 +95,21 @@ void ReferencePlatform::contextDestroyed(ContextImpl& context) const { ...@@ -95,21 +95,21 @@ void ReferencePlatform::contextDestroyed(ContextImpl& context) const {
} }
ReferencePlatform::PlatformData::PlatformData(const System& system) : time(0.0), stepCount(0), numParticles(system.getNumParticles()) { ReferencePlatform::PlatformData::PlatformData(const System& system) : time(0.0), stepCount(0), numParticles(system.getNumParticles()) {
positions = new vector<RealVec>(numParticles); positions = new vector<Vec3>(numParticles);
velocities = new vector<RealVec>(numParticles); velocities = new vector<Vec3>(numParticles);
forces = new vector<RealVec>(numParticles); forces = new vector<Vec3>(numParticles);
periodicBoxSize = new RealVec(); periodicBoxSize = new Vec3();
periodicBoxVectors = new RealVec[3]; periodicBoxVectors = new Vec3[3];
constraints = new ReferenceConstraints(system); constraints = new ReferenceConstraints(system);
energyParameterDerivatives = new map<string, double>(); energyParameterDerivatives = new map<string, double>();
} }
ReferencePlatform::PlatformData::~PlatformData() { ReferencePlatform::PlatformData::~PlatformData() {
delete (vector<RealVec>*) positions; delete (vector<Vec3>*) positions;
delete (vector<RealVec>*) velocities; delete (vector<Vec3>*) velocities;
delete (vector<RealVec>*) forces; delete (vector<Vec3>*) forces;
delete (RealVec*) periodicBoxSize; delete (Vec3*) periodicBoxSize;
delete[] (RealVec*) periodicBoxVectors; delete[] (Vec3*) periodicBoxVectors;
delete (ReferenceConstraints*) constraints; delete (ReferenceConstraints*) constraints;
delete (map<string, double>*) energyParameterDerivatives; delete (map<string, double>*) energyParameterDerivatives;
} }
platforms/reference/src/SimTKReference/ObcParameters.cpp
View file @ 8469621f
...@@ -28,6 +28,7 @@ ...@@ -28,6 +28,7 @@
#include "openmm/OpenMMException.h" #include "openmm/OpenMMException.h"
#include "ObcParameters.h" #include "ObcParameters.h"
#include "SimTKOpenMMRealType.h"
using std::vector; using std::vector;
using namespace OpenMM; using namespace OpenMM;
...@@ -121,7 +122,7 @@ void ObcParameters::setObcTypeParameters(ObcParameters::ObcType obcType) { ...@@ -121,7 +122,7 @@ void ObcParameters::setObcTypeParameters(ObcParameters::ObcType obcType) {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getDielectricOffset() const { double ObcParameters::getDielectricOffset() const {
return _dielectricOffset; return _dielectricOffset;
} }
...@@ -133,7 +134,7 @@ RealOpenMM ObcParameters::getDielectricOffset() const { ...@@ -133,7 +134,7 @@ RealOpenMM ObcParameters::getDielectricOffset() const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getAlphaObc() const { double ObcParameters::getAlphaObc() const {
return _alphaObc; return _alphaObc;
} }
...@@ -145,7 +146,7 @@ RealOpenMM ObcParameters::getAlphaObc() const { ...@@ -145,7 +146,7 @@ RealOpenMM ObcParameters::getAlphaObc() const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getBetaObc() const { double ObcParameters::getBetaObc() const {
return _betaObc; return _betaObc;
} }
...@@ -157,7 +158,7 @@ RealOpenMM ObcParameters::getBetaObc() const { ...@@ -157,7 +158,7 @@ RealOpenMM ObcParameters::getBetaObc() const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getGammaObc() const { double ObcParameters::getGammaObc() const {
return _gammaObc; return _gammaObc;
} }
...@@ -169,7 +170,7 @@ RealOpenMM ObcParameters::getGammaObc() const { ...@@ -169,7 +170,7 @@ RealOpenMM ObcParameters::getGammaObc() const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getSolventDielectric() const { double ObcParameters::getSolventDielectric() const {
return _solventDielectric; return _solventDielectric;
} }
...@@ -181,7 +182,7 @@ RealOpenMM ObcParameters::getSolventDielectric() const { ...@@ -181,7 +182,7 @@ RealOpenMM ObcParameters::getSolventDielectric() const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ObcParameters::setSolventDielectric(RealOpenMM solventDielectric) { void ObcParameters::setSolventDielectric(double solventDielectric) {
_solventDielectric = solventDielectric; _solventDielectric = solventDielectric;
} }
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -192,7 +193,7 @@ void ObcParameters::setSolventDielectric(RealOpenMM solventDielectric) { ...@@ -192,7 +193,7 @@ void ObcParameters::setSolventDielectric(RealOpenMM solventDielectric) {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getSoluteDielectric() const { double ObcParameters::getSoluteDielectric() const {
return _soluteDielectric; return _soluteDielectric;
} }
...@@ -204,7 +205,7 @@ RealOpenMM ObcParameters::getSoluteDielectric() const { ...@@ -204,7 +205,7 @@ RealOpenMM ObcParameters::getSoluteDielectric() const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ObcParameters::setSoluteDielectric(RealOpenMM soluteDielectric) { void ObcParameters::setSoluteDielectric(double soluteDielectric) {
_soluteDielectric = soluteDielectric; _soluteDielectric = soluteDielectric;
} }
...@@ -216,7 +217,7 @@ void ObcParameters::setSoluteDielectric(RealOpenMM soluteDielectric) { ...@@ -216,7 +217,7 @@ void ObcParameters::setSoluteDielectric(RealOpenMM soluteDielectric) {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getElectricConstant() const { double ObcParameters::getElectricConstant() const {
return _electricConstant; return _electricConstant;
} }
...@@ -228,7 +229,7 @@ RealOpenMM ObcParameters::getElectricConstant() const { ...@@ -228,7 +229,7 @@ RealOpenMM ObcParameters::getElectricConstant() const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getProbeRadius() const { double ObcParameters::getProbeRadius() const {
return _probeRadius; return _probeRadius;
} }
...@@ -240,25 +241,25 @@ RealOpenMM ObcParameters::getProbeRadius() const { ...@@ -240,25 +241,25 @@ RealOpenMM ObcParameters::getProbeRadius() const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ObcParameters::setProbeRadius(RealOpenMM probeRadius) { void ObcParameters::setProbeRadius(double probeRadius) {
_probeRadius = probeRadius; _probeRadius = probeRadius;
} }
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
Get pi*4*Asolv: used in ACE approximation for nonpolar term Get pi*4*Asolv: used in ACE approximation for nonpolar term
((RealOpenMM) M_PI)*4.0f*0.0049*1000.0; (Still) M_PI*4.0f*0.0049*1000.0; (Still)
((RealOpenMM) M_PI)*4.0f*0.0054*1000.0; (OBC) M_PI*4.0f*0.0054*1000.0; (OBC)
@return pi4Asolv @return pi4Asolv
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getPi4Asolv() const { double ObcParameters::getPi4Asolv() const {
return _pi4Asolv; return _pi4Asolv;
} }
void ObcParameters::setPi4Asolv(RealOpenMM pi4Asolv) { void ObcParameters::setPi4Asolv(double pi4Asolv) {
_pi4Asolv = pi4Asolv; _pi4Asolv = pi4Asolv;
} }
...@@ -270,7 +271,7 @@ void ObcParameters::setPi4Asolv(RealOpenMM pi4Asolv) { ...@@ -270,7 +271,7 @@ void ObcParameters::setPi4Asolv(RealOpenMM pi4Asolv) {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
const vector<RealOpenMM>& ObcParameters::getAtomicRadii() const { const vector<double>& ObcParameters::getAtomicRadii() const {
return _atomicRadii; return _atomicRadii;
} }
...@@ -282,7 +283,7 @@ const vector<RealOpenMM>& ObcParameters::getAtomicRadii() const { ...@@ -282,7 +283,7 @@ const vector<RealOpenMM>& ObcParameters::getAtomicRadii() const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ObcParameters::setAtomicRadii(const vector<RealOpenMM>& atomicRadii) { void ObcParameters::setAtomicRadii(const vector<double>& atomicRadii) {
if (atomicRadii.size() == _atomicRadii.size()) { if (atomicRadii.size() == _atomicRadii.size()) {
for (unsigned int ii = 0; ii < atomicRadii.size(); ii++) { for (unsigned int ii = 0; ii < atomicRadii.size(); ii++) {
...@@ -306,7 +307,7 @@ void ObcParameters::setAtomicRadii(const vector<RealOpenMM>& atomicRadii) { ...@@ -306,7 +307,7 @@ void ObcParameters::setAtomicRadii(const vector<RealOpenMM>& atomicRadii) {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
const vector<RealOpenMM>& ObcParameters::getScaledRadiusFactors() const { const vector<double>& ObcParameters::getScaledRadiusFactors() const {
return _scaledRadiusFactors; return _scaledRadiusFactors;
} }
...@@ -318,7 +319,7 @@ const vector<RealOpenMM>& ObcParameters::getScaledRadiusFactors() const { ...@@ -318,7 +319,7 @@ const vector<RealOpenMM>& ObcParameters::getScaledRadiusFactors() const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ObcParameters::setScaledRadiusFactors(const vector<RealOpenMM>& scaledRadiusFactors) { void ObcParameters::setScaledRadiusFactors(const vector<double>& scaledRadiusFactors) {
if (scaledRadiusFactors.size() == _scaledRadiusFactors.size()) { if (scaledRadiusFactors.size() == _scaledRadiusFactors.size()) {
for (unsigned int ii = 0; ii < scaledRadiusFactors.size(); ii++) { for (unsigned int ii = 0; ii < scaledRadiusFactors.size(); ii++) {
...@@ -342,7 +343,7 @@ void ObcParameters::setScaledRadiusFactors(const vector<RealOpenMM>& scaledRadiu ...@@ -342,7 +343,7 @@ void ObcParameters::setScaledRadiusFactors(const vector<RealOpenMM>& scaledRadiu
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ObcParameters::setUseCutoff(RealOpenMM distance) { void ObcParameters::setUseCutoff(double distance) {
_cutoff = true; _cutoff = true;
_cutoffDistance = distance; _cutoffDistance = distance;
...@@ -364,7 +365,7 @@ bool ObcParameters::getUseCutoff() const { ...@@ -364,7 +365,7 @@ bool ObcParameters::getUseCutoff() const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getCutoffDistance() const { double ObcParameters::getCutoffDistance() const {
return _cutoffDistance; return _cutoffDistance;
} }
...@@ -378,7 +379,7 @@ RealOpenMM ObcParameters::getCutoffDistance() const { ...@@ -378,7 +379,7 @@ RealOpenMM ObcParameters::getCutoffDistance() const {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ObcParameters::setPeriodic(OpenMM::RealVec* vectors) { void ObcParameters::setPeriodic(OpenMM::Vec3* vectors) {
assert(_cutoff); assert(_cutoff);
...@@ -408,6 +409,6 @@ bool ObcParameters::getPeriodic() { ...@@ -408,6 +409,6 @@ bool ObcParameters::getPeriodic() {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
const OpenMM::RealVec* ObcParameters::getPeriodicBox() { const OpenMM::Vec3* ObcParameters::getPeriodicBox() {
return _periodicBoxVectors; return _periodicBoxVectors;
} }
platforms/reference/src/SimTKReference/ReferenceAndersenThermostat.cpp
View file @ 8469621f
...@@ -22,6 +22,7 @@ ...@@ -22,6 +22,7 @@
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/ */
#include <cmath>
#include <string.h> #include <string.h>
#include <sstream> #include <sstream>
...@@ -61,10 +62,10 @@ using namespace OpenMM; ...@@ -61,10 +62,10 @@ using namespace OpenMM;
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ReferenceAndersenThermostat::applyThermostat(const vector<vector<int> >& atomGroups, vector<RealVec>& atomVelocities, vector<RealOpenMM>& atomMasses, void ReferenceAndersenThermostat::applyThermostat(const vector<vector<int> >& atomGroups, vector<Vec3>& atomVelocities, vector<double>& atomMasses,
RealOpenMM temperature, RealOpenMM collisionFrequency, RealOpenMM stepSize) const { double temperature, double collisionFrequency, double stepSize) const {
const RealOpenMM collisionProbability = 1.0f - EXP(-collisionFrequency*stepSize); const double collisionProbability = 1.0f - exp(-collisionFrequency*stepSize);
for (int i = 0; i < (int) atomGroups.size(); ++i) { for (int i = 0; i < (int) atomGroups.size(); ++i) {
if (SimTKOpenMMUtilities::getUniformlyDistributedRandomNumber() < collisionProbability) { if (SimTKOpenMMUtilities::getUniformlyDistributedRandomNumber() < collisionProbability) {
...@@ -73,7 +74,7 @@ using namespace OpenMM; ...@@ -73,7 +74,7 @@ using namespace OpenMM;
for (int j = 0; j < (int) atomGroups[i].size(); j++) { for (int j = 0; j < (int) atomGroups[i].size(); j++) {
int atom = atomGroups[i][j]; int atom = atomGroups[i][j];
if (atomMasses[atom] != 0) { if (atomMasses[atom] != 0) {
const RealOpenMM velocityScale = static_cast<RealOpenMM>(sqrt(BOLTZ*temperature/atomMasses[atom])); const double velocityScale = static_cast<double>(sqrt(BOLTZ*temperature/atomMasses[atom]));
atomVelocities[atom][0] = velocityScale*SimTKOpenMMUtilities::getNormallyDistributedRandomNumber(); atomVelocities[atom][0] = velocityScale*SimTKOpenMMUtilities::getNormallyDistributedRandomNumber();
atomVelocities[atom][1] = velocityScale*SimTKOpenMMUtilities::getNormallyDistributedRandomNumber(); atomVelocities[atom][1] = velocityScale*SimTKOpenMMUtilities::getNormallyDistributedRandomNumber();
atomVelocities[atom][2] = velocityScale*SimTKOpenMMUtilities::getNormallyDistributedRandomNumber(); atomVelocities[atom][2] = velocityScale*SimTKOpenMMUtilities::getNormallyDistributedRandomNumber();
......
platforms/reference/src/SimTKReference/ReferenceAngleBondIxn.cpp
View file @ 8469621f
...@@ -39,13 +39,6 @@ using namespace OpenMM; ...@@ -39,13 +39,6 @@ using namespace OpenMM;
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceAngleBondIxn::ReferenceAngleBondIxn() : usePeriodic(false) { ReferenceAngleBondIxn::ReferenceAngleBondIxn() : usePeriodic(false) {
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nReferenceAngleBondIxn::ReferenceAngleBondIxn";
// ---------------------------------------------------------------------------------------
} }
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -55,16 +48,9 @@ ReferenceAngleBondIxn::ReferenceAngleBondIxn() : usePeriodic(false) { ...@@ -55,16 +48,9 @@ ReferenceAngleBondIxn::ReferenceAngleBondIxn() : usePeriodic(false) {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceAngleBondIxn::~ReferenceAngleBondIxn() { ReferenceAngleBondIxn::~ReferenceAngleBondIxn() {
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nReferenceAngleBondIxn::~ReferenceAngleBondIxn";
// ---------------------------------------------------------------------------------------
} }
void ReferenceAngleBondIxn::setPeriodic(OpenMM::RealVec* vectors) { void ReferenceAngleBondIxn::setPeriodic(OpenMM::Vec3* vectors) {
usePeriodic = true; usePeriodic = true;
boxVectors[0] = vectors[0]; boxVectors[0] = vectors[0];
boxVectors[1] = vectors[1]; boxVectors[1] = vectors[1];
...@@ -83,32 +69,22 @@ void ReferenceAngleBondIxn::setPeriodic(OpenMM::RealVec* vectors) { ...@@ -83,32 +69,22 @@ void ReferenceAngleBondIxn::setPeriodic(OpenMM::RealVec* vectors) {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ReferenceAngleBondIxn::getPrefactorsGivenAngleCosine(RealOpenMM cosine, RealOpenMM* angleParameters, void ReferenceAngleBondIxn::getPrefactorsGivenAngleCosine(double cosine, double* angleParameters,
RealOpenMM* dEdR, RealOpenMM* energyTerm) const { double* dEdR, double* energyTerm) const {
// ---------------------------------------------------------------------------------------
// static const std::string methodName = "\nReferenceAngleBondIxn::getPrefactorsGivenAngleCosine";
static const RealOpenMM zero = 0.0;
static const RealOpenMM one = 1.0;
static const RealOpenMM half = 0.5;
// --------------------------------------------------------------------------------------- double angle;
if (cosine >= 1.0) {
RealOpenMM angle; angle = 0.0;
if (cosine >= one) { } else if (cosine <= -1.0) {
angle = zero;
} else if (cosine <= -one) {
angle = PI_M; angle = PI_M;
} else { } else {
angle = ACOS(cosine); angle = acos(cosine);
} }
RealOpenMM deltaIdeal = angle - angleParameters[0]; double deltaIdeal = angle - angleParameters[0];
RealOpenMM deltaIdeal2 = deltaIdeal*deltaIdeal; double deltaIdeal2 = deltaIdeal*deltaIdeal;
*dEdR = angleParameters[1]*deltaIdeal; *dEdR = angleParameters[1]*deltaIdeal;
*energyTerm = half*angleParameters[1]*deltaIdeal2; *energyTerm = 0.5*angleParameters[1]*deltaIdeal2;
} }
...@@ -126,24 +102,14 @@ void ReferenceAngleBondIxn::getPrefactorsGivenAngleCosine(RealOpenMM cosine, Rea ...@@ -126,24 +102,14 @@ void ReferenceAngleBondIxn::getPrefactorsGivenAngleCosine(RealOpenMM cosine, Rea
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ReferenceAngleBondIxn::calculateBondIxn(int* atomIndices, void ReferenceAngleBondIxn::calculateBondIxn(int* atomIndices,
vector<RealVec>& atomCoordinates, vector<Vec3>& atomCoordinates,
RealOpenMM* parameters, double* parameters,
vector<RealVec>& forces, vector<Vec3>& forces,
RealOpenMM* totalEnergy, double* energyParamDerivs) { double* totalEnergy, double* energyParamDerivs) {
// constants -- reduce Visual Studio warnings regarding conversions between float & double
static const RealOpenMM zero = 0.0;
static const RealOpenMM one = 1.0;
static const RealOpenMM two = 2.0;
static const RealOpenMM three = 3.0;
static const RealOpenMM oneM = -1.0;
static const int threeI = 3;
static const int LastAtomIndex = 3; static const int LastAtomIndex = 3;
RealOpenMM deltaR[2][ReferenceForce::LastDeltaRIndex]; double deltaR[2][ReferenceForce::LastDeltaRIndex];
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
...@@ -161,37 +127,36 @@ void ReferenceAngleBondIxn::calculateBondIxn(int* atomIndices, ...@@ -161,37 +127,36 @@ void ReferenceAngleBondIxn::calculateBondIxn(int* atomIndices,
ReferenceForce::getDeltaR(atomCoordinates[atomCIndex], atomCoordinates[atomBIndex], deltaR[1]); ReferenceForce::getDeltaR(atomCoordinates[atomCIndex], atomCoordinates[atomBIndex], deltaR[1]);
} }
RealOpenMM pVector[threeI]; double pVector[3];
SimTKOpenMMUtilities::crossProductVector3(deltaR[0], deltaR[1], pVector); SimTKOpenMMUtilities::crossProductVector3(deltaR[0], deltaR[1], pVector);
RealOpenMM rp = DOT3(pVector, pVector); double rp = sqrt(DOT3(pVector, pVector));
rp = SQRT(rp);
if (rp < 1.0e-06) { if (rp < 1.0e-06) {
rp = (RealOpenMM) 1.0e-06; rp = 1.0e-06;
} }
RealOpenMM dot = DOT3(deltaR[0], deltaR[1]); double dot = DOT3(deltaR[0], deltaR[1]);
RealOpenMM cosine = dot/SQRT((deltaR[0][ReferenceForce::R2Index]*deltaR[1][ReferenceForce::R2Index])); double cosine = dot/sqrt((deltaR[0][ReferenceForce::R2Index]*deltaR[1][ReferenceForce::R2Index]));
RealOpenMM dEdR; double dEdR;
RealOpenMM energy; double energy;
getPrefactorsGivenAngleCosine(cosine, parameters, &dEdR, &energy); getPrefactorsGivenAngleCosine(cosine, parameters, &dEdR, &energy);
RealOpenMM termA = dEdR/(deltaR[0][ReferenceForce::R2Index]*rp); double termA = dEdR/(deltaR[0][ReferenceForce::R2Index]*rp);
RealOpenMM termC = -dEdR/(deltaR[1][ReferenceForce::R2Index]*rp); double termC = -dEdR/(deltaR[1][ReferenceForce::R2Index]*rp);
RealOpenMM deltaCrossP[LastAtomIndex][threeI]; double deltaCrossP[LastAtomIndex][3];
SimTKOpenMMUtilities::crossProductVector3(deltaR[0], pVector, deltaCrossP[0]); SimTKOpenMMUtilities::crossProductVector3(deltaR[0], pVector, deltaCrossP[0]);
SimTKOpenMMUtilities::crossProductVector3(deltaR[1], pVector, deltaCrossP[2]); SimTKOpenMMUtilities::crossProductVector3(deltaR[1], pVector, deltaCrossP[2]);
for (int ii = 0; ii < threeI; ii++) { for (int ii = 0; ii < 3; ii++) {
deltaCrossP[0][ii] *= termA; deltaCrossP[0][ii] *= termA;
deltaCrossP[2][ii] *= termC; deltaCrossP[2][ii] *= termC;
deltaCrossP[1][ii] = oneM*(deltaCrossP[0][ii] + deltaCrossP[2][ii]); deltaCrossP[1][ii] = -(deltaCrossP[0][ii] + deltaCrossP[2][ii]);
} }
// accumulate forces // accumulate forces
for (int jj = 0; jj < LastAtomIndex; jj++) { for (int jj = 0; jj < LastAtomIndex; jj++) {
for (int ii = 0; ii < threeI; ii++) { for (int ii = 0; ii < 3; ii++) {
forces[atomIndices[jj]][ii] += deltaCrossP[jj][ii]; forces[atomIndices[jj]][ii] += deltaCrossP[jj][ii];
} }
} }
......
platforms/reference/src/SimTKReference/ReferenceBondForce.cpp
View file @ 8469621f
...@@ -38,13 +38,6 @@ using namespace OpenMM; ...@@ -38,13 +38,6 @@ using namespace OpenMM;
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceBondForce::ReferenceBondForce() { ReferenceBondForce::ReferenceBondForce() {
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nReferenceBondForce::ReferenceBondForce";
// ---------------------------------------------------------------------------------------
} }
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -54,13 +47,6 @@ ReferenceBondForce::ReferenceBondForce() { ...@@ -54,13 +47,6 @@ ReferenceBondForce::ReferenceBondForce() {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceBondForce::~ReferenceBondForce() { ReferenceBondForce::~ReferenceBondForce() {
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nReferenceBondForce::~ReferenceBondForce";
// ---------------------------------------------------------------------------------------
} }
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -79,19 +65,12 @@ ReferenceBondForce::~ReferenceBondForce() { ...@@ -79,19 +65,12 @@ ReferenceBondForce::~ReferenceBondForce() {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ReferenceBondForce::calculateForce(int numberOfBonds, int** atomIndices, void ReferenceBondForce::calculateForce(int numberOfBonds, int** atomIndices,
vector<RealVec>& atomCoordinates, vector<Vec3>& atomCoordinates,
RealOpenMM** parameters, double** parameters,
vector<RealVec>& forces, vector<Vec3>& forces,
RealOpenMM *totalEnergy, double *totalEnergy,
ReferenceBondIxn& referenceBondIxn) { ReferenceBondIxn& referenceBondIxn) {
// ---------------------------------------------------------------------------------------
static const char* methodName = "\nReferenceBondForce::calculateForce";
// ---------------------------------------------------------------------------------------
for (int ii = 0; ii < numberOfBonds; ii++) { for (int ii = 0; ii < numberOfBonds; ii++) {
// calculate bond ixn // calculate bond ixn
......
platforms/reference/src/SimTKReference/ReferenceBondIxn.cpp
View file @ 8469621f
...@@ -39,13 +39,6 @@ using namespace OpenMM; ...@@ -39,13 +39,6 @@ using namespace OpenMM;
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceBondIxn::ReferenceBondIxn() { ReferenceBondIxn::ReferenceBondIxn() {
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nReferenceBondIxn::ReferenceBondIxn";
// ---------------------------------------------------------------------------------------
} }
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -55,13 +48,6 @@ ReferenceBondIxn::ReferenceBondIxn() { ...@@ -55,13 +48,6 @@ ReferenceBondIxn::ReferenceBondIxn() {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
ReferenceBondIxn::~ReferenceBondIxn() { ReferenceBondIxn::~ReferenceBondIxn() {
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nReferenceBondIxn::~ReferenceBondIxn";
// ---------------------------------------------------------------------------------------
} }
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -76,15 +62,9 @@ ReferenceBondIxn::~ReferenceBondIxn() { ...@@ -76,15 +62,9 @@ ReferenceBondIxn::~ReferenceBondIxn() {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
void ReferenceBondIxn::calculateBondIxn(int* atomIndices, vector<RealVec>& atomCoordinates, void ReferenceBondIxn::calculateBondIxn(int* atomIndices, vector<Vec3>& atomCoordinates,
RealOpenMM* parameters, vector<RealVec>& forces, double* parameters, vector<Vec3>& forces,
RealOpenMM* totalEnergy, double* energyParamDerivs) { double* totalEnergy, double* energyParamDerivs) {
// ---------------------------------------------------------------------------------------
// static const std::string methodName = "\nReferenceBondIxn::calculateBondIxn";
// ---------------------------------------------------------------------------------------
} }
/**--------------------------------------------------------------------------------------- /**---------------------------------------------------------------------------------------
...@@ -102,67 +82,26 @@ ReferenceBondIxn::~ReferenceBondIxn() { ...@@ -102,67 +82,26 @@ ReferenceBondIxn::~ReferenceBondIxn() {
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ReferenceBondIxn::getNormedDotProduct(RealOpenMM* vector1, RealOpenMM* vector2, double ReferenceBondIxn::getNormedDotProduct(double* vector1, double* vector2,
int hasREntry = 0) { int hasREntry = 0) {
// ---------------------------------------------------------------------------------------
// static const std::string methodName = "\nReferenceBondIxn::getNormedDotProduct";
static const RealOpenMM zero = 0.0;
static const RealOpenMM one = 1.0;
// ---------------------------------------------------------------------------------------
// for angles near pi, double is required due to the 'steepness' of acos()
// in this regime.
//#define USE_DOUBLE_FOR_NORMED_DOT_PRODUCT
#if defined USE_DOUBLE_FOR_NORMED_DOT_PRODUCT double dotProduct = DOT3(vector1, vector2);
double v1D[3]; if (dotProduct != 0.0) {
double v2D[3];
v1D[0] = static_cast<double>(vector1[0]);
v1D[1] = static_cast<double>(vector1[1]);
v1D[2] = static_cast<double>(vector1[2]);
v2D[0] = static_cast<double>(vector2[0]);
v2D[1] = static_cast<double>(vector2[1]);
v2D[2] = static_cast<double>(vector2[2]);
double dotProductD = DOT3(v1D, v2D);
if (dotProductD != 0.0) {
if (hasREntry) {
dotProductD /= (static_cast<double>(vector1[ReferenceForce::RIndex])*static_cast<double>(vector2[ReferenceForce::RIndex]));
} else {
double norm1 = DOT3(v1D, v1D);
double norm2 = DOT3(v2D, v2D);
dotProductD /= sqrt(norm1*norm2);
}
}
RealOpenMM dotProduct = static_cast<RealOpenMM>(dotProductD);
#else
RealOpenMM dotProduct = DOT3(vector1, vector2);
if (dotProduct != zero) {
if (hasREntry) { if (hasREntry) {
dotProduct /= (vector1[ReferenceForce::RIndex]*vector2[ReferenceForce::RIndex]); dotProduct /= (vector1[ReferenceForce::RIndex]*vector2[ReferenceForce::RIndex]);
} else { } else {
RealOpenMM norm1 = DOT3(vector1, vector1); double norm1 = DOT3(vector1, vector1);
RealOpenMM norm2 = DOT3(vector2, vector2); double norm2 = DOT3(vector2, vector2);
dotProduct /= SQRT(norm1*norm2); dotProduct /= sqrt(norm1*norm2);
} }
} }
#endif
#undef USE_DOUBLE_FOR_NORMED_DOT_PRODUCT
// clamp dot product to [-1,1] // clamp dot product to [-1,1]
if (dotProduct > one) { if (dotProduct > 1.0) {
dotProduct = one; dotProduct = 1.0;
} else if (dotProduct < -one) { } else if (dotProduct < -1.0) {
dotProduct = -one; dotProduct = -1.0;
} }
return dotProduct; return dotProduct;
...@@ -183,35 +122,26 @@ RealOpenMM ReferenceBondIxn::getNormedDotProduct(RealOpenMM* vector1, RealOpenMM ...@@ -183,35 +122,26 @@ RealOpenMM ReferenceBondIxn::getNormedDotProduct(RealOpenMM* vector1, RealOpenMM
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ReferenceBondIxn::getAngleBetweenTwoVectors(RealOpenMM* vector1, RealOpenMM* vector2, double ReferenceBondIxn::getAngleBetweenTwoVectors(double* vector1, double* vector2,
RealOpenMM* outputDotProduct = NULL, double* outputDotProduct = NULL,
int hasREntry = 0) { int hasREntry = 0) {
// --------------------------------------------------------------------------------------- // get dot product betweenn vectors and then angle
// static const std::string methodName = "\nReferenceBondIxn::getAngle"; double dotProduct = getNormedDotProduct(vector1, vector2, hasREntry);
static const RealOpenMM zero = 0.0; double angle;
static const RealOpenMM one = 1.0; if (dotProduct > 0.99 || dotProduct < -0.99) {
// ---------------------------------------------------------------------------------------
// get dot product betweenn vectors and then angle
RealOpenMM dotProduct = getNormedDotProduct(vector1, vector2, hasREntry);
RealOpenMM angle;
if (dotProduct > (RealOpenMM) 0.99 || dotProduct < (RealOpenMM) -0.99) {
// We're close to the singularity in acos(), so take the cross product and use asin() instead. // We're close to the singularity in acos(), so take the cross product and use asin() instead.
RealOpenMM cross[3]; double cross[3];
SimTKOpenMMUtilities::crossProductVector3(vector1, vector2, cross); SimTKOpenMMUtilities::crossProductVector3(vector1, vector2, cross);
RealOpenMM scale = DOT3(vector1, vector1)*DOT3(vector2, vector2); double scale = DOT3(vector1, vector1)*DOT3(vector2, vector2);
angle = ASIN(SQRT(DOT3(cross, cross)/scale)); angle = asin(sqrt(DOT3(cross, cross)/scale));
if (dotProduct < zero) if (dotProduct < 0.0)
angle = (RealOpenMM) (M_PI-angle); angle = M_PI-angle;
} else { } else {
angle = ACOS(dotProduct); angle = acos(dotProduct);
} }
if (outputDotProduct) { if (outputDotProduct) {
...@@ -240,29 +170,20 @@ RealOpenMM ReferenceBondIxn::getAngleBetweenTwoVectors(RealOpenMM* vector1, Real ...@@ -240,29 +170,20 @@ RealOpenMM ReferenceBondIxn::getAngleBetweenTwoVectors(RealOpenMM* vector1, Real
--------------------------------------------------------------------------------------- */ --------------------------------------------------------------------------------------- */
RealOpenMM ReferenceBondIxn::getDihedralAngleBetweenThreeVectors(RealOpenMM* vector1, double ReferenceBondIxn::getDihedralAngleBetweenThreeVectors(double* vector1,
RealOpenMM* vector2, double* vector2,
RealOpenMM* vector3, double* vector3,
RealOpenMM** outputCrossProduct = NULL, double** outputCrossProduct = NULL,
RealOpenMM* cosineOfAngle = NULL, double* cosineOfAngle = NULL,
RealOpenMM* signVector = NULL, double* signVector = NULL,
RealOpenMM* signOfAngle = NULL, double* signOfAngle = NULL,
int hasREntry = 0) { int hasREntry = 0) {
// ---------------------------------------------------------------------------------------
// static const std::string methodName = "\nReferenceBondIxn::getDihedralAngleBetweenThreeVectors";
static const RealOpenMM zero = 0.0;
static const RealOpenMM one = 1.0;
RealOpenMM tempVectors[6] = { zero, zero, zero, zero, zero, zero };
// --------------------------------------------------------------------------------------- double tempVectors[6] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
// get cross products between vectors and then angle between cross product vectors // get cross products between vectors and then angle between cross product vectors
RealOpenMM* crossProduct[2]; double* crossProduct[2];
if (outputCrossProduct) { if (outputCrossProduct) {
crossProduct[0] = outputCrossProduct[0]; crossProduct[0] = outputCrossProduct[0];
crossProduct[1] = outputCrossProduct[1]; crossProduct[1] = outputCrossProduct[1];
...@@ -274,13 +195,13 @@ RealOpenMM ReferenceBondIxn::getDihedralAngleBetweenThreeVectors(RealOpenMM* ve ...@@ -274,13 +195,13 @@ RealOpenMM ReferenceBondIxn::getDihedralAngleBetweenThreeVectors(RealOpenMM* ve
SimTKOpenMMUtilities::crossProductVector3(vector1, vector2, crossProduct[0]); SimTKOpenMMUtilities::crossProductVector3(vector1, vector2, crossProduct[0]);
SimTKOpenMMUtilities::crossProductVector3(vector2, vector3, crossProduct[1]); SimTKOpenMMUtilities::crossProductVector3(vector2, vector3, crossProduct[1]);
RealOpenMM angle = getAngleBetweenTwoVectors(crossProduct[0], crossProduct[1], cosineOfAngle, 0); double angle = getAngleBetweenTwoVectors(crossProduct[0], crossProduct[1], cosineOfAngle, 0);
// take care of sign of angle // take care of sign of angle
if (signVector) { if (signVector) {
RealOpenMM dotProduct = DOT3(signVector, crossProduct[1]); double dotProduct = DOT3(signVector, crossProduct[1]);
RealOpenMM sign = dotProduct < zero ? -one : one; double sign = dotProduct < 0.0 ? -1.0 : 1.0;
if (signOfAngle) { if (signOfAngle) {
*signOfAngle = sign; *signOfAngle = sign;
} }
......
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