Skip to content

GitLab

Commit 3d69185a authored by peastman's avatar peastman
Browse files

Combined subfolders in reference source, and renamed a couple of badly named classes

parent 0671c7b0
Show whitespace changes
Inline Side-by-side
Showing with 72 additions and 72 deletions
platforms/reference/include/CpuGBVI.h → platforms/reference/include/ReferenceGBVI.h
View file @ 3d69185a
......@@ -22,8 +22,8 @@
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef __CpuGBVI_H__
#define __CpuGBVI_H__
#ifndef __ReferenceGBVI_H__
#define __ReferenceGBVI_H__
#include <vector>
......@@ -32,7 +32,7 @@
namespace OpenMM {
class CpuGBVI {
class ReferenceGBVI {
private:
......@@ -53,7 +53,7 @@ class CpuGBVI {
--------------------------------------------------------------------------------------- */
CpuGBVI(GBVIParameters* gbviParameters);
ReferenceGBVI(GBVIParameters* gbviParameters);
/**---------------------------------------------------------------------------------------
......@@ -61,7 +61,7 @@ class CpuGBVI {
--------------------------------------------------------------------------------------- */
~CpuGBVI();
~ReferenceGBVI();
/**---------------------------------------------------------------------------------------
......@@ -313,4 +313,4 @@ class CpuGBVI {
} // namespace OpenMM
#endif // __CpuGBVI_H__
#endif // __ReferenceGBVI_H__
platforms/reference/include/ReferenceKernels.h
View file @ 3d69185a
......@@ -41,8 +41,8 @@
namespace OpenMM {
class CpuObc;
class CpuGBVI;
class ReferenceObc;
class ReferenceGBVI;
class ReferenceAndersenThermostat;
class ReferenceCustomCompoundBondIxn;
class ReferenceCustomHbondIxn;
......@@ -658,7 +658,7 @@ public:
*/
void copyParametersToContext(ContextImpl& context, const GBSAOBCForce& force);
private:
CpuObc* obc;
ReferenceObc* obc;
std::vector<RealOpenMM> charges;
bool isPeriodic;
};
......@@ -689,7 +689,7 @@ public:
*/
double execute(ContextImpl& context, bool includeForces, bool includeEnergy);
private:
CpuGBVI * gbvi;
ReferenceGBVI * gbvi;
std::vector<RealOpenMM> charges;
bool isPeriodic;
};
......
platforms/reference/include/CpuObc.h → platforms/reference/include/ReferenceObc.h
View file @ 3d69185a
......@@ -22,14 +22,14 @@
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef __CpuObc_H__
#define __CpuObc_H__
#ifndef __ReferenceObc_H__
#define __ReferenceObc_H__
#include "ObcParameters.h"
namespace OpenMM {
class CpuObc {
class ReferenceObc {
private:
......@@ -59,7 +59,7 @@ class CpuObc {
--------------------------------------------------------------------------------------- */
CpuObc(ObcParameters* obcParameters);
ReferenceObc(ObcParameters* obcParameters);
/**---------------------------------------------------------------------------------------
......@@ -67,7 +67,7 @@ class CpuObc {
--------------------------------------------------------------------------------------- */
~CpuObc();
~ReferenceObc();
/**---------------------------------------------------------------------------------------
......@@ -183,4 +183,4 @@ class CpuObc {
} // namespace OpenMM
#endif // __CpuObc_H__
#endif // __ReferenceObc_H__
platforms/reference/src/ReferenceKernels.cpp
View file @ 3d69185a
......@@ -30,8 +30,8 @@
* -------------------------------------------------------------------------- */
#include "ReferenceKernels.h"
#include "CpuObc.h"
#include "CpuGBVI.h"
#include "ReferenceObc.h"
#include "ReferenceGBVI.h"
#include "ReferenceAndersenThermostat.h"
#include "ReferenceAngleBondIxn.h"
#include "ReferenceBondForce.h"
......@@ -1111,7 +1111,7 @@ void ReferenceCalcGBSAOBCForceKernel::initialize(const System& system, const GBS
if (force.getNonbondedMethod() != GBSAOBCForce::NoCutoff)
obcParameters->setUseCutoff(static_cast<RealOpenMM>(force.getCutoffDistance()));
isPeriodic = (force.getNonbondedMethod() == GBSAOBCForce::CutoffPeriodic);
obc = new CpuObc(obcParameters);
obc = new ReferenceObc(obcParameters);
obc->setIncludeAceApproximation(true);
}
......@@ -1185,7 +1185,7 @@ void ReferenceCalcGBVIForceKernel::initialize(const System& system, const GBVIFo
if (force.getNonbondedMethod() != GBVIForce::NoCutoff)
gBVIParameters->setUseCutoff(static_cast<RealOpenMM>(force.getCutoffDistance()));
isPeriodic = (force.getNonbondedMethod() == GBVIForce::CutoffPeriodic);
gbvi = new CpuGBVI(gBVIParameters);
gbvi = new ReferenceGBVI(gBVIParameters);
}
double ReferenceCalcGBVIForceKernel::execute(ContextImpl& context, bool includeForces, bool includeEnergy) {
......
platforms/reference/src/gbsa/CpuGBVI.cpp → platforms/reference/src/SimTKReference/ReferenceGBVI.cpp
View file @ 3d69185a
......@@ -27,30 +27,30 @@
#include <stdio.h>
#include "ReferenceForce.h"
#include "CpuGBVI.h"
#include "ReferenceGBVI.h"
using namespace std;
using namespace OpenMM;
/**---------------------------------------------------------------------------------------
CpuGBVI constructor
ReferenceGBVI constructor
gbviParameters gbviParameters object
--------------------------------------------------------------------------------------- */
CpuGBVI::CpuGBVI(GBVIParameters* gbviParameters) : _gbviParameters(gbviParameters) {
ReferenceGBVI::ReferenceGBVI(GBVIParameters* gbviParameters) : _gbviParameters(gbviParameters) {
_switchDeriviative.resize(gbviParameters->getNumberOfAtoms());
}
/**---------------------------------------------------------------------------------------
CpuGBVI destructor
ReferenceGBVI destructor
--------------------------------------------------------------------------------------- */
CpuGBVI::~CpuGBVI() {
ReferenceGBVI::~ReferenceGBVI() {
}
/**---------------------------------------------------------------------------------------
......@@ -61,7 +61,7 @@ CpuGBVI::~CpuGBVI() {
--------------------------------------------------------------------------------------- */
GBVIParameters* CpuGBVI::getGBVIParameters() const {
GBVIParameters* ReferenceGBVI::getGBVIParameters() const {
return _gbviParameters;
}
......@@ -73,7 +73,7 @@ GBVIParameters* CpuGBVI::getGBVIParameters() const {
--------------------------------------------------------------------------------------- */
void CpuGBVI::setGBVIParameters(GBVIParameters* gbviParameters) {
void ReferenceGBVI::setGBVIParameters(GBVIParameters* gbviParameters) {
_gbviParameters = gbviParameters;
}
......@@ -85,7 +85,7 @@ void CpuGBVI::setGBVIParameters(GBVIParameters* gbviParameters) {
--------------------------------------------------------------------------------------- */
vector<RealOpenMM>& CpuGBVI::getSwitchDeriviative() {
vector<RealOpenMM>& ReferenceGBVI::getSwitchDeriviative() {
return _switchDeriviative;
}
......@@ -101,7 +101,7 @@ vector<RealOpenMM>& CpuGBVI::getSwitchDeriviative() {
--------------------------------------------------------------------------------------- */
void CpuGBVI::quinticSpline(RealOpenMM x, RealOpenMM rl, RealOpenMM ru,
void ReferenceGBVI::quinticSpline(RealOpenMM x, RealOpenMM rl, RealOpenMM ru,
RealOpenMM* outValue, RealOpenMM* outDerivative) {
// ---------------------------------------------------------------------------------------
......@@ -139,7 +139,7 @@ void CpuGBVI::quinticSpline(RealOpenMM x, RealOpenMM rl, RealOpenMM ru,
--------------------------------------------------------------------------------------- */
void CpuGBVI::computeBornRadiiUsingQuinticSpline(RealOpenMM atomicRadius3, RealOpenMM bornSum,
void ReferenceGBVI::computeBornRadiiUsingQuinticSpline(RealOpenMM atomicRadius3, RealOpenMM bornSum,
GBVIParameters* gbviParameters,
RealOpenMM* bornRadius, RealOpenMM* switchDeriviative) {
......@@ -202,7 +202,7 @@ void CpuGBVI::computeBornRadiiUsingQuinticSpline(RealOpenMM atomicRadius3, RealO
--------------------------------------------------------------------------------------- */
void CpuGBVI::computeBornRadii(const vector<RealVec>& atomCoordinates, vector<RealOpenMM>& bornRadii) {
void ReferenceGBVI::computeBornRadii(const vector<RealVec>& atomCoordinates, vector<RealOpenMM>& bornRadii) {
// ---------------------------------------------------------------------------------------
......@@ -248,7 +248,7 @@ void CpuGBVI::computeBornRadii(const vector<RealVec>& atomCoordinates, vector<Re
if (_gbviParameters->getUseCutoff() && r > _gbviParameters->getCutoffDistance())
continue;
sum += CpuGBVI::getVolume(r, radiusI, scaledRadii[atomJ]);
sum += ReferenceGBVI::getVolume(r, radiusI, scaledRadii[atomJ]);
}
}
......@@ -280,7 +280,7 @@ void CpuGBVI::computeBornRadii(const vector<RealVec>& atomCoordinates, vector<Re
--------------------------------------------------------------------------------------- */
RealOpenMM CpuGBVI::getVolume(RealOpenMM r, RealOpenMM R, RealOpenMM S) {
RealOpenMM ReferenceGBVI::getVolume(RealOpenMM r, RealOpenMM R, RealOpenMM S) {
// ---------------------------------------------------------------------------------------
......@@ -291,13 +291,13 @@ RealOpenMM CpuGBVI::getVolume(RealOpenMM r, RealOpenMM R, RealOpenMM S) {
if (FABS(diff) < r) {
RealOpenMM lowerBound = (R > (r - S)) ? R : (r - S);
return (CpuGBVI::getL(r, (r + S), S) -
CpuGBVI::getL(r, lowerBound, S));
return (ReferenceGBVI::getL(r, (r + S), S) -
ReferenceGBVI::getL(r, lowerBound, S));
} else if (r <= diff) {
return CpuGBVI::getL(r, (r + S), S) -
CpuGBVI::getL(r, (r - S), S) +
return ReferenceGBVI::getL(r, (r + S), S) -
ReferenceGBVI::getL(r, (r - S), S) +
POW(R, minusThree);
} else {
......@@ -317,7 +317,7 @@ RealOpenMM CpuGBVI::getVolume(RealOpenMM r, RealOpenMM R, RealOpenMM S) {
--------------------------------------------------------------------------------------- */
RealOpenMM CpuGBVI::getL(RealOpenMM r, RealOpenMM x, RealOpenMM S) {
RealOpenMM ReferenceGBVI::getL(RealOpenMM r, RealOpenMM x, RealOpenMM S) {
// ---------------------------------------------------------------------------------------
......@@ -352,7 +352,7 @@ RealOpenMM CpuGBVI::getL(RealOpenMM r, RealOpenMM x, RealOpenMM S) {
--------------------------------------------------------------------------------------- */
RealOpenMM CpuGBVI::dL_dr(RealOpenMM r, RealOpenMM x, RealOpenMM S) {
RealOpenMM ReferenceGBVI::dL_dr(RealOpenMM r, RealOpenMM x, RealOpenMM S) {
// ---------------------------------------------------------------------------------------
......@@ -389,7 +389,7 @@ RealOpenMM CpuGBVI::dL_dr(RealOpenMM r, RealOpenMM x, RealOpenMM S) {
--------------------------------------------------------------------------------------- */
RealOpenMM CpuGBVI::dL_dx(RealOpenMM r, RealOpenMM x, RealOpenMM S) {
RealOpenMM ReferenceGBVI::dL_dx(RealOpenMM r, RealOpenMM x, RealOpenMM S) {
// ---------------------------------------------------------------------------------------
......@@ -421,11 +421,11 @@ RealOpenMM CpuGBVI::dL_dx(RealOpenMM r, RealOpenMM x, RealOpenMM S) {
--------------------------------------------------------------------------------------- */
RealOpenMM CpuGBVI::Sgb(RealOpenMM t) {
RealOpenMM ReferenceGBVI::Sgb(RealOpenMM t) {
// ---------------------------------------------------------------------------------------
// static const char* methodName = "CpuGBVI::Sgb";
// static const char* methodName = "ReferenceGBVI::Sgb";
static const RealOpenMM zero = static_cast<RealOpenMM>(0.0);
static const RealOpenMM one = static_cast<RealOpenMM>(1.0);
......@@ -447,7 +447,7 @@ RealOpenMM CpuGBVI::Sgb(RealOpenMM t) {
--------------------------------------------------------------------------------------- */
RealOpenMM CpuGBVI::computeBornEnergy(const vector<RealVec>& atomCoordinates, const vector<RealOpenMM>& partialCharges) {
RealOpenMM ReferenceGBVI::computeBornEnergy(const vector<RealVec>& atomCoordinates, const vector<RealOpenMM>& partialCharges) {
// ---------------------------------------------------------------------------------------
......@@ -531,7 +531,7 @@ RealOpenMM CpuGBVI::computeBornEnergy(const vector<RealVec>& atomCoordinates, co
--------------------------------------------------------------------------------------- */
void CpuGBVI::computeBornForces(std::vector<RealVec>& atomCoordinates, const vector<RealOpenMM>& partialCharges,
void ReferenceGBVI::computeBornForces(std::vector<RealVec>& atomCoordinates, const vector<RealOpenMM>& partialCharges,
std::vector<OpenMM::RealVec>& inputForces) {
// ---------------------------------------------------------------------------------------
......@@ -689,15 +689,15 @@ void CpuGBVI::computeBornForces(std::vector<RealVec>& atomCoordinates, const vec
// find dRb/dr, where Rb is the Born radius
if (FABS(diff) < r) {
de = CpuGBVI::dL_dr(r, r+S, S) + CpuGBVI::dL_dx(r, r+S, S);
de = ReferenceGBVI::dL_dr(r, r+S, S) + ReferenceGBVI::dL_dx(r, r+S, S);
if (R > (r - S)) {
de -= CpuGBVI::dL_dr(r, R, S);
de -= ReferenceGBVI::dL_dr(r, R, S);
} else {
de -= (CpuGBVI::dL_dr(r, (r-S), S) + CpuGBVI::dL_dx(r, (r-S), S));
de -= (ReferenceGBVI::dL_dr(r, (r-S), S) + ReferenceGBVI::dL_dx(r, (r-S), S));
}
} else if (r < (S - R)) {
de = CpuGBVI::dL_dr(r, r+S, S) + CpuGBVI::dL_dx(r, r+S, S);
de -= (CpuGBVI::dL_dr(r, r-S, S) + CpuGBVI::dL_dx(r, r-S, S));
de = ReferenceGBVI::dL_dr(r, r+S, S) + ReferenceGBVI::dL_dx(r, r+S, S);
de -= (ReferenceGBVI::dL_dr(r, r-S, S) + ReferenceGBVI::dL_dx(r, r-S, S));
}
// de = (dG/dRb)(dRb/dr)
......@@ -747,7 +747,7 @@ void CpuGBVI::computeBornForces(std::vector<RealVec>& atomCoordinates, const vec
--------------------------------------------------------------------------------------- */
void CpuGBVI::printGbvi(const std::vector<OpenMM::RealVec>& atomCoordinates, const vector<RealOpenMM>& partialCharges,
void ReferenceGBVI::printGbvi(const std::vector<OpenMM::RealVec>& atomCoordinates, const vector<RealOpenMM>& partialCharges,
const vector<RealOpenMM>& bornRadii,
const vector<RealOpenMM>& bornForces,
const std::vector<OpenMM::RealVec>& forces,
......@@ -834,7 +834,7 @@ void CpuGBVI::printGbvi(const std::vector<OpenMM::RealVec>& atomCoordinates, con
--------------------------------------------------------------------------------------- */
double CpuGBVI::getVolumeD(double r, double R, double S) {
double ReferenceGBVI::getVolumeD(double r, double R, double S) {
// ---------------------------------------------------------------------------------------
......@@ -846,13 +846,13 @@ double CpuGBVI::getVolumeD(double r, double R, double S) {
double lowerBound = (R > (r - S)) ? R : (r - S);
return (CpuGBVI::getLD(r, (r + S), S) -
CpuGBVI::getLD(r, lowerBound, S));
return (ReferenceGBVI::getLD(r, (r + S), S) -
ReferenceGBVI::getLD(r, lowerBound, S));
} else if (r < diff) {
return CpuGBVI::getLD(r, (r + S), S) -
CpuGBVI::getLD(r, (r - S), S) +
return ReferenceGBVI::getLD(r, (r + S), S) -
ReferenceGBVI::getLD(r, (r - S), S) +
pow(R, minusThree);
} else {
......@@ -874,7 +874,7 @@ double CpuGBVI::getVolumeD(double r, double R, double S) {
--------------------------------------------------------------------------------------- */
double CpuGBVI::getLD(double r, double x, double S) {
double ReferenceGBVI::getLD(double r, double x, double S) {
// ---------------------------------------------------------------------------------------
......@@ -911,7 +911,7 @@ double CpuGBVI::getLD(double r, double x, double S) {
--------------------------------------------------------------------------------------- */
double CpuGBVI::dL_drD(double r, double x, double S) {
double ReferenceGBVI::dL_drD(double r, double x, double S) {
// ---------------------------------------------------------------------------------------
......@@ -950,7 +950,7 @@ double CpuGBVI::dL_drD(double r, double x, double S) {
--------------------------------------------------------------------------------------- */
double CpuGBVI::dL_dxD(double r, double x, double S) {
double ReferenceGBVI::dL_dxD(double r, double x, double S) {
// ---------------------------------------------------------------------------------------
......
platforms/reference/src/gbsa/CpuObc.cpp → platforms/reference/src/SimTKReference/ReferenceObc.cpp
View file @ 3d69185a
......@@ -29,30 +29,30 @@
#include <cstdio>
#include "ReferenceForce.h"
#include "CpuObc.h"
#include "ReferenceObc.h"
using namespace OpenMM;
using namespace std;
/**---------------------------------------------------------------------------------------
CpuObc constructor
ReferenceObc constructor
obcParameters obcParameters object
--------------------------------------------------------------------------------------- */
CpuObc::CpuObc(ObcParameters* obcParameters) : _obcParameters(obcParameters), _includeAceApproximation(1) {
ReferenceObc::ReferenceObc(ObcParameters* obcParameters) : _obcParameters(obcParameters), _includeAceApproximation(1) {
_obcChain.resize(_obcParameters->getNumberOfAtoms());
}
/**---------------------------------------------------------------------------------------
CpuObc destructor
ReferenceObc destructor
--------------------------------------------------------------------------------------- */
CpuObc::~CpuObc() {
ReferenceObc::~ReferenceObc() {
}
/**---------------------------------------------------------------------------------------
......@@ -63,7 +63,7 @@ CpuObc::~CpuObc() {
--------------------------------------------------------------------------------------- */
ObcParameters* CpuObc::getObcParameters() const {
ObcParameters* ReferenceObc::getObcParameters() const {
return _obcParameters;
}
......@@ -75,7 +75,7 @@ ObcParameters* CpuObc::getObcParameters() const {
--------------------------------------------------------------------------------------- */
void CpuObc::setObcParameters( ObcParameters* obcParameters) {
void ReferenceObc::setObcParameters( ObcParameters* obcParameters) {
_obcParameters = obcParameters;
}
......@@ -87,7 +87,7 @@ void CpuObc::setObcParameters( ObcParameters* obcParameters) {
--------------------------------------------------------------------------------------- */
int CpuObc::includeAceApproximation() const {
int ReferenceObc::includeAceApproximation() const {
return _includeAceApproximation;
}
......@@ -99,7 +99,7 @@ int CpuObc::includeAceApproximation() const {
--------------------------------------------------------------------------------------- */
void CpuObc::setIncludeAceApproximation(int includeAceApproximation) {
void ReferenceObc::setIncludeAceApproximation(int includeAceApproximation) {
_includeAceApproximation = includeAceApproximation;
}
......@@ -111,7 +111,7 @@ void CpuObc::setIncludeAceApproximation(int includeAceApproximation) {
--------------------------------------------------------------------------------------- */
vector<RealOpenMM>& CpuObc::getObcChain() {
vector<RealOpenMM>& ReferenceObc::getObcChain() {
return _obcChain;
}
......@@ -127,7 +127,7 @@ vector<RealOpenMM>& CpuObc::getObcChain() {
--------------------------------------------------------------------------------------- */
void CpuObc::computeBornRadii(const vector<RealVec>& atomCoordinates, vector<RealOpenMM>& bornRadii) {
void ReferenceObc::computeBornRadii(const vector<RealVec>& atomCoordinates, vector<RealOpenMM>& bornRadii) {
// ---------------------------------------------------------------------------------------
......@@ -235,7 +235,7 @@ void CpuObc::computeBornRadii(const vector<RealVec>& atomCoordinates, vector<Rea
--------------------------------------------------------------------------------------- */
void CpuObc::computeAceNonPolarForce(const ObcParameters* obcParameters,
void ReferenceObc::computeAceNonPolarForce(const ObcParameters* obcParameters,
const vector<RealOpenMM>& bornRadii,
RealOpenMM* energy,
vector<RealOpenMM>& forces) const {
......@@ -293,7 +293,7 @@ void CpuObc::computeAceNonPolarForce(const ObcParameters* obcParameters,
--------------------------------------------------------------------------------------- */
RealOpenMM CpuObc::computeBornEnergyForces(const vector<RealVec>& atomCoordinates,
RealOpenMM ReferenceObc::computeBornEnergyForces(const vector<RealVec>& atomCoordinates,
const vector<RealOpenMM>& partialCharges, vector<RealVec>& inputForces) {
// ---------------------------------------------------------------------------------------
......@@ -513,7 +513,7 @@ RealOpenMM CpuObc::computeBornEnergyForces(const vector<RealVec>& atomCoordinate
--------------------------------------------------------------------------------------- */
void CpuObc::printObc(const std::vector<OpenMM::RealVec>& atomCoordinates,
void ReferenceObc::printObc(const std::vector<OpenMM::RealVec>& atomCoordinates,
const vector<RealOpenMM>& partialCharges,
const vector<RealOpenMM>& bornRadii,
const vector<RealOpenMM>& bornForces,
......
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