Skip to content

GitLab

Commit 39d85db0 authored by Michael Sherman's avatar Michael Sherman
Browse files

Reworked the NaCl example per dryrun feedback and fixed some warnings in ethane example.

parent 7fccb08e
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 422 additions and 366 deletions
examples/HelloEthane.cpp
View file @ 39d85db0
This diff is collapsed.
examples/HelloSodiumChloride.cpp
View file @ 39d85db0
/* -----------------------------------------------------------------------------
* OpenMM(tm) HelloSodiumChloride example (May 2009)
* -----------------------------------------------------------------------------
* This is a complete, self-contained "hello world" example demonstrating
* GPU-accelerated constant energy simulation of a very simple system with just
* nonbonded forces, consisting of several sodium (Na+) and chloride (Cl-) ions.
* A multi-frame PDB file is written to stdout which can be read by VMD or other
* visualization tool to produce an animation of the resulting trajectory.
*
* Pay particular attention to the handling of units in this example. Incorrect
* handling of units is a very common error; this example shows how you can
* continue to work with Amber-style units of Angstroms and kCals while correctly
* communicating with OpenMM in nanometers and kJoules.
* -------------------------------------------------------------------------- */
// Suppress irrelevant warnings from Microsoft's compiler.
#ifdef _MSC_VER
#pragma warning(disable:4996) // sprintf is unsafe
#pragma warning(disable:4251) // no dll interface for some classes
#endif
#include "OpenMM.h"
#include <iostream>
#include <iomanip>
#include <string>
using namespace OpenMM;
Vec3 operator*(const Vec3& v, double r) {
return Vec3(v[0]*r, v[1]*r, v[2]*r);
}
Vec3 operator*(double r, const Vec3& v) {
return Vec3(r*v[0], r*v[1], r*v[2]);
using OpenMM::Vec3; // so we can just say "Vec3" below
// -----------------------------------------------------------------------------
// MODELING AND SIMULATION PARAMETERS
// -----------------------------------------------------------------------------
const double StepSizeInFs = 2; // integration step size (fs)
const double ReportIntervalInFs = 10; // how often to generate PDB frame (fs)
const double SimulationTimeInPs = 100; // total simulation time (ps)
static void simulateNaCl();
static void writePDB(const OpenMM::OpenMMContext&); // PDB file writer; see below.
// -----------------------------------------------------------------------------
// MAIN PROGRAM
// -----------------------------------------------------------------------------
int main() {
// ALWAYS enclose all OpenMM calls with a try/catch block to make sure that
// usage and runtime errors are caught and reported.
try {
// Load all available OpenMM plugins from their default location.
OpenMM::Platform::loadPluginsFromDirectory
(OpenMM::Platform::getDefaultPluginsDirectory());
simulateNaCl();
return 0; // Normal return from main.
}
// Catch and report usage and runtime errors detected by OpenMM and fail.
catch(const std::exception& e) {
printf("EXCEPTION: %s\n", e.what());
return 1;
}
}
// -----------------------------------------------------------------------------
// ATOM AND FORCE FIELD DATA
// -----------------------------------------------------------------------------
// This is not part of OpenMM; just a struct we can use to collect
// atom parameters for this example. Normally atom parameters would
// come from the force field's parameterization file.
// We're going to use data in Angstrom and Kilocalorie units and
// show how to safely convert to OpenMM's internal unit system
// which uses nanometers and kilojoules.
struct AtomInfo {
char* symbol;
double mass, charge, vdwRadiusAng, vdwEnergyKcal;
Vec3 startPosAng;
};
static AtomInfo atoms[] = {
{"NA", 22.99, 1, 1.8680, 0.00277, Vec3(8,0,0)},
{"CL", 35.45, -1, 2.4700, 0.1000, Vec3(-8,0,0)},
{"NA", 22.99, 1, 1.8680, 0.00277, Vec3(0,9,0)},
{"CL", 35.45, -1, 2.4700, 0.1000, Vec3(0,-9,0)},
{"NA", 22.99, 1, 1.8680, 0.00277, Vec3(0,0,-10)},
{"CL", 35.45, -1, 2.4700, 0.1000, Vec3( 0,0,10)},
struct AtomInfo {
const char* pdb;
double mass, charge, vdwRadiusInAng, vdwEnergyInKcal;
Vec3 initPosInAngstroms;
} atoms[] = {
// pdb mass charge vdwRadius vdwEnergy initPos
{" NA ", 22.99, 1, 1.8680, 0.00277, Vec3(8,0,0)},
{" CL ", 35.45, -1, 2.4700, 0.1000, Vec3(-8,0,0)},
{" NA ", 22.99, 1, 1.8680, 0.00277, Vec3(0,9,0)},
{" CL ", 35.45, -1, 2.4700, 0.1000, Vec3(0,-9,0)},
{" NA ", 22.99, 1, 1.8680, 0.00277, Vec3(0,0,-10)},
{" CL ", 35.45, -1, 2.4700, 0.1000, Vec3( 0,0,10)},
{""} // end of list
};
static const double Temperature = 300; // Kelvins
static const double Friction = 1./91.; // picoseconds between collisions
static const double StepSizeFs = 2; // femtoseconds
static const double ReportIntervalFs = 10;
static const double SimulationTimePs = 100; // total simulation time (ps)
static const double SigmaPerVdwRadius = 2*std::pow(2., -1./6.);
static void writePDB(const OpenMMContext&);
int main() {
try {
// Load all available OpenMM plugins from their default location.
Platform::loadPluginsFromDirectory(Platform::getDefaultPluginsDirectory());
// Create a System and a NonbondedForce object within the System.
System system;
NonbondedForce* nonbond = new NonbondedForce();
// Add missing scalar product operators for OpenMM::Vec3.
Vec3 operator*(const Vec3& v, double r) {return Vec3(v[0]*r, v[1]*r, v[2]*r);}
Vec3 operator*(double r, const Vec3& v) {return Vec3(r*v[0], r*v[1], r*v[2]);}
// This is the conversion factor that takes you from a van der Waals radius
// (defined as 1/2 the minimum energy separation) to the related Lennard Jones
// "sigma" parameter (defined as the zero crossing separation).
static const double SigmaPerVdwRadius = 2*std::pow(2., -1./6.);
// -----------------------------------------------------------------------------
// NaCl SIMULATION
// -----------------------------------------------------------------------------
static void simulateNaCl() {
// -------------------------------------------------------------------------
// Create a System and Force objects within the System. Retain a reference
// to each force object so we can fill in the forces. Note: OpenMM owns
// the objects and will take care of deleting them; don't do it yourself!
// -------------------------------------------------------------------------
OpenMM::System system;
OpenMM::NonbondedForce* nonbond = new OpenMM::NonbondedForce();
system.addForce(nonbond);
int numAtoms = 0;
for (; *atoms[numAtoms].symbol; ++numAtoms) {
const AtomInfo& atom = atoms[numAtoms];
nonbond->setNonbondedMethod(OpenMM::NonbondedForce::CutoffPeriodic);
nonbond->setCutoffDistance(2);
nonbond->setPeriodicBoxVectors(Vec3(5,0,0), Vec3(0,5,0), Vec3(0,0,5));
// -------------------------------------------------------------------------
// Specify the atoms and their properties:
// (1) System needs to know the masses.
// (2) NonbondedForce needs charges,van der Waals properties (in MD units!).
// (3) Collect default positions for initializing the simulation later.
// -------------------------------------------------------------------------
std::vector<Vec3> initialPositions;
for (int n=0; *atoms[n].pdb; ++n) {
const AtomInfo& atom = atoms[n];
system.addParticle(atom.mass);
nonbond->addParticle(atom.charge,
atom.vdwRadiusAng * NmPerAngstrom * SigmaPerVdwRadius,
atom.vdwEnergyKcal * KJPerKcal);
atom.vdwRadiusInAng * OpenMM::NmPerAngstrom * SigmaPerVdwRadius,
atom.vdwEnergyInKcal * OpenMM::KJPerKcal);
initialPositions.push_back(atoms[n].initPosInAngstroms * OpenMM::NmPerAngstrom);
}
// Create an integrator object for advancing time.
LangevinIntegrator integrator(Temperature, Friction, StepSizeFs * PsPerFs);
//VerletIntegrator integrator(StepSizeFs * PsPerFs);
// Create an OpenMM Context for execution; let it choose best platform.
OpenMMContext context(system, integrator);
const std::string platformName = context.getPlatform().getName();
// -------------------------------------------------------------------------
// Choose an Integrator for advancing time, and a Context connecting the
// System with the Integrator for simulation. Let the Context choose the
// best available Platform. Initialize the configuration from the default
// positions we collected above. Initial velocities will be zero.
// -------------------------------------------------------------------------
OpenMM::VerletIntegrator integrator(StepSizeInFs * OpenMM::PsPerFs);
OpenMM::OpenMMContext context(system, integrator);
context.setPositions(initialPositions);
// -------------------------------------------------------------------------
// Run the simulation:
// (1) Write the first line of the PDB file and the initial configuration.
// (2) Run silently entirely within OpenMM between reporting intervals.
// (3) Write a PDB frame when the time comes.
// -------------------------------------------------------------------------
printf( "REMARK Using OpenMM platform %s\n", context.getPlatform().getName().c_str() );
// Fill in a vector of starting positions, one per atom.
std::vector<Vec3> positions(numAtoms);
for (int i=0; i < numAtoms; ++i)
positions[i] = atoms[i].startPosAng * NmPerAngstrom;
// Set the starting positions in the OpenMM context. Velocities will be zero.
context.setPositions(positions);
// Output the initial state.
writePDB(context);
const int NumSilentSteps = (int)(ReportIntervalFs / StepSizeFs + 0.5);
const int NumSilentSteps = (int)(ReportIntervalInFs / StepSizeInFs + 0.5);
do {
integrator.step(NumSilentSteps);
writePDB(context);
} while (context.getTime() < SimulationTimePs);
return 0;
} catch(const std::exception& e) {
std::cout << "EXCEPTION: " << e.what() << std::endl;
return 1;
}
} while (context.getTime() < SimulationTimeInPs);
}
// -----------------------------------------------------------------------------
// PDB FILE WRITER
// -----------------------------------------------------------------------------
static void
writePDB(const OpenMMContext& context) {
writePDB(const OpenMM::OpenMMContext& context) {
// Caution: at the moment asking for energy requires use of slow reference calculation.
const State state = context.getState(State::Positions | State::Velocities | State::Energy);
const double energy = state.getPotentialEnergy() + state.getKineticEnergy();
const std::vector<Vec3>& positions = state.getPositions();
const OpenMM::State state = context.getState( OpenMM::State::Positions
| OpenMM::State::Velocities
| OpenMM::State::Energy);
const double energy = state.getPotentialEnergy() + state.getKineticEnergy();
const std::vector<Vec3>& positions = state.getPositions();
static int modelFrameNumber = 0; // numbering for MODEL records in pdb output
// write out in PDB format -- printf is so much more compact than formatted cout
modelFrameNumber++;
printf("MODEL %d\n", modelFrameNumber);
printf("REMARK 250 time=%.3f picoseconds; Energy = %.3f kilojoules/mole\n", state.getTime(), energy);
printf("REMARK 250 time=%.3f picoseconds; Energy = %.3f kilojoules/mole\n",
state.getTime(), energy);
for (unsigned i=0; i < positions.size(); ++i) {
const Vec3 pos = positions[i] * AngstromsPerNm;
printf("ATOM %3d %2s SLT 1 %8.3f%8.3f%8.3f 1.00 0.00 %2s\n",
i+1, atoms[i].symbol, pos[0], pos[1], pos[2], atoms[i].symbol);
const Vec3 pos = positions[i] * OpenMM::AngstromsPerNm;
printf("ATOM %5d %4s SLT 1 %8.3f%8.3f%8.3f 1.00 0.00 \n",
i+1, atoms[i].pdb, pos[0], pos[1], pos[2]);
}
printf("ENDMDL\n");
}
......
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