Skip to content

GitLab

Commit a783b996 authored by peastman's avatar peastman
Browse files

Eliminated RealOpenMM type

parent 9500f3af
Hide whitespace changes
Inline Side-by-side
Showing with 528 additions and 727 deletions
platforms/reference/include/ReferenceRbDihedralBond.h
View file @ a783b996
......@@ -34,7 +34,7 @@ class OPENMM_EXPORT ReferenceRbDihedralBond : public ReferenceBondIxn {
private:
bool usePeriodic;
RealVec boxVectors[3];
Vec3 boxVectors[3];
public:
......@@ -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 {
--------------------------------------------------------------------------------------- */
void calculateBondIxn(int* atomIndices, std::vector<OpenMM::RealVec>& atomCoordinates,
RealOpenMM* parameters, std::vector<OpenMM::RealVec>& forces,
RealOpenMM* totalEnergy, double* energyParamDerivs);
void calculateBondIxn(int* atomIndices, std::vector<OpenMM::Vec3>& atomCoordinates,
double* parameters, std::vector<OpenMM::Vec3>& forces,
double* totalEnergy, double* energyParamDerivs);
};
......
platforms/reference/include/ReferenceSETTLEAlgorithm.h
View file @ a783b996
......@@ -44,7 +44,7 @@ namespace OpenMM {
class OPENMM_EXPORT ReferenceSETTLEAlgorithm : public ReferenceConstraintAlgorithm {
public:
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.
......@@ -60,7 +60,7 @@ public:
* @param distance1 the distance between atoms 1 and 2
* @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.
*
......@@ -69,7 +69,7 @@ public:
* @param inverseMasses 1/mass
* @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.
......@@ -79,14 +79,14 @@ public:
* @param inverseMasses 1/mass
* @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:
std::vector<int> atom1;
std::vector<int> atom2;
std::vector<int> atom3;
std::vector<RealOpenMM> distance1;
std::vector<RealOpenMM> distance2;
std::vector<RealOpenMM> masses;
std::vector<double> distance1;
std::vector<double> distance2;
std::vector<double> masses;
};
} // namespace OpenMM
......
platforms/reference/include/ReferenceStochasticDynamics.h
View file @ a783b996
......@@ -34,9 +34,9 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
protected:
std::vector<OpenMM::RealVec> xPrime;
std::vector<RealOpenMM> inverseMasses;
RealOpenMM friction;
std::vector<OpenMM::Vec3> xPrime;
std::vector<double> inverseMasses;
double friction;
public:
......@@ -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 {
--------------------------------------------------------------------------------------- */
RealOpenMM getFriction() const;
double getFriction() const;
/**---------------------------------------------------------------------------------------
......@@ -82,8 +82,8 @@ class OPENMM_EXPORT ReferenceStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */
void update(const OpenMM::System& system, std::vector<OpenMM::RealVec>& atomCoordinates,
std::vector<OpenMM::RealVec>& velocities, std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, RealOpenMM tolerance);
void update(const OpenMM::System& system, std::vector<OpenMM::Vec3>& atomCoordinates,
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 {
--------------------------------------------------------------------------------------- */
virtual void updatePart1(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities,
std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& inverseMasses, std::vector<OpenMM::RealVec>& xPrime);
virtual void updatePart1(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities,
std::vector<OpenMM::Vec3>& forces, std::vector<double>& inverseMasses, std::vector<OpenMM::Vec3>& xPrime);
/**---------------------------------------------------------------------------------------
......@@ -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,
std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& inverseMasses, std::vector<OpenMM::RealVec>& xPrime);
virtual void updatePart2(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities,
std::vector<OpenMM::Vec3>& forces, std::vector<double>& inverseMasses, std::vector<OpenMM::Vec3>& xPrime);
/**---------------------------------------------------------------------------------------
......@@ -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,
std::vector<RealOpenMM>& inverseMasses, std::vector<OpenMM::RealVec>& xPrime);
virtual void updatePart3(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities,
std::vector<double>& inverseMasses, std::vector<OpenMM::Vec3>& xPrime);
};
} // namespace OpenMM
......
platforms/reference/include/ReferenceVariableStochasticDynamics.h
View file @ a783b996
......@@ -33,9 +33,9 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
private:
std::vector<OpenMM::RealVec> xPrime;
std::vector<RealOpenMM> inverseMasses;
RealOpenMM friction, _accuracy;
std::vector<OpenMM::Vec3> xPrime;
std::vector<double> inverseMasses;
double friction, _accuracy;
public:
......@@ -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 {
--------------------------------------------------------------------------------------- */
RealOpenMM getFriction() const;
double getFriction() const;
/**---------------------------------------------------------------------------------------
......@@ -76,7 +76,7 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */
RealOpenMM getAccuracy() const;
double getAccuracy() const;
/**---------------------------------------------------------------------------------------
......@@ -84,7 +84,7 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */
void setAccuracy(RealOpenMM accuracy);
void setAccuracy(double accuracy);
/**---------------------------------------------------------------------------------------
......@@ -100,8 +100,8 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */
void update(const OpenMM::System& system, std::vector<OpenMM::RealVec>& atomCoordinates,
std::vector<OpenMM::RealVec>& velocities, std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, RealOpenMM maxStepSize, RealOpenMM tolerance);
void update(const OpenMM::System& system, std::vector<OpenMM::Vec3>& atomCoordinates,
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 {
--------------------------------------------------------------------------------------- */
void updatePart1(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities,
std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, std::vector<RealOpenMM>& inverseMasses,
std::vector<OpenMM::RealVec>& xPrime, RealOpenMM maxStepSize);
void updatePart1(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities,
std::vector<OpenMM::Vec3>& forces, std::vector<double>& masses, std::vector<double>& inverseMasses,
std::vector<OpenMM::Vec3>& xPrime, double maxStepSize);
/**---------------------------------------------------------------------------------------
......@@ -134,9 +134,9 @@ class ReferenceVariableStochasticDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */
void updatePart2(int numberOfAtoms, std::vector<OpenMM::RealVec>& atomCoordinates, std::vector<OpenMM::RealVec>& velocities,
std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& inverseMasses,
std::vector<OpenMM::RealVec>& xPrime);
void updatePart2(int numberOfAtoms, std::vector<OpenMM::Vec3>& atomCoordinates, std::vector<OpenMM::Vec3>& velocities,
std::vector<OpenMM::Vec3>& forces, std::vector<double>& inverseMasses,
std::vector<OpenMM::Vec3>& xPrime);
};
......
platforms/reference/include/ReferenceVariableVerletDynamics.h
View file @ a783b996
......@@ -33,9 +33,9 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics {
private:
std::vector<OpenMM::RealVec> xPrime;
std::vector<RealOpenMM> inverseMasses;
RealOpenMM _accuracy;
std::vector<OpenMM::Vec3> xPrime;
std::vector<double> inverseMasses;
double _accuracy;
public:
......@@ -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 {
--------------------------------------------------------------------------------------- */
RealOpenMM getAccuracy() const;
double getAccuracy() const;
/**---------------------------------------------------------------------------------------
......@@ -74,7 +74,7 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */
void setAccuracy(RealOpenMM accuracy);
void setAccuracy(double accuracy);
/**---------------------------------------------------------------------------------------
......@@ -90,8 +90,8 @@ class ReferenceVariableVerletDynamics : public ReferenceDynamics {
--------------------------------------------------------------------------------------- */
void update(const OpenMM::System& system, std::vector<OpenMM::RealVec>& atomCoordinates,
std::vector<OpenMM::RealVec>& velocities, std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, RealOpenMM maxStepSize, RealOpenMM tolerance);
void update(const OpenMM::System& system, std::vector<OpenMM::Vec3>& atomCoordinates,
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 @ a783b996
......@@ -33,8 +33,8 @@ class ReferenceVerletDynamics : public ReferenceDynamics {
private:
std::vector<OpenMM::RealVec> xPrime;
std::vector<RealOpenMM> inverseMasses;
std::vector<OpenMM::Vec3> xPrime;
std::vector<double> inverseMasses;
public:
......@@ -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 {
--------------------------------------------------------------------------------------- */
void update(const OpenMM::System& system, std::vector<OpenMM::RealVec>& atomCoordinates,
std::vector<OpenMM::RealVec>& velocities, std::vector<OpenMM::RealVec>& forces, std::vector<RealOpenMM>& masses, RealOpenMM tolerance);
void update(const OpenMM::System& system, std::vector<OpenMM::Vec3>& atomCoordinates,
std::vector<OpenMM::Vec3>& velocities, std::vector<OpenMM::Vec3>& forces, std::vector<double>& masses, double tolerance);
};
......
platforms/reference/include/ReferenceVirtualSites.h
View file @ a783b996
......@@ -33,7 +33,7 @@
#define __ReferenceVirtualSites_H__
#include "openmm/System.h"
#include "RealVec.h"
#include "openmm/Vec3.h"
#include <vector>
namespace OpenMM {
......@@ -43,11 +43,11 @@ public:
/**
* 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.
*/
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
......
platforms/reference/include/SimTKOpenMMRealType.h
View file @ a783b996
/* Portions copyright (c) 2006 Stanford University and Simbios.
/* Portions copyright (c) 2006-2017 Stanford University and Simbios.
* Contributors: Pande Group
*
* Permission is hereby granted, free of charge, to any person obtaining
......@@ -28,46 +28,6 @@
#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 SQRT sqrt
#define POW pow
......@@ -98,8 +58,6 @@
#define DEGREE_TO_RADIAN 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 MATRIXDOT3(u,v) u[0]*v[0] + u[1]*v[1] + u[2]*v[2] + \
......
platforms/reference/include/SimTKOpenMMUtilities.h
View file @ a783b996
......@@ -27,7 +27,7 @@
// class of shared, static utility methods
#include "RealVec.h"
#include "SimTKOpenMMRealType.h"
#include "sfmt/SFMT.h"
#include "openmm/internal/windowsExport.h"
......@@ -49,7 +49,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
static uint32_t _randomNumberSeed;
static bool _randomInitialized;
static bool nextGaussianIsValid;
static RealOpenMM nextGaussian;
static double nextGaussian;
static OpenMM_SFMT::SFMT sfmt;
public:
......@@ -61,7 +61,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
/**---------------------------------------------------------------------------------------
Allocate 1D RealOpenMM array (Simbios)
Allocate 1D double array (Simbios)
array[i]
......@@ -75,13 +75,13 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
--------------------------------------------------------------------------------------- */
static RealOpenMM* allocateOneDRealOpenMMArray(int iSize, RealOpenMM* array1D, int initialize,
RealOpenMM initialValue,
static double* allocateOneDRealOpenMMArray(int iSize, double* array1D, int initialize,
double initialValue,
const std::string& idString = std::string("1DArray"));
/**---------------------------------------------------------------------------------------
Allocate 2D RealOpenMM array (Simbios)
Allocate 2D double array (Simbios)
array[i][j]
......@@ -96,14 +96,14 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
--------------------------------------------------------------------------------------- */
static RealOpenMM** allocateTwoDRealOpenMMArray(int iSize, int jSize,
RealOpenMM** array2D, int initialize,
RealOpenMM initialValue,
static double** allocateTwoDRealOpenMMArray(int iSize, int jSize,
double** array2D, int initialize,
double initialValue,
const std::string& idString = std::string("2DArray"));
/* ---------------------------------------------------------------------------------------
Free 2D RealOpenMM array (Simbios)
Free 2D double array (Simbios)
array[i][j]
......@@ -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"));
/* ---------------------------------------------------------------------------------------
Free 2D RealOpenMM array (Simbios)
Free 2D double array (Simbios)
array[i][j]
......@@ -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"));
/**---------------------------------------------------------------------------------------
Initialize 2D RealOpenMM array (Simbios)
Initialize 2D double array (Simbios)
array[i][j]
......@@ -143,7 +143,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
--------------------------------------------------------------------------------------- */
static void initialize2DRealOpenMMArray(int iSize, int jSize,
RealOpenMM** array2D, RealOpenMM initialValue);
double** array2D, double initialValue);
/**---------------------------------------------------------------------------------------
......@@ -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 {
--------------------------------------------------------------------------------------- */
static RealOpenMM getNormallyDistributedRandomNumber();
static double getNormallyDistributedRandomNumber();
/**---------------------------------------------------------------------------------------
......@@ -179,7 +179,7 @@ class OPENMM_EXPORT SimTKOpenMMUtilities {
--------------------------------------------------------------------------------------- */
static RealOpenMM getUniformlyDistributedRandomNumber();
static double getUniformlyDistributedRandomNumber();
/**---------------------------------------------------------------------------------------
......
platforms/reference/include/fftpack.h
View file @ a783b996
......@@ -20,7 +20,6 @@
#include <stdio.h>
#include "RealVec.h"
#include "openmm/internal/windowsExport.h"
#ifdef __cplusplus
......@@ -33,15 +32,15 @@ extern "C" {
class t_complex {
public:
RealOpenMM re;
RealOpenMM im;
double re;
double im;
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 operator*(RealOpenMM r) {
t_complex operator*(double r) {
return t_complex(re*r, im*r);
}
t_complex operator+(const t_complex& c) const {
......
platforms/reference/src/ReferenceKernels.cpp
View file @ a783b996
......@@ -94,10 +94,10 @@ static int** allocateIntArray(int length, int width) {
return array;
}
static RealOpenMM** allocateRealArray(int length, int width) {
RealOpenMM** array = new RealOpenMM*[length];
static double** allocateRealArray(int length, int width) {
double** array = new double*[length];
for (int i = 0; i < length; ++i)
array[i] = new RealOpenMM[width];
array[i] = new double[width];
return array;
}
......@@ -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) {
for (int i = 0; i < size; ++i)
delete[] array[i];
......@@ -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());
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());
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());
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());
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());
return (RealVec*) data->periodicBoxVectors;
return (Vec3*) data->periodicBoxVectors;
}
static ReferenceConstraints& extractConstraints(ContextImpl& context) {
......@@ -168,14 +168,14 @@ static void validateVariables(const Lepton::ExpressionTreeNode& node, const set<
* for a leapfrog integrator.
*/
static double computeShiftedKineticEnergy(ContextImpl& context, vector<double>& masses, double timeShift) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context);
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& velData = extractVelocities(context);
vector<Vec3>& forceData = extractForces(context);
int numParticles = context.getSystem().getNumParticles();
// Compute the shifted velocities.
vector<RealVec> shiftedVel(numParticles);
vector<Vec3> shiftedVel(numParticles);
for (int i = 0; i < numParticles; ++i) {
if (masses[i] > 0)
shiftedVel[i] = velData[i]+forceData[i]*(timeShift/masses[i]);
......@@ -203,13 +203,13 @@ void ReferenceCalcForcesAndEnergyKernel::initialize(const System& system) {
}
void ReferenceCalcForcesAndEnergyKernel::beginComputation(ContextImpl& context, bool includeForces, bool includeEnergy, int groups) {
vector<RealVec>& forceData = extractForces(context);
vector<Vec3>& forceData = extractForces(context);
if (includeForces) {
int numParticles = context.getSystem().getNumParticles();
for (int i = 0; i < numParticles; ++i) {
forceData[i][0] = (RealOpenMM) 0.0;
forceData[i][1] = (RealOpenMM) 0.0;
forceData[i][2] = (RealOpenMM) 0.0;
forceData[i][0] = 0.0;
forceData[i][1] = 0.0;
forceData[i][2] = 0.0;
}
}
else
......@@ -239,7 +239,7 @@ void ReferenceUpdateStateDataKernel::setTime(ContextImpl& context, double time)
void ReferenceUpdateStateDataKernel::getPositions(ContextImpl& context, std::vector<Vec3>& positions) {
int numParticles = context.getSystem().getNumParticles();
vector<RealVec>& posData = extractPositions(context);
vector<Vec3>& posData = extractPositions(context);
positions.resize(numParticles);
for (int i = 0; i < numParticles; ++i)
positions[i] = Vec3(posData[i][0], posData[i][1], posData[i][2]);
......@@ -247,17 +247,17 @@ void ReferenceUpdateStateDataKernel::getPositions(ContextImpl& context, std::vec
void ReferenceUpdateStateDataKernel::setPositions(ContextImpl& context, const std::vector<Vec3>& positions) {
int numParticles = context.getSystem().getNumParticles();
vector<RealVec>& posData = extractPositions(context);
vector<Vec3>& posData = extractPositions(context);
for (int i = 0; i < numParticles; ++i) {
posData[i][0] = (RealOpenMM) positions[i][0];
posData[i][1] = (RealOpenMM) positions[i][1];
posData[i][2] = (RealOpenMM) positions[i][2];
posData[i][0] = positions[i][0];
posData[i][1] = positions[i][1];
posData[i][2] = positions[i][2];
}
}
void ReferenceUpdateStateDataKernel::getVelocities(ContextImpl& context, std::vector<Vec3>& velocities) {
int numParticles = context.getSystem().getNumParticles();
vector<RealVec>& velData = extractVelocities(context);
vector<Vec3>& velData = extractVelocities(context);
velocities.resize(numParticles);
for (int i = 0; i < numParticles; ++i)
velocities[i] = Vec3(velData[i][0], velData[i][1], velData[i][2]);
......@@ -265,17 +265,17 @@ void ReferenceUpdateStateDataKernel::getVelocities(ContextImpl& context, std::ve
void ReferenceUpdateStateDataKernel::setVelocities(ContextImpl& context, const std::vector<Vec3>& velocities) {
int numParticles = context.getSystem().getNumParticles();
vector<RealVec>& velData = extractVelocities(context);
vector<Vec3>& velData = extractVelocities(context);
for (int i = 0; i < numParticles; ++i) {
velData[i][0] = (RealOpenMM) velocities[i][0];
velData[i][1] = (RealOpenMM) velocities[i][1];
velData[i][2] = (RealOpenMM) velocities[i][2];
velData[i][0] = velocities[i][0];
velData[i][1] = velocities[i][1];
velData[i][2] = velocities[i][2];
}
}
void ReferenceUpdateStateDataKernel::getForces(ContextImpl& context, std::vector<Vec3>& forces) {
int numParticles = context.getSystem().getNumParticles();
vector<RealVec>& forceData = extractForces(context);
vector<Vec3>& forceData = extractForces(context);
forces.resize(numParticles);
for (int i = 0; i < numParticles; ++i)
forces[i] = Vec3(forceData[i][0], forceData[i][1], forceData[i][2]);
......@@ -286,18 +286,18 @@ void ReferenceUpdateStateDataKernel::getEnergyParameterDerivatives(ContextImpl&
}
void ReferenceUpdateStateDataKernel::getPeriodicBoxVectors(ContextImpl& context, Vec3& a, Vec3& b, Vec3& c) const {
RealVec* vectors = extractBoxVectors(context);
Vec3* vectors = extractBoxVectors(context);
a = vectors[0];
b = vectors[1];
c = vectors[2];
}
void ReferenceUpdateStateDataKernel::setPeriodicBoxVectors(ContextImpl& context, const Vec3& a, const Vec3& b, const Vec3& c) {
RealVec& box = extractBoxSize(context);
box[0] = (RealOpenMM) a[0];
box[1] = (RealOpenMM) b[1];
box[2] = (RealOpenMM) c[2];
RealVec* vectors = extractBoxVectors(context);
Vec3& box = extractBoxSize(context);
box[0] = a[0];
box[1] = b[1];
box[2] = c[2];
Vec3* vectors = extractBoxVectors(context);
vectors[0] = a;
vectors[1] = b;
vectors[2] = c;
......@@ -307,12 +307,12 @@ void ReferenceUpdateStateDataKernel::createCheckpoint(ContextImpl& context, ostr
int version = 2;
stream.write((char*) &version, sizeof(int));
stream.write((char*) &data.time, sizeof(data.time));
vector<RealVec>& posData = extractPositions(context);
stream.write((char*) &posData[0], sizeof(RealVec)*posData.size());
vector<RealVec>& velData = extractVelocities(context);
stream.write((char*) &velData[0], sizeof(RealVec)*velData.size());
RealVec* vectors = extractBoxVectors(context);
stream.write((char*) vectors, 3*sizeof(RealVec));
vector<Vec3>& posData = extractPositions(context);
stream.write((char*) &posData[0], sizeof(Vec3)*posData.size());
vector<Vec3>& velData = extractVelocities(context);
stream.write((char*) &velData[0], sizeof(Vec3)*velData.size());
Vec3* vectors = extractBoxVectors(context);
stream.write((char*) vectors, 3*sizeof(Vec3));
SimTKOpenMMUtilities::createCheckpoint(stream);
}
......@@ -322,12 +322,12 @@ void ReferenceUpdateStateDataKernel::loadCheckpoint(ContextImpl& context, istrea
if (version != 2)
throw OpenMMException("Checkpoint was created with a different version of OpenMM");
stream.read((char*) &data.time, sizeof(data.time));
vector<RealVec>& posData = extractPositions(context);
stream.read((char*) &posData[0], sizeof(RealVec)*posData.size());
vector<RealVec>& velData = extractVelocities(context);
stream.read((char*) &velData[0], sizeof(RealVec)*velData.size());
RealVec* vectors = extractBoxVectors(context);
stream.read((char*) vectors, 3*sizeof(RealVec));
vector<Vec3>& posData = extractPositions(context);
stream.read((char*) &posData[0], sizeof(Vec3)*posData.size());
vector<Vec3>& velData = extractVelocities(context);
stream.read((char*) &velData[0], sizeof(Vec3)*velData.size());
Vec3* vectors = extractBoxVectors(context);
stream.read((char*) vectors, 3*sizeof(Vec3));
SimTKOpenMMUtilities::loadCheckpoint(stream);
}
......@@ -336,7 +336,7 @@ void ReferenceApplyConstraintsKernel::initialize(const System& system) {
masses.resize(numParticles);
inverseMasses.resize(numParticles);
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];
}
}
......@@ -345,14 +345,14 @@ ReferenceApplyConstraintsKernel::~ReferenceApplyConstraintsKernel() {
}
void ReferenceApplyConstraintsKernel::apply(ContextImpl& context, double tol) {
vector<RealVec>& positions = extractPositions(context);
vector<Vec3>& positions = extractPositions(context);
extractConstraints(context).apply(positions, positions, inverseMasses, tol);
ReferenceVirtualSites::computePositions(context.getSystem(), positions);
}
void ReferenceApplyConstraintsKernel::applyToVelocities(ContextImpl& context, double tol) {
vector<RealVec>& positions = extractPositions(context);
vector<RealVec>& velocities = extractVelocities(context);
vector<Vec3>& positions = extractPositions(context);
vector<Vec3>& velocities = extractVelocities(context);
extractConstraints(context).applyToVelocities(positions, velocities, inverseMasses, tol);
}
......@@ -360,7 +360,7 @@ void ReferenceVirtualSitesKernel::initialize(const System& system) {
}
void ReferenceVirtualSitesKernel::computePositions(ContextImpl& context) {
vector<RealVec>& positions = extractPositions(context);
vector<Vec3>& positions = extractPositions(context);
ReferenceVirtualSites::computePositions(context.getSystem(), positions);
}
......@@ -379,16 +379,16 @@ void ReferenceCalcHarmonicBondForceKernel::initialize(const System& system, cons
force.getBondParameters(i, particle1, particle2, length, k);
bondIndexArray[i][0] = particle1;
bondIndexArray[i][1] = particle2;
bondParamArray[i][0] = (RealOpenMM) length;
bondParamArray[i][1] = (RealOpenMM) k;
bondParamArray[i][0] = length;
bondParamArray[i][1] = k;
}
usePeriodic = force.usesPeriodicBoundaryConditions();
}
double ReferenceCalcHarmonicBondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
RealOpenMM energy = 0;
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
double energy = 0;
ReferenceBondForce refBondForce;
ReferenceHarmonicBondIxn harmonicBond;
if (usePeriodic)
......@@ -411,8 +411,8 @@ void ReferenceCalcHarmonicBondForceKernel::copyParametersToContext(ContextImpl&
throw OpenMMException("updateParametersInContext: The set of particles in a bond has changed");
bondIndexArray[i][0] = particle1;
bondIndexArray[i][1] = particle2;
bondParamArray[i][0] = (RealOpenMM) length;
bondParamArray[i][1] = (RealOpenMM) k;
bondParamArray[i][0] = length;
bondParamArray[i][1] = k;
}
}
......@@ -437,7 +437,7 @@ void ReferenceCalcCustomBondForceKernel::initialize(const System& system, const
bondIndexArray[i][0] = particle1;
bondIndexArray[i][1] = particle2;
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.
......@@ -462,9 +462,9 @@ void ReferenceCalcCustomBondForceKernel::initialize(const System& system, const
}
double ReferenceCalcCustomBondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
RealOpenMM energy = 0;
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
double energy = 0;
map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
......@@ -494,7 +494,7 @@ void ReferenceCalcCustomBondForceKernel::copyParametersToContext(ContextImpl& co
if (particle1 != bondIndexArray[i][0] || particle2 != bondIndexArray[i][1])
throw OpenMMException("updateParametersInContext: The set of particles in a bond has changed");
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
angleIndexArray[i][0] = particle1;
angleIndexArray[i][1] = particle2;
angleIndexArray[i][2] = particle3;
angleParamArray[i][0] = (RealOpenMM) angle;
angleParamArray[i][1] = (RealOpenMM) k;
angleParamArray[i][0] = angle;
angleParamArray[i][1] = k;
}
usePeriodic = force.usesPeriodicBoundaryConditions();
}
double ReferenceCalcHarmonicAngleForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
RealOpenMM energy = 0;
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
double energy = 0;
ReferenceBondForce refBondForce;
ReferenceAngleBondIxn angleBond;
if (usePeriodic)
......@@ -544,8 +544,8 @@ void ReferenceCalcHarmonicAngleForceKernel::copyParametersToContext(ContextImpl&
force.getAngleParameters(i, particle1, particle2, particle3, angle, k);
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");
angleParamArray[i][0] = (RealOpenMM) angle;
angleParamArray[i][1] = (RealOpenMM) k;
angleParamArray[i][0] = angle;
angleParamArray[i][1] = k;
}
}
......@@ -571,7 +571,7 @@ void ReferenceCalcCustomAngleForceKernel::initialize(const System& system, const
angleIndexArray[i][1] = particle2;
angleIndexArray[i][2] = particle3;
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.
......@@ -596,9 +596,9 @@ void ReferenceCalcCustomAngleForceKernel::initialize(const System& system, const
}
double ReferenceCalcCustomAngleForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
RealOpenMM energy = 0;
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
double energy = 0;
map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
......@@ -628,7 +628,7 @@ void ReferenceCalcCustomAngleForceKernel::copyParametersToContext(ContextImpl& c
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");
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
torsionIndexArray[i][1] = particle2;
torsionIndexArray[i][2] = particle3;
torsionIndexArray[i][3] = particle4;
torsionParamArray[i][0] = (RealOpenMM) k;
torsionParamArray[i][1] = (RealOpenMM) phase;
torsionParamArray[i][2] = (RealOpenMM) periodicity;
torsionParamArray[i][0] = k;
torsionParamArray[i][1] = phase;
torsionParamArray[i][2] = periodicity;
}
usePeriodic = force.usesPeriodicBoundaryConditions();
}
double ReferenceCalcPeriodicTorsionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
RealOpenMM energy = 0;
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
double energy = 0;
ReferenceBondForce refBondForce;
ReferenceProperDihedralBond periodicTorsionBond;
if (usePeriodic)
......@@ -680,9 +680,9 @@ void ReferenceCalcPeriodicTorsionForceKernel::copyParametersToContext(ContextImp
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])
throw OpenMMException("updateParametersInContext: The set of particles in a torsion has changed");
torsionParamArray[i][0] = (RealOpenMM) k;
torsionParamArray[i][1] = (RealOpenMM) phase;
torsionParamArray[i][2] = (RealOpenMM) periodicity;
torsionParamArray[i][0] = k;
torsionParamArray[i][1] = phase;
torsionParamArray[i][2] = periodicity;
}
}
......@@ -703,20 +703,20 @@ void ReferenceCalcRBTorsionForceKernel::initialize(const System& system, const R
torsionIndexArray[i][1] = particle2;
torsionIndexArray[i][2] = particle3;
torsionIndexArray[i][3] = particle4;
torsionParamArray[i][0] = (RealOpenMM) c0;
torsionParamArray[i][1] = (RealOpenMM) c1;
torsionParamArray[i][2] = (RealOpenMM) c2;
torsionParamArray[i][3] = (RealOpenMM) c3;
torsionParamArray[i][4] = (RealOpenMM) c4;
torsionParamArray[i][5] = (RealOpenMM) c5;
torsionParamArray[i][0] = c0;
torsionParamArray[i][1] = c1;
torsionParamArray[i][2] = c2;
torsionParamArray[i][3] = c3;
torsionParamArray[i][4] = c4;
torsionParamArray[i][5] = c5;
}
usePeriodic = force.usesPeriodicBoundaryConditions();
}
double ReferenceCalcRBTorsionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
RealOpenMM energy = 0;
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
double energy = 0;
ReferenceBondForce refBondForce;
ReferenceRbDihedralBond rbTorsionBond;
if (usePeriodic)
......@@ -737,12 +737,12 @@ void ReferenceCalcRBTorsionForceKernel::copyParametersToContext(ContextImpl& con
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])
throw OpenMMException("updateParametersInContext: The set of particles in a torsion has changed");
torsionParamArray[i][0] = (RealOpenMM) c0;
torsionParamArray[i][1] = (RealOpenMM) c1;
torsionParamArray[i][2] = (RealOpenMM) c2;
torsionParamArray[i][3] = (RealOpenMM) c3;
torsionParamArray[i][4] = (RealOpenMM) c4;
torsionParamArray[i][5] = (RealOpenMM) c5;
torsionParamArray[i][0] = c0;
torsionParamArray[i][1] = c1;
torsionParamArray[i][2] = c2;
torsionParamArray[i][3] = c3;
torsionParamArray[i][4] = c4;
torsionParamArray[i][5] = c5;
}
}
......@@ -774,9 +774,9 @@ void ReferenceCalcCMAPTorsionForceKernel::initialize(const System& system, const
}
double ReferenceCalcCMAPTorsionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
RealOpenMM totalEnergy = 0;
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
double totalEnergy = 0;
ReferenceCMAPTorsionIxn torsion(coeff, torsionMaps, torsionIndices);
if (usePeriodic)
torsion.setPeriodic(extractBoxVectors(context));
......@@ -841,7 +841,7 @@ void ReferenceCalcCustomTorsionForceKernel::initialize(const System& system, con
torsionIndexArray[i][2] = particle3;
torsionIndexArray[i][3] = particle4;
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.
......@@ -866,9 +866,9 @@ void ReferenceCalcCustomTorsionForceKernel::initialize(const System& system, con
}
double ReferenceCalcCustomTorsionForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
RealOpenMM energy = 0;
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
double energy = 0;
map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
......@@ -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])
throw OpenMMException("updateParametersInContext: The set of particles in a torsion has changed");
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
for (int i = 0; i < numParticles; ++i) {
double charge, radius, depth;
force.getParticleParameters(i, charge, radius, depth);
particleParamArray[i][0] = static_cast<RealOpenMM>(0.5*radius);
particleParamArray[i][1] = static_cast<RealOpenMM>(2.0*sqrt(depth));
particleParamArray[i][2] = static_cast<RealOpenMM>(charge);
particleParamArray[i][0] = 0.5*radius;
particleParamArray[i][1] = 2.0*sqrt(depth);
particleParamArray[i][2] = charge;
}
this->exclusions = exclusions;
for (int i = 0; i < num14; ++i) {
......@@ -947,12 +947,12 @@ void ReferenceCalcNonbondedForceKernel::initialize(const System& system, const N
force.getExceptionParameters(nb14s[i], particle1, particle2, charge, radius, depth);
bonded14IndexArray[i][0] = particle1;
bonded14IndexArray[i][1] = particle2;
bonded14ParamArray[i][0] = static_cast<RealOpenMM>(radius);
bonded14ParamArray[i][1] = static_cast<RealOpenMM>(4.0*depth);
bonded14ParamArray[i][2] = static_cast<RealOpenMM>(charge);
bonded14ParamArray[i][0] = radius;
bonded14ParamArray[i][1] = 4.0*depth;
bonded14ParamArray[i][2] = charge;
}
nonbondedMethod = CalcNonbondedForceKernel::NonbondedMethod(force.getNonbondedMethod());
nonbondedCutoff = (RealOpenMM) force.getCutoffDistance();
nonbondedCutoff = force.getCutoffDistance();
if (nonbondedMethod == NoCutoff) {
neighborList = NULL;
useSwitchingFunction = false;
......@@ -965,14 +965,14 @@ void ReferenceCalcNonbondedForceKernel::initialize(const System& system, const N
if (nonbondedMethod == Ewald) {
double alpha;
NonbondedForceImpl::calcEwaldParameters(system, force, alpha, kmax[0], kmax[1], kmax[2]);
ewaldAlpha = (RealOpenMM) alpha;
ewaldAlpha = alpha;
}
else if (nonbondedMethod == PME) {
double alpha;
NonbondedForceImpl::calcPMEParameters(system, force, alpha, gridSize[0], gridSize[1], gridSize[2]);
ewaldAlpha = (RealOpenMM) alpha;
ewaldAlpha = alpha;
}
rfDielectric = (RealOpenMM)force.getReactionFieldDielectric();
rfDielectric = force.getReactionFieldDielectric();
if (force.getUseDispersionCorrection())
dispersionCoefficient = NonbondedForceImpl::calcDispersionCorrection(system, force);
else
......@@ -980,9 +980,9 @@ void ReferenceCalcNonbondedForceKernel::initialize(const System& system, const N
}
double ReferenceCalcNonbondedForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy, bool includeDirect, bool includeReciprocal) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
RealOpenMM energy = 0;
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
double energy = 0;
ReferenceLJCoulombIxn clj;
bool periodic = (nonbondedMethod == CutoffPeriodic);
bool ewald = (nonbondedMethod == Ewald);
......@@ -992,7 +992,7 @@ double ReferenceCalcNonbondedForceKernel::execute(ContextImpl& context, bool inc
clj.setUseCutoff(nonbondedCutoff, *neighborList, rfDielectric);
}
if (periodic || ewald || pme) {
RealVec* boxVectors = extractBoxVectors(context);
Vec3* boxVectors = extractBoxVectors(context);
double minAllowedSize = 1.999999*nonbondedCutoff;
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.");
......@@ -1010,7 +1010,7 @@ double ReferenceCalcNonbondedForceKernel::execute(ContextImpl& context, bool inc
ReferenceLJCoulomb14 nonbonded14;
refBondForce.calculateForce(num14, bonded14IndexArray, posData, bonded14ParamArray, forceData, includeEnergy ? &energy : NULL, nonbonded14);
if (periodic || ewald || pme) {
RealVec* boxVectors = extractBoxVectors(context);
Vec3* boxVectors = extractBoxVectors(context);
energy += dispersionCoefficient/(boxVectors[0][0]*boxVectors[1][1]*boxVectors[2][2]);
}
}
......@@ -1036,9 +1036,9 @@ void ReferenceCalcNonbondedForceKernel::copyParametersToContext(ContextImpl& con
for (int i = 0; i < numParticles; ++i) {
double charge, radius, depth;
force.getParticleParameters(i, charge, radius, depth);
particleParamArray[i][0] = static_cast<RealOpenMM>(0.5*radius);
particleParamArray[i][1] = static_cast<RealOpenMM>(2.0*sqrt(depth));
particleParamArray[i][2] = static_cast<RealOpenMM>(charge);
particleParamArray[i][0] = 0.5*radius;
particleParamArray[i][1] = 2.0*sqrt(depth);
particleParamArray[i][2] = charge;
}
for (int i = 0; i < num14; ++i) {
int particle1, particle2;
......@@ -1046,9 +1046,9 @@ void ReferenceCalcNonbondedForceKernel::copyParametersToContext(ContextImpl& con
force.getExceptionParameters(nb14s[i], particle1, particle2, charge, radius, depth);
bonded14IndexArray[i][0] = particle1;
bonded14IndexArray[i][1] = particle2;
bonded14ParamArray[i][0] = static_cast<RealOpenMM>(radius);
bonded14ParamArray[i][1] = static_cast<RealOpenMM>(4.0*depth);
bonded14ParamArray[i][2] = static_cast<RealOpenMM>(charge);
bonded14ParamArray[i][0] = radius;
bonded14ParamArray[i][1] = 4.0*depth;
bonded14ParamArray[i][2] = charge;
}
// Recompute the coefficient for the dispersion correction.
......@@ -1096,10 +1096,10 @@ void ReferenceCalcCustomNonbondedForceKernel::initialize(const System& system, c
vector<double> parameters;
force.getParticleParameters(i, parameters);
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());
nonbondedCutoff = (RealOpenMM) force.getCutoffDistance();
nonbondedCutoff = force.getCutoffDistance();
if (nonbondedMethod == NoCutoff) {
neighborList = NULL;
useSwitchingFunction = false;
......@@ -1167,10 +1167,10 @@ void ReferenceCalcCustomNonbondedForceKernel::initialize(const System& system, c
}
double ReferenceCalcCustomNonbondedForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
RealVec* boxVectors = extractBoxVectors(context);
RealOpenMM energy = 0;
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
Vec3* boxVectors = extractBoxVectors(context);
double energy = 0;
ReferenceCustomNonbondedIxn ixn(energyExpression, forceExpression, parameterNames, energyParamDerivExpressions);
bool periodic = (nonbondedMethod == CutoffPeriodic);
if (nonbondedMethod != NoCutoff) {
......@@ -1225,7 +1225,7 @@ void ReferenceCalcCustomNonbondedForceKernel::copyParametersToContext(ContextImp
vector<double> parameters;
force.getParticleParameters(i, parameters);
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.
......@@ -1247,31 +1247,31 @@ ReferenceCalcGBSAOBCForceKernel::~ReferenceCalcGBSAOBCForceKernel() {
void ReferenceCalcGBSAOBCForceKernel::initialize(const System& system, const GBSAOBCForce& force) {
int numParticles = system.getNumParticles();
charges.resize(numParticles);
vector<RealOpenMM> atomicRadii(numParticles);
vector<RealOpenMM> scaleFactors(numParticles);
vector<double> atomicRadii(numParticles);
vector<double> scaleFactors(numParticles);
for (int i = 0; i < numParticles; ++i) {
double charge, radius, scalingFactor;
force.getParticleParameters(i, charge, radius, scalingFactor);
charges[i] = static_cast<RealOpenMM>(charge);
atomicRadii[i] = static_cast<RealOpenMM>(radius);
scaleFactors[i] = static_cast<RealOpenMM>(scalingFactor);
charges[i] = charge;
atomicRadii[i] = radius;
scaleFactors[i] = scalingFactor;
}
ObcParameters* obcParameters = new ObcParameters(numParticles, ObcParameters::ObcTypeII);
obcParameters->setAtomicRadii(atomicRadii);
obcParameters->setScaledRadiusFactors(scaleFactors);
obcParameters->setSolventDielectric(static_cast<RealOpenMM>(force.getSolventDielectric()));
obcParameters->setSoluteDielectric(static_cast<RealOpenMM>(force.getSoluteDielectric()));
obcParameters->setSolventDielectric(force.getSolventDielectric());
obcParameters->setSoluteDielectric(force.getSoluteDielectric());
obcParameters->setPi4Asolv(4*M_PI*force.getSurfaceAreaEnergy());
if (force.getNonbondedMethod() != GBSAOBCForce::NoCutoff)
obcParameters->setUseCutoff(static_cast<RealOpenMM>(force.getCutoffDistance()));
obcParameters->setUseCutoff(force.getCutoffDistance());
isPeriodic = (force.getNonbondedMethod() == GBSAOBCForce::CutoffPeriodic);
obc = new ReferenceObc(obcParameters);
obc->setIncludeAceApproximation(true);
}
double ReferenceCalcGBSAOBCForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
if (isPeriodic)
obc->getObcParameters()->setPeriodic(extractBoxVectors(context));
return obc->computeBornEnergyForces(posData, charges, forceData);
......@@ -1285,14 +1285,14 @@ void ReferenceCalcGBSAOBCForceKernel::copyParametersToContext(ContextImpl& conte
// Record the values.
vector<RealOpenMM> atomicRadii(numParticles);
vector<RealOpenMM> scaleFactors(numParticles);
vector<double> atomicRadii(numParticles);
vector<double> scaleFactors(numParticles);
for (int i = 0; i < numParticles; ++i) {
double charge, radius, scalingFactor;
force.getParticleParameters(i, charge, radius, scalingFactor);
charges[i] = (RealOpenMM) charge;
atomicRadii[i] = (RealOpenMM) radius;
scaleFactors[i] = (RealOpenMM) scalingFactor;
charges[i] = charge;
atomicRadii[i] = radius;
scaleFactors[i] = scalingFactor;
}
obcParameters->setAtomicRadii(atomicRadii);
obcParameters->setScaledRadiusFactors(scaleFactors);
......@@ -1337,14 +1337,14 @@ void ReferenceCalcCustomGBForceKernel::initialize(const System& system, const Cu
vector<double> parameters;
force.getParticleParameters(i, parameters);
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++)
particleParameterNames.push_back(force.getPerParticleParameterName(i));
for (int i = 0; i < force.getNumGlobalParameters(); i++)
globalParameterNames.push_back(force.getGlobalParameterName(i));
nonbondedMethod = CalcCustomGBForceKernel::NonbondedMethod(force.getNonbondedMethod());
nonbondedCutoff = (RealOpenMM) force.getCutoffDistance();
nonbondedCutoff = force.getCutoffDistance();
if (nonbondedMethod == NoCutoff)
neighborList = NULL;
else
......@@ -1442,9 +1442,9 @@ void ReferenceCalcCustomGBForceKernel::initialize(const System& system, const Cu
}
double ReferenceCalcCustomGBForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
RealOpenMM energy = 0;
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
double energy = 0;
ReferenceCustomGBIxn ixn(valueExpressions, valueDerivExpressions, valueGradientExpressions, valueParamDerivExpressions, valueNames, valueTypes,
energyExpressions, energyDerivExpressions, energyGradientExpressions, energyParamDerivExpressions, energyTypes, particleParameterNames);
bool periodic = (nonbondedMethod == CutoffPeriodic);
......@@ -1477,11 +1477,11 @@ void ReferenceCalcCustomGBForceKernel::copyParametersToContext(ContextImpl& cont
vector<double> parameters;
force.getParticleParameters(i, parameters);
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 {
......@@ -1489,8 +1489,8 @@ int ReferenceCalcCustomExternalForceKernel::PeriodicDistanceFunction::getNumArgu
}
double ReferenceCalcCustomExternalForceKernel::PeriodicDistanceFunction::evaluate(const double* arguments) const {
RealVec* boxVectors = *boxVectorHandle;
RealVec delta = RealVec(arguments[0], arguments[1], arguments[2])-RealVec(arguments[3], arguments[4], arguments[5]);
Vec3* boxVectors = *boxVectorHandle;
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[1]*floor(delta[1]/boxVectors[1][1]+0.5);
delta -= boxVectors[0]*floor(delta[0]/boxVectors[0][0]+0.5);
......@@ -1506,8 +1506,8 @@ double ReferenceCalcCustomExternalForceKernel::PeriodicDistanceFunction::evaluat
argIndex = i;
}
}
RealVec* boxVectors = *boxVectorHandle;
RealVec delta = RealVec(arguments[0], arguments[1], arguments[2])-RealVec(arguments[3], arguments[4], arguments[5]);
Vec3* boxVectors = *boxVectorHandle;
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[1]*floor(delta[1]/boxVectors[1][1]+0.5);
delta -= boxVectors[0]*floor(delta[0]/boxVectors[0][0]+0.5);
......@@ -1539,7 +1539,7 @@ void ReferenceCalcCustomExternalForceKernel::initialize(const System& system, co
for (int i = 0; i < numParticles; ++i) {
force.getParticleParameters(i, particles[i], params);
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.
......@@ -1566,10 +1566,10 @@ void ReferenceCalcCustomExternalForceKernel::initialize(const System& system, co
}
double ReferenceCalcCustomExternalForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
boxVectors = extractBoxVectors(context);
RealOpenMM energy = 0;
double energy = 0;
map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
......@@ -1594,7 +1594,7 @@ void ReferenceCalcCustomExternalForceKernel::copyParametersToContext(ContextImpl
if (particle != particles[i])
throw OpenMMException("updateParametersInContext: A particle index has changed");
for (int j = 0; j < numParameters; j++)
particleParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]);
particleParamArray[i][j] = parameters[j];
}
}
......@@ -1632,7 +1632,7 @@ void ReferenceCalcCustomHbondForceKernel::initialize(const System& system, const
donorParticles[i].push_back(d2);
donorParticles[i].push_back(d3);
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);
int numAcceptorParameters = force.getNumPerAcceptorParameters();
......@@ -1645,10 +1645,10 @@ void ReferenceCalcCustomHbondForceKernel::initialize(const System& system, const
acceptorParticles[i].push_back(a2);
acceptorParticles[i].push_back(a3);
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());
nonbondedCutoff = (RealOpenMM) force.getCutoffDistance();
nonbondedCutoff = force.getCutoffDistance();
// Create custom functions for the tabulated functions.
......@@ -1682,11 +1682,11 @@ void ReferenceCalcCustomHbondForceKernel::initialize(const System& system, const
}
double ReferenceCalcCustomHbondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
if (isPeriodic)
ixn->setPeriodic(extractBoxVectors(context));
RealOpenMM energy = 0;
double energy = 0;
map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
......@@ -1711,7 +1711,7 @@ void ReferenceCalcCustomHbondForceKernel::copyParametersToContext(ContextImpl& c
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");
for (int j = 0; j < numDonorParameters; j++)
donorParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]);
donorParamArray[i][j] = parameters[j];
}
int numAcceptorParameters = force.getNumPerAcceptorParameters();
const vector<vector<int> >& acceptorAtoms = ixn->getAcceptorAtoms();
......@@ -1721,7 +1721,7 @@ void ReferenceCalcCustomHbondForceKernel::copyParametersToContext(ContextImpl& c
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");
for (int j = 0; j < numAcceptorParameters; j++)
acceptorParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]);
acceptorParamArray[i][j] = parameters[j];
}
}
......@@ -1751,7 +1751,7 @@ void ReferenceCalcCustomCentroidBondForceKernel::initialize(const System& system
vector<double> parameters;
force.getBondParameters(i, bondGroups[i], parameters);
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.
......@@ -1786,9 +1786,9 @@ void ReferenceCalcCustomCentroidBondForceKernel::initialize(const System& system
}
double ReferenceCalcCustomCentroidBondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
RealOpenMM energy = 0;
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
double energy = 0;
map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
......@@ -1818,7 +1818,7 @@ void ReferenceCalcCustomCentroidBondForceKernel::copyParametersToContext(Context
if (groups[j] != bondGroups[i][j])
throw OpenMMException("updateParametersInContext: The set of groups in a bond has changed");
for (int j = 0; j < numParameters; j++)
bondParamArray[i][j] = (RealOpenMM) params[j];
bondParamArray[i][j] = params[j];
}
}
......@@ -1841,7 +1841,7 @@ void ReferenceCalcCustomCompoundBondForceKernel::initialize(const System& system
vector<double> parameters;
force.getBondParameters(i, bondParticles[i], parameters);
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.
......@@ -1876,9 +1876,9 @@ void ReferenceCalcCustomCompoundBondForceKernel::initialize(const System& system
}
double ReferenceCalcCustomCompoundBondForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
RealOpenMM energy = 0;
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
double energy = 0;
map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
......@@ -1908,7 +1908,7 @@ void ReferenceCalcCustomCompoundBondForceKernel::copyParametersToContext(Context
if (particles[j] != bondAtoms[i][j])
throw OpenMMException("updateParametersInContext: The set of particles in a bond has changed");
for (int j = 0; j < numParameters; j++)
bondParamArray[i][j] = (RealOpenMM) params[j];
bondParamArray[i][j] = params[j];
}
}
......@@ -1940,14 +1940,14 @@ void ReferenceCalcCustomManyParticleForceKernel::initialize(const System& system
}
double ReferenceCalcCustomManyParticleForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& forceData = extractForces(context);
RealOpenMM energy = 0;
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& forceData = extractForces(context);
double energy = 0;
map<string, double> globalParameters;
for (int i = 0; i < (int) globalParameterNames.size(); i++)
globalParameters[globalParameterNames[i]] = context.getParameter(globalParameterNames[i]);
if (nonbondedMethod == CutoffPeriodic) {
RealVec* boxVectors = extractBoxVectors(context);
Vec3* boxVectors = extractBoxVectors(context);
double minAllowedSize = 2*cutoffDistance;
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.");
......@@ -1970,7 +1970,7 @@ void ReferenceCalcCustomManyParticleForceKernel::copyParametersToContext(Context
int type;
force.getParticleParameters(i, parameters, type);
for (int j = 0; j < numParameters; j++)
particleParamArray[i][j] = static_cast<RealOpenMM>(parameters[j]);
particleParamArray[i][j] = parameters[j];
}
}
......@@ -2002,20 +2002,20 @@ void ReferenceIntegrateVerletStepKernel::initialize(const System& system, const
int numParticles = system.getNumParticles();
masses.resize(numParticles);
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) {
double stepSize = integrator.getStepSize();
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context);
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& velData = extractVelocities(context);
vector<Vec3>& forceData = extractForces(context);
if (dynamics == 0 || stepSize != prevStepSize) {
// Recreate the computation objects with the new parameters.
if (dynamics)
delete dynamics;
dynamics = new ReferenceVerletDynamics(context.getSystem().getNumParticles(), static_cast<RealOpenMM>(stepSize));
dynamics = new ReferenceVerletDynamics(context.getSystem().getNumParticles(), stepSize);
dynamics->setReferenceConstraintAlgorithm(&extractConstraints(context));
prevStepSize = stepSize;
}
......@@ -2037,7 +2037,7 @@ void ReferenceIntegrateLangevinStepKernel::initialize(const System& system, cons
int numParticles = system.getNumParticles();
masses.resize(numParticles);
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());
}
......@@ -2045,9 +2045,9 @@ void ReferenceIntegrateLangevinStepKernel::execute(ContextImpl& context, const L
double temperature = integrator.getTemperature();
double friction = integrator.getFriction();
double stepSize = integrator.getStepSize();
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context);
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& velData = extractVelocities(context);
vector<Vec3>& forceData = extractForces(context);
if (dynamics == 0 || temperature != prevTemp || friction != prevFriction || stepSize != prevStepSize) {
// Recreate the computation objects with the new parameters.
......@@ -2055,9 +2055,9 @@ void ReferenceIntegrateLangevinStepKernel::execute(ContextImpl& context, const L
delete dynamics;
dynamics = new ReferenceStochasticDynamics(
context.getSystem().getNumParticles(),
static_cast<RealOpenMM>(stepSize),
static_cast<RealOpenMM>(friction),
static_cast<RealOpenMM>(temperature));
stepSize,
friction,
temperature);
dynamics->setReferenceConstraintAlgorithm(&extractConstraints(context));
prevTemp = temperature;
prevFriction = friction;
......@@ -2081,7 +2081,7 @@ void ReferenceIntegrateBrownianStepKernel::initialize(const System& system, cons
int numParticles = system.getNumParticles();
masses.resize(numParticles);
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());
}
......@@ -2089,9 +2089,9 @@ void ReferenceIntegrateBrownianStepKernel::execute(ContextImpl& context, const B
double temperature = integrator.getTemperature();
double friction = integrator.getFriction();
double stepSize = integrator.getStepSize();
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context);
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& velData = extractVelocities(context);
vector<Vec3>& forceData = extractForces(context);
if (dynamics == 0 || temperature != prevTemp || friction != prevFriction || stepSize != prevStepSize) {
// Recreate the computation objects with the new parameters.
......@@ -2099,9 +2099,9 @@ void ReferenceIntegrateBrownianStepKernel::execute(ContextImpl& context, const B
delete dynamics;
dynamics = new ReferenceBrownianDynamics(
context.getSystem().getNumParticles(),
static_cast<RealOpenMM>(stepSize),
static_cast<RealOpenMM>(friction),
static_cast<RealOpenMM>(temperature));
stepSize,
friction,
temperature);
dynamics->setReferenceConstraintAlgorithm(&extractConstraints(context));
prevTemp = temperature;
prevFriction = friction;
......@@ -2125,7 +2125,7 @@ void ReferenceIntegrateVariableLangevinStepKernel::initialize(const System& syst
int numParticles = system.getNumParticles();
masses.resize(numParticles);
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());
}
......@@ -2133,21 +2133,21 @@ double ReferenceIntegrateVariableLangevinStepKernel::execute(ContextImpl& contex
double temperature = integrator.getTemperature();
double friction = integrator.getFriction();
double errorTol = integrator.getErrorTolerance();
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context);
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& velData = extractVelocities(context);
vector<Vec3>& forceData = extractForces(context);
if (dynamics == 0 || temperature != prevTemp || friction != prevFriction || errorTol != prevErrorTol) {
// Recreate the computation objects with the new parameters.
if (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));
prevTemp = temperature;
prevFriction = friction;
prevErrorTol = errorTol;
}
RealOpenMM maxStepSize = (RealOpenMM) (maxTime-data.time);
double maxStepSize = maxTime-data.time;
dynamics->update(context.getSystem(), posData, velData, forceData, masses, maxStepSize, integrator.getConstraintTolerance());
data.time += dynamics->getDeltaT();
if (dynamics->getDeltaT() == maxStepSize)
......@@ -2169,24 +2169,24 @@ void ReferenceIntegrateVariableVerletStepKernel::initialize(const System& system
int numParticles = system.getNumParticles();
masses.resize(numParticles);
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 errorTol = integrator.getErrorTolerance();
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context);
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& velData = extractVelocities(context);
vector<Vec3>& forceData = extractForces(context);
if (dynamics == 0 || errorTol != prevErrorTol) {
// Recreate the computation objects with the new parameters.
if (dynamics)
delete dynamics;
dynamics = new ReferenceVariableVerletDynamics(context.getSystem().getNumParticles(), (RealOpenMM) errorTol);
dynamics = new ReferenceVariableVerletDynamics(context.getSystem().getNumParticles(), errorTol);
dynamics->setReferenceConstraintAlgorithm(&extractConstraints(context));
prevErrorTol = errorTol;
}
RealOpenMM maxStepSize = (RealOpenMM) (maxTime-data.time);
double maxStepSize = maxTime-data.time;
dynamics->update(context.getSystem(), posData, velData, forceData, masses, maxStepSize, integrator.getConstraintTolerance());
data.time += dynamics->getDeltaT();
if (dynamics->getDeltaT() == maxStepSize)
......@@ -2208,7 +2208,7 @@ void ReferenceIntegrateCustomStepKernel::initialize(const System& system, const
int numParticles = system.getNumParticles();
masses.resize(numParticles);
for (int i = 0; i < numParticles; ++i)
masses[i] = static_cast<RealOpenMM>(system.getParticleMass(i));
masses[i] = system.getParticleMass(i);
perDofValues.resize(integrator.getNumPerDofVariables());
for (int i = 0; i < (int) perDofValues.size(); i++)
perDofValues[i].resize(numParticles);
......@@ -2220,9 +2220,9 @@ void ReferenceIntegrateCustomStepKernel::initialize(const System& system, const
}
void ReferenceIntegrateCustomStepKernel::execute(ContextImpl& context, CustomIntegrator& integrator, bool& forcesAreValid) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context);
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& velData = extractVelocities(context);
vector<Vec3>& forceData = extractForces(context);
// Record global variables.
......@@ -2246,9 +2246,9 @@ void ReferenceIntegrateCustomStepKernel::execute(ContextImpl& context, CustomInt
}
double ReferenceIntegrateCustomStepKernel::computeKineticEnergy(ContextImpl& context, CustomIntegrator& integrator, bool& forcesAreValid) {
vector<RealVec>& posData = extractPositions(context);
vector<RealVec>& velData = extractVelocities(context);
vector<RealVec>& forceData = extractForces(context);
vector<Vec3>& posData = extractPositions(context);
vector<Vec3>& velData = extractVelocities(context);
vector<Vec3>& forceData = extractForces(context);
// Record global variables.
......@@ -2291,18 +2291,18 @@ void ReferenceApplyAndersenThermostatKernel::initialize(const System& system, co
int numParticles = system.getNumParticles();
masses.resize(numParticles);
for (int i = 0; i < numParticles; ++i)
masses[i] = static_cast<RealOpenMM>(system.getParticleMass(i));
masses[i] = system.getParticleMass(i);
this->thermostat = new ReferenceAndersenThermostat();
SimTKOpenMMUtilities::setRandomNumberSeed((unsigned int) thermostat.getRandomNumberSeed());
particleGroups = AndersenThermostatImpl::calcParticleGroups(system);
}
void ReferenceApplyAndersenThermostatKernel::execute(ContextImpl& context) {
vector<RealVec>& velData = extractVelocities(context);
vector<Vec3>& velData = extractVelocities(context);
thermostat->applyThermostat(particleGroups, velData, masses,
static_cast<RealOpenMM>(context.getParameter(AndersenThermostat::Temperature())),
static_cast<RealOpenMM>(context.getParameter(AndersenThermostat::CollisionFrequency())),
static_cast<RealOpenMM>(context.getIntegrator().getStepSize()));
context.getParameter(AndersenThermostat::Temperature()),
context.getParameter(AndersenThermostat::CollisionFrequency()),
context.getIntegrator().getStepSize());
}
ReferenceApplyMonteCarloBarostatKernel::~ReferenceApplyMonteCarloBarostatKernel() {
......@@ -2316,13 +2316,13 @@ void ReferenceApplyMonteCarloBarostatKernel::initialize(const System& system, co
void ReferenceApplyMonteCarloBarostatKernel::scaleCoordinates(ContextImpl& context, double scaleX, double scaleY, double scaleZ) {
if (barostat == NULL)
barostat = new ReferenceMonteCarloBarostat(context.getSystem().getNumParticles(), context.getMolecules());
vector<RealVec>& posData = extractPositions(context);
RealVec* boxVectors = extractBoxVectors(context);
vector<Vec3>& posData = extractPositions(context);
Vec3* boxVectors = extractBoxVectors(context);
barostat->applyBarostat(posData, boxVectors, scaleX, scaleY, scaleZ);
}
void ReferenceApplyMonteCarloBarostatKernel::restoreCoordinates(ContextImpl& context) {
vector<RealVec>& posData = extractPositions(context);
vector<Vec3>& posData = extractPositions(context);
barostat->restorePositions(posData);
}
......@@ -2336,17 +2336,17 @@ void ReferenceRemoveCMMotionKernel::initialize(const System& system, const CMMot
void ReferenceRemoveCMMotionKernel::execute(ContextImpl& context) {
if (data.stepCount%frequency != 0)
return;
vector<RealVec>& velData = extractVelocities(context);
vector<Vec3>& velData = extractVelocities(context);
// Calculate the center of mass momentum.
RealOpenMM momentum[] = {0.0, 0.0, 0.0};
RealOpenMM mass = 0.0;
double momentum[] = {0.0, 0.0, 0.0};
double mass = 0.0;
for (size_t i = 0; i < masses.size(); ++i) {
momentum[0] += static_cast<RealOpenMM>(masses[i]*velData[i][0]);
momentum[1] += static_cast<RealOpenMM>(masses[i]*velData[i][1]);
momentum[2] += static_cast<RealOpenMM>(masses[i]*velData[i][2]);
mass += static_cast<RealOpenMM>(masses[i]);
momentum[0] += masses[i]*velData[i][0];
momentum[1] += masses[i]*velData[i][1];
momentum[2] += masses[i]*velData[i][2];
mass += masses[i];
}
// Adjust the particle velocities.
......
platforms/reference/src/ReferencePlatform.cpp
View file @ a783b996
......@@ -35,7 +35,7 @@
#include "ReferenceKernels.h"
#include "openmm/internal/ContextImpl.h"
#include "SimTKOpenMMRealType.h"
#include "RealVec.h"
#include "openmm/Vec3.h"
#include <map>
#include <vector>
......@@ -82,7 +82,7 @@ double ReferencePlatform::getSpeed() const {
}
bool ReferencePlatform::supportsDoublePrecision() const {
return (sizeof(RealOpenMM) >= sizeof(double));
return true;
}
void ReferencePlatform::contextCreated(ContextImpl& context, const map<string, string>& properties) 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()) {
positions = new vector<RealVec>(numParticles);
velocities = new vector<RealVec>(numParticles);
forces = new vector<RealVec>(numParticles);
periodicBoxSize = new RealVec();
periodicBoxVectors = new RealVec[3];
positions = new vector<Vec3>(numParticles);
velocities = new vector<Vec3>(numParticles);
forces = new vector<Vec3>(numParticles);
periodicBoxSize = new Vec3();
periodicBoxVectors = new Vec3[3];
constraints = new ReferenceConstraints(system);
energyParameterDerivatives = new map<string, double>();
}
ReferencePlatform::PlatformData::~PlatformData() {
delete (vector<RealVec>*) positions;
delete (vector<RealVec>*) velocities;
delete (vector<RealVec>*) forces;
delete (RealVec*) periodicBoxSize;
delete[] (RealVec*) periodicBoxVectors;
delete (vector<Vec3>*) positions;
delete (vector<Vec3>*) velocities;
delete (vector<Vec3>*) forces;
delete (Vec3*) periodicBoxSize;
delete[] (Vec3*) periodicBoxVectors;
delete (ReferenceConstraints*) constraints;
delete (map<string, double>*) energyParameterDerivatives;
}
platforms/reference/src/SimTKReference/ObcParameters.cpp
View file @ a783b996
......@@ -28,6 +28,7 @@
#include "openmm/OpenMMException.h"
#include "ObcParameters.h"
#include "SimTKOpenMMRealType.h"
using std::vector;
using namespace OpenMM;
......@@ -121,7 +122,7 @@ void ObcParameters::setObcTypeParameters(ObcParameters::ObcType obcType) {
--------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getDielectricOffset() const {
double ObcParameters::getDielectricOffset() const {
return _dielectricOffset;
}
......@@ -133,7 +134,7 @@ RealOpenMM ObcParameters::getDielectricOffset() const {
--------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getAlphaObc() const {
double ObcParameters::getAlphaObc() const {
return _alphaObc;
}
......@@ -145,7 +146,7 @@ RealOpenMM ObcParameters::getAlphaObc() const {
--------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getBetaObc() const {
double ObcParameters::getBetaObc() const {
return _betaObc;
}
......@@ -157,7 +158,7 @@ RealOpenMM ObcParameters::getBetaObc() const {
--------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getGammaObc() const {
double ObcParameters::getGammaObc() const {
return _gammaObc;
}
......@@ -169,7 +170,7 @@ RealOpenMM ObcParameters::getGammaObc() const {
--------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getSolventDielectric() const {
double ObcParameters::getSolventDielectric() const {
return _solventDielectric;
}
......@@ -181,7 +182,7 @@ RealOpenMM ObcParameters::getSolventDielectric() const {
--------------------------------------------------------------------------------------- */
void ObcParameters::setSolventDielectric(RealOpenMM solventDielectric) {
void ObcParameters::setSolventDielectric(double solventDielectric) {
_solventDielectric = solventDielectric;
}
/**---------------------------------------------------------------------------------------
......@@ -192,7 +193,7 @@ void ObcParameters::setSolventDielectric(RealOpenMM solventDielectric) {
--------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getSoluteDielectric() const {
double ObcParameters::getSoluteDielectric() const {
return _soluteDielectric;
}
......@@ -204,7 +205,7 @@ RealOpenMM ObcParameters::getSoluteDielectric() const {
--------------------------------------------------------------------------------------- */
void ObcParameters::setSoluteDielectric(RealOpenMM soluteDielectric) {
void ObcParameters::setSoluteDielectric(double soluteDielectric) {
_soluteDielectric = soluteDielectric;
}
......@@ -216,7 +217,7 @@ void ObcParameters::setSoluteDielectric(RealOpenMM soluteDielectric) {
--------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getElectricConstant() const {
double ObcParameters::getElectricConstant() const {
return _electricConstant;
}
......@@ -228,7 +229,7 @@ RealOpenMM ObcParameters::getElectricConstant() const {
--------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getProbeRadius() const {
double ObcParameters::getProbeRadius() const {
return _probeRadius;
}
......@@ -240,25 +241,25 @@ RealOpenMM ObcParameters::getProbeRadius() const {
--------------------------------------------------------------------------------------- */
void ObcParameters::setProbeRadius(RealOpenMM probeRadius) {
void ObcParameters::setProbeRadius(double probeRadius) {
_probeRadius = probeRadius;
}
/**---------------------------------------------------------------------------------------
Get pi*4*Asolv: used in ACE approximation for nonpolar term
((RealOpenMM) M_PI)*4.0f*0.0049*1000.0; (Still)
((RealOpenMM) M_PI)*4.0f*0.0054*1000.0; (OBC)
M_PI*4.0f*0.0049*1000.0; (Still)
M_PI*4.0f*0.0054*1000.0; (OBC)
@return pi4Asolv
--------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getPi4Asolv() const {
double ObcParameters::getPi4Asolv() const {
return _pi4Asolv;
}
void ObcParameters::setPi4Asolv(RealOpenMM pi4Asolv) {
void ObcParameters::setPi4Asolv(double pi4Asolv) {
_pi4Asolv = pi4Asolv;
}
......@@ -270,7 +271,7 @@ void ObcParameters::setPi4Asolv(RealOpenMM pi4Asolv) {
--------------------------------------------------------------------------------------- */
const vector<RealOpenMM>& ObcParameters::getAtomicRadii() const {
const vector<double>& ObcParameters::getAtomicRadii() const {
return _atomicRadii;
}
......@@ -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()) {
for (unsigned int ii = 0; ii < atomicRadii.size(); ii++) {
......@@ -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;
}
......@@ -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()) {
for (unsigned int ii = 0; ii < scaledRadiusFactors.size(); ii++) {
......@@ -342,7 +343,7 @@ void ObcParameters::setScaledRadiusFactors(const vector<RealOpenMM>& scaledRadiu
--------------------------------------------------------------------------------------- */
void ObcParameters::setUseCutoff(RealOpenMM distance) {
void ObcParameters::setUseCutoff(double distance) {
_cutoff = true;
_cutoffDistance = distance;
......@@ -364,7 +365,7 @@ bool ObcParameters::getUseCutoff() const {
--------------------------------------------------------------------------------------- */
RealOpenMM ObcParameters::getCutoffDistance() const {
double ObcParameters::getCutoffDistance() const {
return _cutoffDistance;
}
......@@ -378,7 +379,7 @@ RealOpenMM ObcParameters::getCutoffDistance() const {
--------------------------------------------------------------------------------------- */
void ObcParameters::setPeriodic(OpenMM::RealVec* vectors) {
void ObcParameters::setPeriodic(OpenMM::Vec3* vectors) {
assert(_cutoff);
......@@ -408,6 +409,6 @@ bool ObcParameters::getPeriodic() {
--------------------------------------------------------------------------------------- */
const OpenMM::RealVec* ObcParameters::getPeriodicBox() {
const OpenMM::Vec3* ObcParameters::getPeriodicBox() {
return _periodicBoxVectors;
}
platforms/reference/src/SimTKReference/ReferenceAndersenThermostat.cpp
View file @ a783b996
......@@ -22,6 +22,7 @@
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <cmath>
#include <string.h>
#include <sstream>
......@@ -61,10 +62,10 @@ using namespace OpenMM;
--------------------------------------------------------------------------------------- */
void ReferenceAndersenThermostat::applyThermostat(const vector<vector<int> >& atomGroups, vector<RealVec>& atomVelocities, vector<RealOpenMM>& atomMasses,
RealOpenMM temperature, RealOpenMM collisionFrequency, RealOpenMM stepSize) const {
void ReferenceAndersenThermostat::applyThermostat(const vector<vector<int> >& atomGroups, vector<Vec3>& atomVelocities, vector<double>& atomMasses,
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) {
if (SimTKOpenMMUtilities::getUniformlyDistributedRandomNumber() < collisionProbability) {
......@@ -73,7 +74,7 @@ using namespace OpenMM;
for (int j = 0; j < (int) atomGroups[i].size(); j++) {
int atom = atomGroups[i][j];
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][1] = velocityScale*SimTKOpenMMUtilities::getNormallyDistributedRandomNumber();
atomVelocities[atom][2] = velocityScale*SimTKOpenMMUtilities::getNormallyDistributedRandomNumber();
......
platforms/reference/src/SimTKReference/ReferenceAngleBondIxn.cpp
View file @ a783b996
......@@ -39,13 +39,6 @@ using namespace OpenMM;
--------------------------------------------------------------------------------------- */
ReferenceAngleBondIxn::ReferenceAngleBondIxn() : usePeriodic(false) {
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nReferenceAngleBondIxn::ReferenceAngleBondIxn";
// ---------------------------------------------------------------------------------------
}
/**---------------------------------------------------------------------------------------
......@@ -55,16 +48,9 @@ ReferenceAngleBondIxn::ReferenceAngleBondIxn() : usePeriodic(false) {
--------------------------------------------------------------------------------------- */
ReferenceAngleBondIxn::~ReferenceAngleBondIxn() {
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nReferenceAngleBondIxn::~ReferenceAngleBondIxn";
// ---------------------------------------------------------------------------------------
}
void ReferenceAngleBondIxn::setPeriodic(OpenMM::RealVec* vectors) {
void ReferenceAngleBondIxn::setPeriodic(OpenMM::Vec3* vectors) {
usePeriodic = true;
boxVectors[0] = vectors[0];
boxVectors[1] = vectors[1];
......@@ -83,32 +69,22 @@ void ReferenceAngleBondIxn::setPeriodic(OpenMM::RealVec* vectors) {
--------------------------------------------------------------------------------------- */
void ReferenceAngleBondIxn::getPrefactorsGivenAngleCosine(RealOpenMM cosine, RealOpenMM* angleParameters,
RealOpenMM* dEdR, RealOpenMM* 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;
void ReferenceAngleBondIxn::getPrefactorsGivenAngleCosine(double cosine, double* angleParameters,
double* dEdR, double* energyTerm) const {
// ---------------------------------------------------------------------------------------
RealOpenMM angle;
if (cosine >= one) {
angle = zero;
} else if (cosine <= -one) {
double angle;
if (cosine >= 1.0) {
angle = 0.0;
} else if (cosine <= -1.0) {
angle = PI_M;
} else {
angle = ACOS(cosine);
angle = acos(cosine);
}
RealOpenMM deltaIdeal = angle - angleParameters[0];
RealOpenMM deltaIdeal2 = deltaIdeal*deltaIdeal;
double deltaIdeal = angle - angleParameters[0];
double deltaIdeal2 = deltaIdeal*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
--------------------------------------------------------------------------------------- */
void ReferenceAngleBondIxn::calculateBondIxn(int* atomIndices,
vector<RealVec>& atomCoordinates,
RealOpenMM* parameters,
vector<RealVec>& forces,
RealOpenMM* 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;
vector<Vec3>& atomCoordinates,
double* parameters,
vector<Vec3>& forces,
double* totalEnergy, double* energyParamDerivs) {
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,
ReferenceForce::getDeltaR(atomCoordinates[atomCIndex], atomCoordinates[atomBIndex], deltaR[1]);
}
RealOpenMM pVector[threeI];
double pVector[3];
SimTKOpenMMUtilities::crossProductVector3(deltaR[0], deltaR[1], pVector);
RealOpenMM rp = DOT3(pVector, pVector);
rp = SQRT(rp);
double rp = sqrt(DOT3(pVector, pVector));
if (rp < 1.0e-06) {
rp = (RealOpenMM) 1.0e-06;
rp = 1.0e-06;
}
RealOpenMM dot = DOT3(deltaR[0], deltaR[1]);
RealOpenMM cosine = dot/SQRT((deltaR[0][ReferenceForce::R2Index]*deltaR[1][ReferenceForce::R2Index]));
double dot = DOT3(deltaR[0], deltaR[1]);
double cosine = dot/sqrt((deltaR[0][ReferenceForce::R2Index]*deltaR[1][ReferenceForce::R2Index]));
RealOpenMM dEdR;
RealOpenMM energy;
double dEdR;
double energy;
getPrefactorsGivenAngleCosine(cosine, parameters, &dEdR, &energy);
RealOpenMM termA = dEdR/(deltaR[0][ReferenceForce::R2Index]*rp);
RealOpenMM termC = -dEdR/(deltaR[1][ReferenceForce::R2Index]*rp);
double termA = dEdR/(deltaR[0][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[1], pVector, deltaCrossP[2]);
for (int ii = 0; ii < threeI; ii++) {
for (int ii = 0; ii < 3; ii++) {
deltaCrossP[0][ii] *= termA;
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
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];
}
}
......
platforms/reference/src/SimTKReference/ReferenceBondForce.cpp
View file @ a783b996
......@@ -38,13 +38,6 @@ using namespace OpenMM;
--------------------------------------------------------------------------------------- */
ReferenceBondForce::ReferenceBondForce() {
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nReferenceBondForce::ReferenceBondForce";
// ---------------------------------------------------------------------------------------
}
/**---------------------------------------------------------------------------------------
......@@ -54,13 +47,6 @@ ReferenceBondForce::ReferenceBondForce() {
--------------------------------------------------------------------------------------- */
ReferenceBondForce::~ReferenceBondForce() {
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nReferenceBondForce::~ReferenceBondForce";
// ---------------------------------------------------------------------------------------
}
/**---------------------------------------------------------------------------------------
......@@ -79,19 +65,12 @@ ReferenceBondForce::~ReferenceBondForce() {
--------------------------------------------------------------------------------------- */
void ReferenceBondForce::calculateForce(int numberOfBonds, int** atomIndices,
vector<RealVec>& atomCoordinates,
RealOpenMM** parameters,
vector<RealVec>& forces,
RealOpenMM *totalEnergy,
vector<Vec3>& atomCoordinates,
double** parameters,
vector<Vec3>& forces,
double *totalEnergy,
ReferenceBondIxn& referenceBondIxn) {
// ---------------------------------------------------------------------------------------
static const char* methodName = "\nReferenceBondForce::calculateForce";
// ---------------------------------------------------------------------------------------
for (int ii = 0; ii < numberOfBonds; ii++) {
// calculate bond ixn
......
platforms/reference/src/SimTKReference/ReferenceBondIxn.cpp
View file @ a783b996
......@@ -39,13 +39,6 @@ using namespace OpenMM;
--------------------------------------------------------------------------------------- */
ReferenceBondIxn::ReferenceBondIxn() {
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nReferenceBondIxn::ReferenceBondIxn";
// ---------------------------------------------------------------------------------------
}
/**---------------------------------------------------------------------------------------
......@@ -55,13 +48,6 @@ ReferenceBondIxn::ReferenceBondIxn() {
--------------------------------------------------------------------------------------- */
ReferenceBondIxn::~ReferenceBondIxn() {
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nReferenceBondIxn::~ReferenceBondIxn";
// ---------------------------------------------------------------------------------------
}
/**---------------------------------------------------------------------------------------
......@@ -76,15 +62,9 @@ ReferenceBondIxn::~ReferenceBondIxn() {
--------------------------------------------------------------------------------------- */
void ReferenceBondIxn::calculateBondIxn(int* atomIndices, vector<RealVec>& atomCoordinates,
RealOpenMM* parameters, vector<RealVec>& forces,
RealOpenMM* totalEnergy, double* energyParamDerivs) {
// ---------------------------------------------------------------------------------------
// static const std::string methodName = "\nReferenceBondIxn::calculateBondIxn";
// ---------------------------------------------------------------------------------------
void ReferenceBondIxn::calculateBondIxn(int* atomIndices, vector<Vec3>& atomCoordinates,
double* parameters, vector<Vec3>& forces,
double* totalEnergy, double* energyParamDerivs) {
}
/**---------------------------------------------------------------------------------------
......@@ -102,67 +82,26 @@ ReferenceBondIxn::~ReferenceBondIxn() {
--------------------------------------------------------------------------------------- */
RealOpenMM ReferenceBondIxn::getNormedDotProduct(RealOpenMM* vector1, RealOpenMM* vector2,
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
double ReferenceBondIxn::getNormedDotProduct(double* vector1, double* vector2,
int hasREntry = 0) {
#if defined USE_DOUBLE_FOR_NORMED_DOT_PRODUCT
double v1D[3];
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) {
double dotProduct = DOT3(vector1, vector2);
if (dotProduct != 0.0) {
if (hasREntry) {
dotProduct /= (vector1[ReferenceForce::RIndex]*vector2[ReferenceForce::RIndex]);
} else {
RealOpenMM norm1 = DOT3(vector1, vector1);
RealOpenMM norm2 = DOT3(vector2, vector2);
dotProduct /= SQRT(norm1*norm2);
double norm1 = DOT3(vector1, vector1);
double norm2 = DOT3(vector2, vector2);
dotProduct /= sqrt(norm1*norm2);
}
}
#endif
#undef USE_DOUBLE_FOR_NORMED_DOT_PRODUCT
// clamp dot product to [-1,1]
if (dotProduct > one) {
dotProduct = one;
} else if (dotProduct < -one) {
dotProduct = -one;
if (dotProduct > 1.0) {
dotProduct = 1.0;
} else if (dotProduct < -1.0) {
dotProduct = -1.0;
}
return dotProduct;
......@@ -183,35 +122,26 @@ RealOpenMM ReferenceBondIxn::getNormedDotProduct(RealOpenMM* vector1, RealOpenMM
--------------------------------------------------------------------------------------- */
RealOpenMM ReferenceBondIxn::getAngleBetweenTwoVectors(RealOpenMM* vector1, RealOpenMM* vector2,
RealOpenMM* outputDotProduct = NULL,
int hasREntry = 0) {
double ReferenceBondIxn::getAngleBetweenTwoVectors(double* vector1, double* vector2,
double* outputDotProduct = NULL,
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;
static const RealOpenMM one = 1.0;
// ---------------------------------------------------------------------------------------
// 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) {
double angle;
if (dotProduct > 0.99 || dotProduct < -0.99) {
// 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);
RealOpenMM scale = DOT3(vector1, vector1)*DOT3(vector2, vector2);
angle = ASIN(SQRT(DOT3(cross, cross)/scale));
if (dotProduct < zero)
angle = (RealOpenMM) (M_PI-angle);
double scale = DOT3(vector1, vector1)*DOT3(vector2, vector2);
angle = asin(sqrt(DOT3(cross, cross)/scale));
if (dotProduct < 0.0)
angle = M_PI-angle;
} else {
angle = ACOS(dotProduct);
angle = acos(dotProduct);
}
if (outputDotProduct) {
......@@ -240,29 +170,20 @@ RealOpenMM ReferenceBondIxn::getAngleBetweenTwoVectors(RealOpenMM* vector1, Real
--------------------------------------------------------------------------------------- */
RealOpenMM ReferenceBondIxn::getDihedralAngleBetweenThreeVectors(RealOpenMM* vector1,
RealOpenMM* vector2,
RealOpenMM* vector3,
RealOpenMM** outputCrossProduct = NULL,
RealOpenMM* cosineOfAngle = NULL,
RealOpenMM* signVector = NULL,
RealOpenMM* signOfAngle = NULL,
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 ReferenceBondIxn::getDihedralAngleBetweenThreeVectors(double* vector1,
double* vector2,
double* vector3,
double** outputCrossProduct = NULL,
double* cosineOfAngle = NULL,
double* signVector = NULL,
double* signOfAngle = NULL,
int hasREntry = 0) {
// ---------------------------------------------------------------------------------------
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
RealOpenMM* crossProduct[2];
double* crossProduct[2];
if (outputCrossProduct) {
crossProduct[0] = outputCrossProduct[0];
crossProduct[1] = outputCrossProduct[1];
......@@ -274,13 +195,13 @@ RealOpenMM ReferenceBondIxn::getDihedralAngleBetweenThreeVectors(RealOpenMM* ve
SimTKOpenMMUtilities::crossProductVector3(vector1, vector2, crossProduct[0]);
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
if (signVector) {
RealOpenMM dotProduct = DOT3(signVector, crossProduct[1]);
RealOpenMM sign = dotProduct < zero ? -one : one;
double dotProduct = DOT3(signVector, crossProduct[1]);
double sign = dotProduct < 0.0 ? -1.0 : 1.0;
if (signOfAngle) {
*signOfAngle = sign;
}
......
platforms/reference/src/SimTKReference/ReferenceBrownianDynamics.cpp
View file @ a783b996
......@@ -47,8 +47,8 @@ using namespace OpenMM;
--------------------------------------------------------------------------------------- */
ReferenceBrownianDynamics::ReferenceBrownianDynamics(int numberOfAtoms,
RealOpenMM deltaT, RealOpenMM friction,
RealOpenMM temperature) :
double deltaT, double friction,
double temperature) :
ReferenceDynamics(numberOfAtoms, deltaT, temperature), friction(friction) {
if (friction <= 0) {
......@@ -67,13 +67,6 @@ ReferenceBrownianDynamics::ReferenceBrownianDynamics(int numberOfAtoms,
--------------------------------------------------------------------------------------- */
ReferenceBrownianDynamics::~ReferenceBrownianDynamics() {
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nReferenceBrownianDynamics::~ReferenceBrownianDynamics";
// ---------------------------------------------------------------------------------------
}
/**---------------------------------------------------------------------------------------
......@@ -84,14 +77,7 @@ ReferenceBrownianDynamics::~ReferenceBrownianDynamics() {
--------------------------------------------------------------------------------------- */
RealOpenMM ReferenceBrownianDynamics::getFriction() const {
// ---------------------------------------------------------------------------------------
// static const char* methodName = "\nReferenceBrownianDynamics::getFriction";
// ---------------------------------------------------------------------------------------
double ReferenceBrownianDynamics::getFriction() const {
return friction;
}
......@@ -108,18 +94,9 @@ RealOpenMM ReferenceBrownianDynamics::getFriction() const {
--------------------------------------------------------------------------------------- */
void ReferenceBrownianDynamics::update(const OpenMM::System& system, vector<RealVec>& atomCoordinates,
vector<RealVec>& velocities,
vector<RealVec>& forces, vector<RealOpenMM>& masses, RealOpenMM tolerance) {
// ---------------------------------------------------------------------------------------
static const char* methodName = "\nReferenceBrownianDynamics::update";
static const RealOpenMM zero = 0.0;
static const RealOpenMM one = 1.0;
// ---------------------------------------------------------------------------------------
void ReferenceBrownianDynamics::update(const OpenMM::System& system, vector<Vec3>& atomCoordinates,
vector<Vec3>& velocities,
vector<Vec3>& forces, vector<double>& masses, double tolerance) {
// first-time-through initialization
......@@ -128,21 +105,21 @@ void ReferenceBrownianDynamics::update(const OpenMM::System& system, vector<Real
// invert masses
for (int ii = 0; ii < numberOfAtoms; ii++) {
if (masses[ii] == zero)
inverseMasses[ii] = zero;
if (masses[ii] == 0.0)
inverseMasses[ii] = 0.0;
else
inverseMasses[ii] = one/masses[ii];
inverseMasses[ii] = 1.0/masses[ii];
}
}
// Perform the integration.
const RealOpenMM noiseAmplitude = static_cast<RealOpenMM>(sqrt(2.0*BOLTZ*getTemperature()*getDeltaT()/getFriction()));
const RealOpenMM forceScale = getDeltaT()/getFriction();
const double noiseAmplitude = sqrt(2.0*BOLTZ*getTemperature()*getDeltaT()/getFriction());
const double forceScale = getDeltaT()/getFriction();
for (int i = 0; i < numberOfAtoms; ++i) {
if (masses[i] != zero)
if (masses[i] != 0.0)
for (int j = 0; j < 3; ++j) {
xPrime[i][j] = atomCoordinates[i][j] + forceScale*inverseMasses[i]*forces[i][j] + noiseAmplitude*SQRT(inverseMasses[i])*SimTKOpenMMUtilities::getNormallyDistributedRandomNumber();
xPrime[i][j] = atomCoordinates[i][j] + forceScale*inverseMasses[i]*forces[i][j] + noiseAmplitude*sqrt(inverseMasses[i])*SimTKOpenMMUtilities::getNormallyDistributedRandomNumber();
}
}
ReferenceConstraintAlgorithm* referenceConstraintAlgorithm = getReferenceConstraintAlgorithm();
......@@ -151,9 +128,9 @@ void ReferenceBrownianDynamics::update(const OpenMM::System& system, vector<Real
// Update the positions and velocities.
RealOpenMM velocityScale = static_cast<RealOpenMM>(1.0/getDeltaT());
double velocityScale = 1.0/getDeltaT();
for (int i = 0; i < numberOfAtoms; ++i) {
if (masses[i] != zero)
if (masses[i] != 0.0)
for (int j = 0; j < 3; ++j) {
velocities[i][j] = velocityScale*(xPrime[i][j] - atomCoordinates[i][j]);
atomCoordinates[i][j] = xPrime[i][j];
......
platforms/reference/src/SimTKReference/ReferenceCCMAAlgorithm.cpp
View file @ a783b996
......@@ -43,7 +43,7 @@ using namespace std;
class ExtractMatrixTask : public ThreadPool::Task {
public:
ExtractMatrixTask(int numConstraints, vector<vector<pair<int, RealOpenMM> > >& transposedMatrix, const vector<RealOpenMM>& distance, RealOpenMM elementCutoff,
ExtractMatrixTask(int numConstraints, vector<vector<pair<int, double> > >& transposedMatrix, const vector<double>& distance, double elementCutoff,
const int* qRowStart, const int* qColIndex, const int* rRowStart, const int* rColIndex, const double* qValue, const double* rValue) :
numConstraints(numConstraints), transposedMatrix(transposedMatrix), distance(distance), elementCutoff(elementCutoff), qRowStart(qRowStart), qColIndex(qColIndex),
rRowStart(rRowStart), rColIndex(rColIndex), qValue(qValue), rValue(rValue) {
......@@ -60,16 +60,16 @@ public:
QUERN_solve_with_r(numConstraints, rRowStart, rColIndex, rValue, &rhs[0], &rhs[0]);
for (int j = 0; j < numConstraints; j++) {
double value = rhs[j]*distance[i]/distance[j];
if (FABS((RealOpenMM) value) > elementCutoff)
transposedMatrix[i].push_back(pair<int, RealOpenMM>(j, (RealOpenMM) value));
if (fabs(value) > elementCutoff)
transposedMatrix[i].push_back(pair<int, double>(j, value));
}
}
}
private:
int numConstraints;
vector<vector<pair<int, RealOpenMM> > >& transposedMatrix;
const vector<RealOpenMM>& distance;
RealOpenMM elementCutoff;
vector<vector<pair<int, double> > >& transposedMatrix;
const vector<double>& distance;
double elementCutoff;
const int *qRowStart, *qColIndex, *rRowStart, *rColIndex;
const double *qValue, *rValue;
};
......@@ -77,10 +77,10 @@ private:
ReferenceCCMAAlgorithm::ReferenceCCMAAlgorithm(int numberOfAtoms,
int numberOfConstraints,
const vector<pair<int, int> >& atomIndices,
const vector<RealOpenMM>& distance,
vector<RealOpenMM>& masses,
const vector<double>& distance,
vector<double>& masses,
vector<AngleInfo>& angles,
RealOpenMM elementCutoff) {
double elementCutoff) {
_numberOfConstraints = numberOfConstraints;
_elementCutoff = elementCutoff;
_atomIndices = atomIndices;
......@@ -116,8 +116,8 @@ ReferenceCCMAAlgorithm::ReferenceCCMAAlgorithm(int numberOfAtoms,
int atomj1 = _atomIndices[j].second;
int atomk0 = _atomIndices[k].first;
int atomk1 = _atomIndices[k].second;
RealOpenMM invMass0 = 1/masses[atomj0];
RealOpenMM invMass1 = 1/masses[atomj1];
double invMass0 = 1/masses[atomj0];
double invMass1 = 1/masses[atomj1];
int atoma, atomb, atomc;
if (atomj0 == atomk0) {
atoma = atomj1;
......@@ -192,7 +192,7 @@ ReferenceCCMAAlgorithm::ReferenceCCMAAlgorithm(int numberOfAtoms,
double *qValue, *rValue;
QUERN_compute_qr(numberOfConstraints, numberOfConstraints, &matrixRowStart[0], &matrixColIndex[0], &matrixValue[0], NULL,
&qRowStart, &qColIndex, &qValue, &rRowStart, &rColIndex, &rValue);
vector<vector<pair<int, RealOpenMM> > > transposedMatrix(numberOfConstraints);
vector<vector<pair<int, double> > > transposedMatrix(numberOfConstraints);
_matrix.resize(numberOfConstraints);
ThreadPool threads;
ExtractMatrixTask task(numberOfConstraints, transposedMatrix, _distance, _elementCutoff, qRowStart, qColIndex, rRowStart, rColIndex, qValue, rValue);
......@@ -203,7 +203,7 @@ ReferenceCCMAAlgorithm::ReferenceCCMAAlgorithm(int numberOfAtoms,
for (int i = 0; i < numberOfConstraints; i++) {
for (int j = 0; j < transposedMatrix[i].size(); j++) {
pair<int, RealOpenMM> value = transposedMatrix[i][j];
pair<int, double> value = transposedMatrix[i][j];
_matrix[value.first].push_back(make_pair(i, value.second));
}
}
......@@ -232,25 +232,25 @@ void ReferenceCCMAAlgorithm::setMaximumNumberOfIterations(int maximumNumberOfIte
_maximumNumberOfIterations = maximumNumberOfIterations;
}
void ReferenceCCMAAlgorithm::apply(vector<RealVec>& atomCoordinates,
vector<RealVec>& atomCoordinatesP,
vector<RealOpenMM>& inverseMasses, RealOpenMM tolerance) {
void ReferenceCCMAAlgorithm::apply(vector<Vec3>& atomCoordinates,
vector<Vec3>& atomCoordinatesP,
vector<double>& inverseMasses, double tolerance) {
applyConstraints(atomCoordinates, atomCoordinatesP, inverseMasses, false, tolerance);
}
void ReferenceCCMAAlgorithm::applyToVelocities(std::vector<OpenMM::RealVec>& atomCoordinates,
std::vector<OpenMM::RealVec>& velocities, std::vector<RealOpenMM>& inverseMasses, RealOpenMM tolerance) {
void ReferenceCCMAAlgorithm::applyToVelocities(std::vector<OpenMM::Vec3>& atomCoordinates,
std::vector<OpenMM::Vec3>& velocities, std::vector<double>& inverseMasses, double tolerance) {
applyConstraints(atomCoordinates, velocities, inverseMasses, true, tolerance);
}
void ReferenceCCMAAlgorithm::applyConstraints(vector<RealVec>& atomCoordinates,
vector<RealVec>& atomCoordinatesP,
vector<RealOpenMM>& inverseMasses, bool constrainingVelocities, RealOpenMM tolerance) {
void ReferenceCCMAAlgorithm::applyConstraints(vector<Vec3>& atomCoordinates,
vector<Vec3>& atomCoordinatesP,
vector<double>& inverseMasses, bool constrainingVelocities, double tolerance) {
// temp arrays
vector<RealVec>& r_ij = _r_ij;
RealOpenMM* d_ij2 = _d_ij2;
RealOpenMM* reducedMasses = _reducedMasses;
vector<Vec3>& r_ij = _r_ij;
double* d_ij2 = _d_ij2;
double* reducedMasses = _reducedMasses;
// calculate reduced masses on 1st pass
......@@ -271,33 +271,33 @@ void ReferenceCCMAAlgorithm::applyConstraints(vector<RealVec>& atomCoordinates,
r_ij[ii] = atomCoordinates[atomI] - atomCoordinates[atomJ];
d_ij2[ii] = r_ij[ii].dot(r_ij[ii]);
}
RealOpenMM lowerTol = 1-2*tolerance+tolerance*tolerance;
RealOpenMM upperTol = 1+2*tolerance+tolerance*tolerance;
double lowerTol = 1-2*tolerance+tolerance*tolerance;
double upperTol = 1+2*tolerance+tolerance*tolerance;
// main loop
int iterations = 0;
int numberConverged = 0;
vector<RealOpenMM> constraintDelta(_numberOfConstraints);
vector<RealOpenMM> tempDelta(_numberOfConstraints);
vector<double> constraintDelta(_numberOfConstraints);
vector<double> tempDelta(_numberOfConstraints);
while (iterations < getMaximumNumberOfIterations()) {
numberConverged = 0;
for (int ii = 0; ii < _numberOfConstraints; ii++) {
int atomI = _atomIndices[ii].first;
int atomJ = _atomIndices[ii].second;
RealVec rp_ij = atomCoordinatesP[atomI] - atomCoordinatesP[atomJ];
Vec3 rp_ij = atomCoordinatesP[atomI] - atomCoordinatesP[atomJ];
if (constrainingVelocities) {
RealOpenMM rrpr = rp_ij.dot(r_ij[ii]);
double rrpr = rp_ij.dot(r_ij[ii]);
constraintDelta[ii] = -2*reducedMasses[ii]*rrpr/d_ij2[ii];
if (fabs(constraintDelta[ii]) <= tolerance)
numberConverged++;
}
else {
RealOpenMM rp2 = rp_ij.dot(rp_ij);
RealOpenMM dist2 = _distance[ii]*_distance[ii];
RealOpenMM diff = dist2 - rp2;
double rp2 = rp_ij.dot(rp_ij);
double dist2 = _distance[ii]*_distance[ii];
double diff = dist2 - rp2;
constraintDelta[ii] = 0;
RealOpenMM rrpr = DOT3(rp_ij, r_ij[ii]);
double rrpr = DOT3(rp_ij, r_ij[ii]);
constraintDelta[ii] = reducedMasses[ii]*diff/rrpr;
if (rp2 >= lowerTol*dist2 && rp2 <= upperTol*dist2)
numberConverged++;
......@@ -309,9 +309,9 @@ void ReferenceCCMAAlgorithm::applyConstraints(vector<RealVec>& atomCoordinates,
if (_matrix.size() > 0) {
for (int i = 0; i < _numberOfConstraints; i++) {
RealOpenMM sum = 0.0;
double sum = 0.0;
for (int j = 0; j < (int) _matrix[i].size(); j++) {
pair<int, RealOpenMM> element = _matrix[i][j];
pair<int, double> element = _matrix[i][j];
sum += element.second*constraintDelta[element.first];
}
tempDelta[i] = sum;
......@@ -321,13 +321,13 @@ void ReferenceCCMAAlgorithm::applyConstraints(vector<RealVec>& atomCoordinates,
for (int ii = 0; ii < _numberOfConstraints; ii++) {
int atomI = _atomIndices[ii].first;
int atomJ = _atomIndices[ii].second;
RealVec dr = r_ij[ii]*constraintDelta[ii];
Vec3 dr = r_ij[ii]*constraintDelta[ii];
atomCoordinatesP[atomI] += dr*inverseMasses[atomI];
atomCoordinatesP[atomJ] -= dr*inverseMasses[atomJ];
}
}
}
const vector<vector<pair<int, RealOpenMM> > >& ReferenceCCMAAlgorithm::getMatrix() const {
const vector<vector<pair<int, double> > >& ReferenceCCMAAlgorithm::getMatrix() const {
return _matrix;
}
platforms/reference/src/SimTKReference/ReferenceCMAPTorsionIxn.cpp
View file @ a783b996
......@@ -34,12 +34,12 @@ using namespace OpenMM;
--------------------------------------------------------------------------------------- */
ReferenceCMAPTorsionIxn::ReferenceCMAPTorsionIxn(const vector<vector<vector<RealOpenMM> > >& coeff,
ReferenceCMAPTorsionIxn::ReferenceCMAPTorsionIxn(const vector<vector<vector<double> > >& coeff,
const vector<int>& torsionMaps, const vector<vector<int> >& torsionIndices) :
coeff(coeff), torsionMaps(torsionMaps), torsionIndices(torsionIndices), usePeriodic(false) {
}
void ReferenceCMAPTorsionIxn::setPeriodic(OpenMM::RealVec* vectors) {
void ReferenceCMAPTorsionIxn::setPeriodic(OpenMM::Vec3* vectors) {
usePeriodic = true;
boxVectors[0] = vectors[0];
boxVectors[1] = vectors[1];
......@@ -59,7 +59,7 @@ void ReferenceCMAPTorsionIxn::setPeriodic(OpenMM::RealVec* vectors) {
--------------------------------------------------------------------------------------- */
void ReferenceCMAPTorsionIxn::calculateIxn(vector<RealVec>& atomCoordinates, vector<RealVec>& forces, RealOpenMM* totalEnergy) const {
void ReferenceCMAPTorsionIxn::calculateIxn(vector<Vec3>& atomCoordinates, vector<Vec3>& forces, double* totalEnergy) const {
for (unsigned int i = 0; i < torsionMaps.size(); i++)
calculateOneIxn(i, atomCoordinates, forces, totalEnergy);
}
......@@ -75,8 +75,8 @@ void ReferenceCMAPTorsionIxn::calculateIxn(vector<RealVec>& atomCoordinates, vec
--------------------------------------------------------------------------------------- */
void ReferenceCMAPTorsionIxn::calculateOneIxn(int index, vector<RealVec>& atomCoordinates, vector<RealVec>& forces,
RealOpenMM* totalEnergy) const {
void ReferenceCMAPTorsionIxn::calculateOneIxn(int index, vector<Vec3>& atomCoordinates, vector<Vec3>& forces,
double* totalEnergy) const {
int map = torsionMaps[index];
int a1 = torsionIndices[index][0];
int a2 = torsionIndices[index][1];
......@@ -89,8 +89,8 @@ void ReferenceCMAPTorsionIxn::calculateOneIxn(int index, vector<RealVec>& atomCo
// Compute deltas between the various atoms involved.
RealOpenMM deltaA[3][ReferenceForce::LastDeltaRIndex];
RealOpenMM deltaB[3][ReferenceForce::LastDeltaRIndex];
double deltaA[3][ReferenceForce::LastDeltaRIndex];
double deltaB[3][ReferenceForce::LastDeltaRIndex];
if (usePeriodic) {
ReferenceForce::getDeltaRPeriodic(atomCoordinates[a2], atomCoordinates[a1], boxVectors, deltaA[0]);
ReferenceForce::getDeltaRPeriodic(atomCoordinates[a2], atomCoordinates[a3], boxVectors, deltaA[1]);
......@@ -110,40 +110,40 @@ void ReferenceCMAPTorsionIxn::calculateOneIxn(int index, vector<RealVec>& atomCo
// Visual Studio complains if crossProduct declared as 'crossProduct[2][3]'
RealOpenMM crossProductMemory[12];
RealOpenMM* cpA[2];
double crossProductMemory[12];
double* cpA[2];
cpA[0] = crossProductMemory;
cpA[1] = crossProductMemory + 3;
RealOpenMM* cpB[2];
double* cpB[2];
cpB[0] = crossProductMemory + 6;
cpB[1] = crossProductMemory + 9;
// Compute the dihedral angles.
RealOpenMM dotDihedral;
RealOpenMM signOfAngle;
RealOpenMM angleA = getDihedralAngleBetweenThreeVectors(deltaA[0], deltaA[1], deltaA[2],
double dotDihedral;
double signOfAngle;
double angleA = getDihedralAngleBetweenThreeVectors(deltaA[0], deltaA[1], deltaA[2],
cpA, &dotDihedral, deltaA[0], &signOfAngle, 1);
RealOpenMM angleB = getDihedralAngleBetweenThreeVectors(deltaB[0], deltaB[1], deltaB[2],
double angleB = getDihedralAngleBetweenThreeVectors(deltaB[0], deltaB[1], deltaB[2],
cpB, &dotDihedral, deltaB[0], &signOfAngle, 1);
angleA = fmod(angleA+2.0*M_PI, 2.0*M_PI);
angleB = fmod(angleB+2.0*M_PI, 2.0*M_PI);
// Identify which patch this is in.
int size = (int) SQRT((RealOpenMM) coeff[map].size());
RealOpenMM delta = 2*M_PI/size;
int size = (int) sqrt(coeff[map].size());
double delta = 2*M_PI/size;
int s = (int) (angleA/delta);
int t = (int) (angleB/delta);
const vector<RealOpenMM>& c = coeff[map][s+size*t];
RealOpenMM da = angleA/delta-s;
RealOpenMM db = angleB/delta-t;
const vector<double>& c = coeff[map][s+size*t];
double da = angleA/delta-s;
double db = angleB/delta-t;
// Evaluate the spline to determine the energy and gradients.
RealOpenMM energy = 0;
RealOpenMM dEdA = 0;
RealOpenMM dEdB = 0;
double energy = 0;
double dEdA = 0;
double dEdB = 0;
for (int i = 3; i >= 0; i--) {
energy = da*energy + ((c[i*4+3]*db + c[i*4+2])*db + c[i*4+1])*db + c[i*4+0];
dEdA = db*dEdA + (3.0*c[i+3*4]*da + 2.0*c[i+2*4])*da + c[i+1*4];
......@@ -156,20 +156,20 @@ void ReferenceCMAPTorsionIxn::calculateOneIxn(int index, vector<RealVec>& atomCo
// Apply the force to the first torsion.
RealOpenMM forceFactors[4];
RealOpenMM normCross1 = DOT3(cpA[0], cpA[0]);
RealOpenMM normBC = deltaA[1][ReferenceForce::RIndex];
double forceFactors[4];
double normCross1 = DOT3(cpA[0], cpA[0]);
double normBC = deltaA[1][ReferenceForce::RIndex];
forceFactors[0] = (-dEdA*normBC)/normCross1;
RealOpenMM normCross2 = DOT3(cpA[1], cpA[1]);
double normCross2 = DOT3(cpA[1], cpA[1]);
forceFactors[3] = (dEdA*normBC)/normCross2;
forceFactors[1] = DOT3(deltaA[0], deltaA[1]);
forceFactors[1] /= deltaA[1][ReferenceForce::R2Index];
forceFactors[2] = DOT3(deltaA[2], deltaA[1]);
forceFactors[2] /= deltaA[1][ReferenceForce::R2Index];
for (int i = 0; i < 3; i++) {
RealOpenMM f0 = forceFactors[0]*cpA[0][i];
RealOpenMM f3 = forceFactors[3]*cpA[1][i];
RealOpenMM s = forceFactors[1]*f0 - forceFactors[2]*f3;
double f0 = forceFactors[0]*cpA[0][i];
double f3 = forceFactors[3]*cpA[1][i];
double s = forceFactors[1]*f0 - forceFactors[2]*f3;
forces[a1][i] += f0;
forces[a2][i] -= f0-s;
forces[a3][i] -= f3+s;
......@@ -188,9 +188,9 @@ void ReferenceCMAPTorsionIxn::calculateOneIxn(int index, vector<RealVec>& atomCo
forceFactors[2] = DOT3(deltaB[2], deltaB[1]);
forceFactors[2] /= deltaB[1][ReferenceForce::R2Index];
for (int i = 0; i < 3; i++) {
RealOpenMM f0 = forceFactors[0]*cpB[0][i];
RealOpenMM f3 = forceFactors[3]*cpB[1][i];
RealOpenMM s = forceFactors[1]*f0 - forceFactors[2]*f3;
double f0 = forceFactors[0]*cpB[0][i];
double f3 = forceFactors[3]*cpB[1][i];
double s = forceFactors[1]*f0 - forceFactors[2]*f3;
forces[b1][i] += f0;
forces[b2][i] -= f0-s;
forces[b3][i] -= f3+s;
......@@ -206,6 +206,6 @@ void ReferenceCMAPTorsionIxn::calculateOneIxn(int index, vector<RealVec>& atomCo
--------------------------------------------------------------------------------------- */
void ReferenceCMAPTorsionIxn::calculateBondIxn(int* atomIndices, vector<RealVec>& atomCoordinates,
RealOpenMM* parameters, vector<RealVec>& forces, RealOpenMM* totalEnergy, double* energyParamDerivs) {
void ReferenceCMAPTorsionIxn::calculateBondIxn(int* atomIndices, vector<Vec3>& atomCoordinates,
double* parameters, vector<Vec3>& forces, double* totalEnergy, double* energyParamDerivs) {
}
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