void testPeriodic() { System system; system.addParticle(1.0); system.addParticle(1.0); system.addParticle(1.0); VerletIntegrator integrator(0.01); NonbondedForce* nonbonded = new NonbondedForce(); nonbonded->addParticle(1.0, 1, 0); nonbonded->addParticle(1.0, 1, 0); nonbonded->addParticle(1.0, 1, 0); nonbonded->addException(0, 1, 0.0, 1.0, 0.0); nonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic); const double cutoff = 2.0; nonbonded->setCutoffDistance(cutoff); system.setDefaultPeriodicBoxVectors(Vec3(4, 0, 0), Vec3(0, 4, 0), Vec3(0, 0, 4)); system.addForce(nonbonded); Context context(system, integrator, platform); vector<Vec3> positions(3); positions[0] = Vec3(0, 0, 0); positions[1] = Vec3(2, 0, 0); positions[2] = Vec3(3, 0, 0); context.setPositions(positions); State state = context.getState(State::Forces | State::Energy); const vector<Vec3>& forces = state.getForces(); const double eps = 78.3; const double krf = (1.0/(cutoff*cutoff*cutoff))*(eps-1.0)/(2.0*eps+1.0); const double crf = (1.0/cutoff)*(3.0*eps)/(2.0*eps+1.0); const double force = ONE_4PI_EPS0*(1.0)*(1.0-2.0*krf*1.0); ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[0], TOL); ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[1], TOL); ASSERT_EQUAL_VEC(Vec3(0, 0, 0), forces[2], TOL); ASSERT_EQUAL_TOL(2*ONE_4PI_EPS0*(1.0)*(1.0+krf*1.0-crf), state.getPotentialEnergy(), TOL); }
void testEwald2Ions() { System system; system.addParticle(1.0); system.addParticle(1.0); VerletIntegrator integrator(0.01); NonbondedForce* nonbonded = new NonbondedForce(); nonbonded->addParticle(1.0, 1, 0); nonbonded->addParticle(-1.0, 1, 0); nonbonded->setNonbondedMethod(NonbondedForce::Ewald); const double cutoff = 2.0; nonbonded->setCutoffDistance(cutoff); nonbonded->setEwaldErrorTolerance(TOL); system.setDefaultPeriodicBoxVectors(Vec3(6, 0, 0), Vec3(0, 6, 0), Vec3(0, 0, 6)); system.addForce(nonbonded); Context context(system, integrator, platform); vector<Vec3> positions(2); positions[0] = Vec3(3.048000,2.764000,3.156000); positions[1] = Vec3(2.809000,2.888000,2.571000); context.setPositions(positions); State state = context.getState(State::Forces | State::Energy); const vector<Vec3>& forces = state.getForces(); ASSERT_EQUAL_VEC(Vec3(-123.711, 64.1877, -302.716), forces[0], 10*TOL); ASSERT_EQUAL_VEC(Vec3( 123.711, -64.1877, 302.716), forces[1], 10*TOL); ASSERT_EQUAL_TOL(-217.276, state.getPotentialEnergy(), 0.01/*10*TOL*/); }
void testCutoff() { System system; system.addParticle(1.0); system.addParticle(1.0); system.addParticle(1.0); VerletIntegrator integrator(0.01); NonbondedForce* forceField = new NonbondedForce(); forceField->addParticle(1.0, 1, 0); forceField->addParticle(1.0, 1, 0); forceField->addParticle(1.0, 1, 0); forceField->setNonbondedMethod(NonbondedForce::CutoffNonPeriodic); const double cutoff = 2.9; forceField->setCutoffDistance(cutoff); const double eps = 50.0; forceField->setReactionFieldDielectric(eps); system.addForce(forceField); Context context(system, integrator, platform); vector<Vec3> positions(3); positions[0] = Vec3(0, 0, 0); positions[1] = Vec3(0, 2, 0); positions[2] = Vec3(0, 3, 0); context.setPositions(positions); State state = context.getState(State::Forces | State::Energy); const vector<Vec3>& forces = state.getForces(); const double krf = (1.0/(cutoff*cutoff*cutoff))*(eps-1.0)/(2.0*eps+1.0); const double crf = (1.0/cutoff)*(3.0*eps)/(2.0*eps+1.0); const double force1 = ONE_4PI_EPS0*(1.0)*(0.25-2.0*krf*2.0); const double force2 = ONE_4PI_EPS0*(1.0)*(1.0-2.0*krf*1.0); ASSERT_EQUAL_VEC(Vec3(0, -force1, 0), forces[0], TOL); ASSERT_EQUAL_VEC(Vec3(0, force1-force2, 0), forces[1], TOL); ASSERT_EQUAL_VEC(Vec3(0, force2, 0), forces[2], TOL); const double energy1 = ONE_4PI_EPS0*(1.0)*(0.5+krf*4.0-crf); const double energy2 = ONE_4PI_EPS0*(1.0)*(1.0+krf*1.0-crf); ASSERT_EQUAL_TOL(energy1+energy2, state.getPotentialEnergy(), TOL); }
void testForceEnergyConsistency() { // Create a box of polarizable particles. const int gridSize = 3; const int numAtoms = gridSize*gridSize*gridSize; const double spacing = 0.6; const double boxSize = spacing*(gridSize+1); const double temperature = 300.0; const double temperatureDrude = 10.0; System system; vector<Vec3> positions; NonbondedForce* nonbonded = new NonbondedForce(); DrudeForce* drude = new DrudeForce(); system.addForce(nonbonded); system.addForce(drude); system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); nonbonded->setNonbondedMethod(NonbondedForce::PME); nonbonded->setCutoffDistance(1.0); nonbonded->setUseSwitchingFunction(true); nonbonded->setSwitchingDistance(0.9); nonbonded->setEwaldErrorTolerance(5e-5); for (int i = 0; i < numAtoms; i++) { int startIndex = system.getNumParticles(); system.addParticle(1.0); system.addParticle(1.0); nonbonded->addParticle(1.0, 0.3, 1.0); nonbonded->addParticle(-1.0, 0.3, 1.0); nonbonded->addException(startIndex, startIndex+1, 0, 1, 0); drude->addParticle(startIndex+1, startIndex, -1, -1, -1, -1.0, 0.001, 1, 1); } for (int i = 0; i < gridSize; i++) for (int j = 0; j < gridSize; j++) for (int k = 0; k < gridSize; k++) { Vec3 pos(i*spacing, j*spacing, k*spacing); positions.push_back(pos); positions.push_back(pos); } // Simulate it and check that force and energy remain consistent. DrudeLangevinIntegrator integ(temperature, 50.0, temperatureDrude, 50.0, 0.001); Platform& platform = Platform::getPlatformByName("Reference"); Context context(system, integ, platform); context.setPositions(positions); State prevState; for (int i = 0; i < 100; i++) { State state = context.getState(State::Energy | State::Forces | State::Positions); if (i > 0) { double expectedEnergyChange = 0; for (int j = 0; j < system.getNumParticles(); j++) { Vec3 delta = state.getPositions()[j]-prevState.getPositions()[j]; expectedEnergyChange -= 0.5*(state.getForces()[j]+prevState.getForces()[j]).dot(delta); } ASSERT_EQUAL_TOL(expectedEnergyChange, state.getPotentialEnergy()-prevState.getPotentialEnergy(), 0.05); } prevState = state; integ.step(1); } }
void testWaterSystem() { ReferencePlatform platform; System system; static int numParticles = 648; const double boxSize = 1.86206; for (int i = 0 ; i < numParticles ; i++) { system.addParticle(1.0); } VerletIntegrator integrator(0.01); NonbondedForce* nonbonded = new NonbondedForce(); for (int i = 0 ; i < numParticles/3 ; i++) { nonbonded->addParticle(-0.82, 1, 0); nonbonded->addParticle(0.41, 1, 0); nonbonded->addParticle(0.41, 1, 0); } nonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic); const double cutoff = 0.8; nonbonded->setCutoffDistance(cutoff); system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); nonbonded->setEwaldErrorTolerance(EWALD_TOL); system.addForce(nonbonded); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); #include "water.dat" context.setPositions(positions); State state1 = context.getState(State::Forces | State::Energy); const vector<Vec3>& forces = state1.getForces(); // Take a small step in the direction of the energy gradient. double norm = 0.0; for (int i = 0; i < numParticles; ++i) { Vec3 f = state1.getForces()[i]; norm += f[0]*f[0] + f[1]*f[1] + f[2]*f[2]; } norm = std::sqrt(norm); const double delta = 1e-3; double step = delta/norm; for (int i = 0; i < numParticles; ++i) { Vec3 p = positions[i]; Vec3 f = state1.getForces()[i]; positions[i] = Vec3(p[0]-f[0]*step, p[1]-f[1]*step, p[2]-f[2]*step); } context.setPositions(positions); // See whether the potential energy changed by the expected amount. nonbonded->setNonbondedMethod(NonbondedForce::Ewald); State state2 = context.getState(State::Energy); ASSERT_EQUAL_TOL(norm, (state2.getPotentialEnergy()-state1.getPotentialEnergy())/delta, 0.01) }
void testLargeSystem() { const int numMolecules = 50; const int numParticles = numMolecules*2; const double cutoff = 2.0; const double boxSize = 5.0; const double tolerance = 5; System system; system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); NonbondedForce* nonbonded = new NonbondedForce(); nonbonded->setCutoffDistance(cutoff); nonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic); system.addForce(nonbonded); // Create a cloud of molecules. OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); vector<Vec3> positions(numParticles); for (int i = 0; i < numMolecules; i++) { system.addParticle(1.0); system.addParticle(1.0); nonbonded->addParticle(-1.0, 0.2, 0.2); nonbonded->addParticle(1.0, 0.2, 0.2); positions[2*i] = Vec3(boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt)); positions[2*i+1] = Vec3(positions[2*i][0]+1.0, positions[2*i][1], positions[2*i][2]); system.addConstraint(2*i, 2*i+1, 1.0); } // Minimize it and verify that the energy has decreased. ReferencePlatform platform; VerletIntegrator integrator(0.01); Context context(system, integrator, platform); context.setPositions(positions); State initialState = context.getState(State::Forces | State::Energy); LocalEnergyMinimizer::minimize(context, tolerance); State finalState = context.getState(State::Forces | State::Energy | State::Positions); ASSERT(finalState.getPotentialEnergy() < initialState.getPotentialEnergy()); // Compute the force magnitude, subtracting off any component parallel to a constraint, and // check that it satisfies the requested tolerance. double forceNorm = 0.0; for (int i = 0; i < numParticles; i += 2) { Vec3 dir = finalState.getPositions()[i+1]-finalState.getPositions()[i]; double distance = sqrt(dir.dot(dir)); dir *= 1.0/distance; Vec3 f = finalState.getForces()[i]; f -= dir*dir.dot(f); forceNorm += f.dot(f); f = finalState.getForces()[i+1]; f -= dir*dir.dot(f); forceNorm += f.dot(f); } forceNorm = sqrt(forceNorm/(4*numMolecules)); ASSERT(forceNorm < 3*tolerance); }
void testCutoffAndPeriodic() { ReferencePlatform platform; System system; system.addParticle(1.0); system.addParticle(1.0); LangevinIntegrator integrator(0, 0.1, 0.01); GBSAOBCForce* gbsa = new GBSAOBCForce(); NonbondedForce* nonbonded = new NonbondedForce(); gbsa->addParticle(-1, 0.15, 1); nonbonded->addParticle(-1, 1, 0); gbsa->addParticle(1, 0.15, 1); nonbonded->addParticle(1, 1, 0); const double cutoffDistance = 3.0; const double boxSize = 10.0; nonbonded->setCutoffDistance(cutoffDistance); gbsa->setCutoffDistance(cutoffDistance); system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); system.addForce(gbsa); system.addForce(nonbonded); vector<Vec3> positions(2); positions[0] = Vec3(0, 0, 0); positions[1] = Vec3(2, 0, 0); // Calculate the forces for both cutoff and periodic with two different atom positions. nonbonded->setNonbondedMethod(NonbondedForce::CutoffNonPeriodic); gbsa->setNonbondedMethod(GBSAOBCForce::CutoffNonPeriodic); Context context(system, integrator, platform); context.setPositions(positions); State state1 = context.getState(State::Forces); nonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic); gbsa->setNonbondedMethod(GBSAOBCForce::CutoffPeriodic); context.reinitialize(); context.setPositions(positions); State state2 = context.getState(State::Forces); positions[1][0]+= boxSize; nonbonded->setNonbondedMethod(NonbondedForce::CutoffNonPeriodic); gbsa->setNonbondedMethod(GBSAOBCForce::CutoffNonPeriodic); context.reinitialize(); context.setPositions(positions); State state3 = context.getState(State::Forces); nonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic); gbsa->setNonbondedMethod(GBSAOBCForce::CutoffPeriodic); context.reinitialize(); context.setPositions(positions); State state4 = context.getState(State::Forces); // All forces should be identical, exception state3 which should be zero. ASSERT_EQUAL_VEC(state1.getForces()[0], state2.getForces()[0], 0.01); ASSERT_EQUAL_VEC(state1.getForces()[1], state2.getForces()[1], 0.01); ASSERT_EQUAL_VEC(state1.getForces()[0], state4.getForces()[0], 0.01); ASSERT_EQUAL_VEC(state1.getForces()[1], state4.getForces()[1], 0.01); ASSERT_EQUAL_VEC(state3.getForces()[0], Vec3(0, 0, 0), 0.01); ASSERT_EQUAL_VEC(state3.getForces()[1], Vec3(0, 0, 0), 0.01); }
void testConstraints() { const int numMolecules = 10; const int numParticles = numMolecules*3; const int numConstraints = numMolecules*3; const double temp = 100.0; System system; LangevinIntegrator integrator(temp, 2.0, 0.001); integrator.setConstraintTolerance(1e-5); NonbondedForce* forceField = new NonbondedForce(); for (int i = 0; i < numMolecules; ++i) { system.addParticle(16.0); system.addParticle(1.0); system.addParticle(1.0); forceField->addParticle(-0.82, 0.317, 0.65); forceField->addParticle(0.41, 1.0, 0.0); forceField->addParticle(0.41, 1.0, 0.0); system.addConstraint(i*3, i*3+1, 0.1); system.addConstraint(i*3, i*3+2, 0.1); system.addConstraint(i*3+1, i*3+2, 0.163); } system.addForce(forceField); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); vector<Vec3> velocities(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numMolecules; ++i) { positions[i*3] = Vec3((i%4)*0.4, (i/4)*0.4, 0); positions[i*3+1] = positions[i*3]+Vec3(0.1, 0, 0); positions[i*3+2] = positions[i*3]+Vec3(-0.03333, 0.09428, 0); velocities[i*3] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5); velocities[i*3+1] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5); velocities[i*3+2] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5); } context.setPositions(positions); context.setVelocities(velocities); // Simulate it and see whether the constraints remain satisfied. for (int i = 0; i < 1000; ++i) { integrator.step(1); State state = context.getState(State::Positions | State::Forces); for (int j = 0; j < numConstraints; ++j) { int particle1, particle2; double distance; system.getConstraintParameters(j, particle1, particle2, distance); Vec3 p1 = state.getPositions()[particle1]; Vec3 p2 = state.getPositions()[particle2]; double dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2])); ASSERT_EQUAL_TOL(distance, dist, 1e-5); } } }
void testSerialization() { // Create a Force. NonbondedForce force; force.setNonbondedMethod(NonbondedForce::CutoffPeriodic); force.setCutoffDistance(2.0); force.setEwaldErrorTolerance(1e-3); force.setReactionFieldDielectric(50.0); force.setUseDispersionCorrection(false); force.addParticle(1, 0.1, 0.01); force.addParticle(0.5, 0.2, 0.02); force.addParticle(-0.5, 0.3, 0.03); force.addException(0, 1, 2, 0.5, 0.1); force.addException(1, 2, 0.2, 0.4, 0.2); // Serialize and then deserialize it. stringstream buffer; XmlSerializer::serialize<NonbondedForce>(&force, "Force", buffer); NonbondedForce* copy = XmlSerializer::deserialize<NonbondedForce>(buffer); // Compare the two forces to see if they are identical. NonbondedForce& force2 = *copy; ASSERT_EQUAL(force.getNonbondedMethod(), force2.getNonbondedMethod()); ASSERT_EQUAL(force.getCutoffDistance(), force2.getCutoffDistance()); ASSERT_EQUAL(force.getEwaldErrorTolerance(), force2.getEwaldErrorTolerance()); ASSERT_EQUAL(force.getReactionFieldDielectric(), force2.getReactionFieldDielectric()); ASSERT_EQUAL(force.getUseDispersionCorrection(), force2.getUseDispersionCorrection()); ASSERT_EQUAL(force.getNumParticles(), force2.getNumParticles()); for (int i = 0; i < force.getNumParticles(); i++) { double charge1, sigma1, epsilon1; double charge2, sigma2, epsilon2; force.getParticleParameters(i, charge1, sigma1, epsilon1); force2.getParticleParameters(i, charge2, sigma2, epsilon2); ASSERT_EQUAL(charge1, charge2); ASSERT_EQUAL(sigma1, sigma2); ASSERT_EQUAL(epsilon1, epsilon2); } ASSERT_EQUAL(force.getNumExceptions(), force2.getNumExceptions()); for (int i = 0; i < force.getNumExceptions(); i++) { int a1, a2, b1, b2; double charge1, sigma1, epsilon1; double charge2, sigma2, epsilon2; force.getExceptionParameters(i, a1, b1, charge1, sigma1, epsilon1); force2.getExceptionParameters(i, a2, b2, charge2, sigma2, epsilon2); ASSERT_EQUAL(a1, a2); ASSERT_EQUAL(b1, b2); ASSERT_EQUAL(charge1, charge2); ASSERT_EQUAL(sigma1, sigma2); ASSERT_EQUAL(epsilon1, epsilon2); } }
void testTruncatedOctahedron() { const int numMolecules = 50; const int numParticles = numMolecules*2; const float cutoff = 2.0; Vec3 a(6.7929, 0, 0); Vec3 b(-2.264163559406279, 6.404455775962287, 0); Vec3 c(-2.264163559406279, -3.2019384603140684, 5.54658849047036); System system; system.setDefaultPeriodicBoxVectors(a, b, c); NonbondedForce* force = new NonbondedForce(); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); vector<Vec3> positions(numParticles); force->setCutoffDistance(cutoff); force->setNonbondedMethod(NonbondedForce::CutoffPeriodic); for (int i = 0; i < numMolecules; i++) { system.addParticle(1.0); system.addParticle(1.0); force->addParticle(-1, 0.2, 0.2); force->addParticle(1, 0.2, 0.2); positions[2*i] = a*(5*genrand_real2(sfmt)-2) + b*(5*genrand_real2(sfmt)-2) + c*(5*genrand_real2(sfmt)-2); positions[2*i+1] = positions[2*i] + Vec3(1.0, 0.0, 0.0); system.addConstraint(2*i, 2*i+1, 1.0); } system.addForce(force); VerletIntegrator integrator(0.01); Context context(system, integrator, Platform::getPlatformByName("Reference")); context.setPositions(positions); State initialState = context.getState(State::Positions | State::Energy, true); for (int i = 0; i < numMolecules; i++) { Vec3 center = (initialState.getPositions()[2*i]+initialState.getPositions()[2*i+1])*0.5; ASSERT(center[0] >= 0.0); ASSERT(center[1] >= 0.0); ASSERT(center[2] >= 0.0); ASSERT(center[0] <= a[0]); ASSERT(center[1] <= b[1]); ASSERT(center[2] <= c[2]); } double initialEnergy = initialState.getPotentialEnergy(); context.setState(initialState); State finalState = context.getState(State::Positions | State::Energy, true); double finalEnergy = finalState.getPotentialEnergy(); ASSERT_EQUAL_TOL(initialEnergy, finalEnergy, 1e-4); }
void testEwaldExact() { // Use a NaCl crystal to compare the calculated and Madelung energies const int numParticles = 1000; const double cutoff = 1.0; const double boxSize = 2.82; ReferencePlatform platform; System system; for (int i = 0; i < numParticles/2; i++) system.addParticle(22.99); for (int i = 0; i < numParticles/2; i++) system.addParticle(35.45); VerletIntegrator integrator(0.01); NonbondedForce* nonbonded = new NonbondedForce(); for (int i = 0; i < numParticles/2; i++) nonbonded->addParticle(1.0, 1.0,0.0); for (int i = 0; i < numParticles/2; i++) nonbonded->addParticle(-1.0, 1.0,0.0); nonbonded->setNonbondedMethod(NonbondedForce::Ewald); nonbonded->setCutoffDistance(cutoff); system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); nonbonded->setEwaldErrorTolerance(EWALD_TOL); system.addForce(nonbonded); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); #include "nacl_crystal.dat" context.setPositions(positions); State state = context.getState(State::Forces | State::Energy); const vector<Vec3>& forces = state.getForces(); // The potential energy of an ion in a crystal is // E = - (M*e^2/ 4*pi*epsilon0*a0), // where // M : Madelung constant (dimensionless, for FCC cells such as NaCl it is 1.7476) // e : 1.6022 × 10−19 C // 4*pi*epsilon0: 1.112 × 10−10 C²/(J m) // a0 : 0.282 x 10-9 m (perfect cell) // // E is then the energy per pair of ions, so for our case // E has to be divided by 2 (per ion), multiplied by N(avogadro), multiplied by number of particles, and divided by 1000 for kJ double exactEnergy = - (1.7476 * 1.6022e-19 * 1.6022e-19 * 6.02214e+23 * numParticles) / (1.112e-10 * 0.282e-9 * 2 * 1000); //cout << "exact\t\t: " << exactEnergy << endl; //cout << "calc\t\t: " << state.getPotentialEnergy() << endl; ASSERT_EQUAL_TOL(exactEnergy, state.getPotentialEnergy(), 100*EWALD_TOL); }
void testTriclinic() { // Create a triclinic box containing eight particles. System system; system.setDefaultPeriodicBoxVectors(Vec3(2.5, 0, 0), Vec3(0.5, 3.0, 0), Vec3(0.7, 0.9, 3.5)); for (int i = 0; i < 8; i++) system.addParticle(1.0); NonbondedForce* force = new NonbondedForce(); system.addForce(force); force->setNonbondedMethod(NonbondedForce::PME); force->setCutoffDistance(1.0); force->setPMEParameters(3.45891, 32, 40, 48); for (int i = 0; i < 4; i++) force->addParticle(-1, 0.440104, 0.4184); // Cl parameters for (int i = 0; i < 4; i++) force->addParticle(1, 0.332840, 0.0115897); // Na parameters vector<Vec3> positions(8); positions[0] = Vec3(1.744, 2.788, 3.162); positions[1] = Vec3(1.048, 0.762, 2.340); positions[2] = Vec3(2.489, 1.570, 2.817); positions[3] = Vec3(1.027, 1.893, 3.271); positions[4] = Vec3(0.937, 0.825, 0.009); positions[5] = Vec3(2.290, 1.887, 3.352); positions[6] = Vec3(1.266, 1.111, 2.894); positions[7] = Vec3(0.933, 1.862, 3.490); // Compute the forces and energy. VerletIntegrator integ(0.001); Context context(system, integ, platform); context.setPositions(positions); State state = context.getState(State::Forces | State::Energy); // Compare them to values computed by Gromacs. double expectedEnergy = -963.370; vector<Vec3> expectedForce(8); expectedForce[0] = Vec3(4.25253e+01, -1.23503e+02, 1.22139e+02); expectedForce[1] = Vec3(9.74752e+01, 1.68213e+02, 1.93169e+02); expectedForce[2] = Vec3(-1.50348e+02, 1.29165e+02, 3.70435e+02); expectedForce[3] = Vec3(9.18644e+02, -3.52571e+00, -1.34772e+03); expectedForce[4] = Vec3(-1.61193e+02, 9.01528e+01, -7.12904e+01); expectedForce[5] = Vec3(2.82630e+02, 2.78029e+01, -3.72864e+02); expectedForce[6] = Vec3(-1.47454e+02, -2.14448e+02, -3.55789e+02); expectedForce[7] = Vec3(-8.82195e+02, -7.39132e+01, 1.46202e+03); for (int i = 0; i < 8; i++) { ASSERT_EQUAL_VEC(expectedForce[i], state.getForces()[i], 1e-4); } ASSERT_EQUAL_TOL(expectedEnergy, state.getPotentialEnergy(), 1e-4); }
void testConstraints() { const int numParticles = 8; const int numConstraints = 5; System system; VariableVerletIntegrator integrator(1e-5); integrator.setConstraintTolerance(1e-5); NonbondedForce* forceField = new NonbondedForce(); for (int i = 0; i < numParticles; ++i) { system.addParticle(10.0); forceField->addParticle((i%2 == 0 ? 0.2 : -0.2), 0.5, 5.0); } system.addConstraint(0, 1, 1.0); system.addConstraint(1, 2, 1.0); system.addConstraint(2, 3, 1.0); system.addConstraint(4, 5, 1.0); system.addConstraint(6, 7, 1.0); system.addForce(forceField); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); vector<Vec3> velocities(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; ++i) { positions[i] = Vec3(i/2, (i+1)/2, 0); velocities[i] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5); } context.setPositions(positions); context.setVelocities(velocities); // Simulate it and see whether the constraints remain satisfied. double initialEnergy = 0.0; for (int i = 0; i < 1000; ++i) { State state = context.getState(State::Positions | State::Energy | State::Velocities | State::Forces); for (int j = 0; j < numConstraints; ++j) { int particle1, particle2; double distance; system.getConstraintParameters(j, particle1, particle2, distance); Vec3 p1 = state.getPositions()[particle1]; Vec3 p2 = state.getPositions()[particle2]; double dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2])); ASSERT_EQUAL_TOL(distance, dist, 1e-4); } double energy = state.getKineticEnergy()+state.getPotentialEnergy(); if (i == 1) initialEnergy = energy; else if (i > 1) ASSERT_EQUAL_TOL(initialEnergy, energy, 0.01); integrator.step(1); } double finalTime = context.getState(State::Positions).getTime(); ASSERT(finalTime > 0.1); // Now try the stepTo() method. finalTime += 0.5; integrator.stepTo(finalTime); ASSERT_EQUAL(finalTime, context.getState(State::Positions).getTime()); }
void testRandomSeed() { const int numParticles = 8; const double temp = 100.0; const double collisionFreq = 10.0; System system; VerletIntegrator integrator(0.01); NonbondedForce* forceField = new NonbondedForce(); for (int i = 0; i < numParticles; ++i) { system.addParticle(2.0); forceField->addParticle((i%2 == 0 ? 1.0 : -1.0), 1.0, 5.0); } system.addForce(forceField); AndersenThermostat* thermostat = new AndersenThermostat(temp, collisionFreq); system.addForce(thermostat); vector<Vec3> positions(numParticles); vector<Vec3> velocities(numParticles); for (int i = 0; i < numParticles; ++i) { positions[i] = Vec3((i%2 == 0 ? 2 : -2), (i%4 < 2 ? 2 : -2), (i < 4 ? 2 : -2)); velocities[i] = Vec3(0, 0, 0); } // Try twice with the same random seed. thermostat->setRandomNumberSeed(5); Context context(system, integrator, platform); context.setPositions(positions); context.setVelocities(velocities); integrator.step(10); State state1 = context.getState(State::Positions); context.reinitialize(); context.setPositions(positions); context.setVelocities(velocities); integrator.step(10); State state2 = context.getState(State::Positions); // Try twice with a different random seed. thermostat->setRandomNumberSeed(10); context.reinitialize(); context.setPositions(positions); context.setVelocities(velocities); integrator.step(10); State state3 = context.getState(State::Positions); context.reinitialize(); context.setPositions(positions); context.setVelocities(velocities); integrator.step(10); State state4 = context.getState(State::Positions); // Compare the results. for (int i = 0; i < numParticles; i++) { for (int j = 0; j < 3; j++) { ASSERT(state1.getPositions()[i][j] == state2.getPositions()[i][j]); ASSERT(state3.getPositions()[i][j] == state4.getPositions()[i][j]); ASSERT(state1.getPositions()[i][j] != state3.getPositions()[i][j]); } } }
void testParallelComputation(NonbondedForce::NonbondedMethod method) { System system; const int numParticles = 200; for (int i = 0; i < numParticles; i++) system.addParticle(1.0); NonbondedForce* force = new NonbondedForce(); for (int i = 0; i < numParticles; i++) force->addParticle(i%2-0.5, 0.5, 1.0); force->setNonbondedMethod(method); system.addForce(force); system.setDefaultPeriodicBoxVectors(Vec3(5,0,0), Vec3(0,5,0), Vec3(0,0,5)); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); vector<Vec3> positions(numParticles); for (int i = 0; i < numParticles; i++) positions[i] = Vec3(5*genrand_real2(sfmt), 5*genrand_real2(sfmt), 5*genrand_real2(sfmt)); for (int i = 0; i < numParticles; ++i) for (int j = 0; j < i; ++j) { Vec3 delta = positions[i]-positions[j]; if (delta.dot(delta) < 0.1) force->addException(i, j, 0, 1, 0); } // Create two contexts, one with a single device and one with two devices. VerletIntegrator integrator1(0.01); Context context1(system, integrator1, platform); context1.setPositions(positions); State state1 = context1.getState(State::Forces | State::Energy); VerletIntegrator integrator2(0.01); string deviceIndex = platform.getPropertyValue(context1, CudaPlatform::CudaDeviceIndex()); map<string, string> props; props[CudaPlatform::CudaDeviceIndex()] = deviceIndex+","+deviceIndex; Context context2(system, integrator2, platform, props); context2.setPositions(positions); State state2 = context2.getState(State::Forces | State::Energy); // See if they agree. ASSERT_EQUAL_TOL(state1.getPotentialEnergy(), state2.getPotentialEnergy(), 1e-5); for (int i = 0; i < numParticles; i++) ASSERT_EQUAL_VEC(state1.getForces()[i], state2.getForces()[i], 1e-5); // Modify some particle parameters and see if they still agree. for (int i = 0; i < numParticles; i += 5) { double charge, sigma, epsilon; force->getParticleParameters(i, charge, sigma, epsilon); force->setParticleParameters(i, 0.9*charge, sigma, epsilon); } force->updateParametersInContext(context1); force->updateParametersInContext(context2); state1 = context1.getState(State::Forces | State::Energy); state2 = context2.getState(State::Forces | State::Energy); ASSERT_EQUAL_TOL(state1.getPotentialEnergy(), state2.getPotentialEnergy(), 1e-5); for (int i = 0; i < numParticles; i++) ASSERT_EQUAL_VEC(state1.getForces()[i], state2.getForces()[i], 1e-5); }
void testSwitchingFunction(NonbondedForce::NonbondedMethod method) { ReferencePlatform platform; System system; system.setDefaultPeriodicBoxVectors(Vec3(6, 0, 0), Vec3(0, 6, 0), Vec3(0, 0, 6)); system.addParticle(1.0); system.addParticle(1.0); VerletIntegrator integrator(0.01); NonbondedForce* nonbonded = new NonbondedForce(); nonbonded->addParticle(0, 1.2, 1); nonbonded->addParticle(0, 1.4, 2); nonbonded->setNonbondedMethod(method); nonbonded->setCutoffDistance(2.0); nonbonded->setUseSwitchingFunction(true); nonbonded->setSwitchingDistance(1.5); nonbonded->setUseDispersionCorrection(false); system.addForce(nonbonded); Context context(system, integrator, platform); vector<Vec3> positions(2); positions[0] = Vec3(0, 0, 0); double eps = SQRT_TWO; // Compute the interaction at various distances. for (double r = 1.0; r < 2.5; r += 0.1) { positions[1] = Vec3(r, 0, 0); context.setPositions(positions); State state = context.getState(State::Forces | State::Energy); // See if the energy is correct. double x = 1.3/r; double expectedEnergy = 4.0*eps*(std::pow(x, 12.0)-std::pow(x, 6.0)); double switchValue; if (r <= 1.5) switchValue = 1; else if (r >= 2.0) switchValue = 0; else { double t = (r-1.5)/0.5; switchValue = 1+t*t*t*(-10+t*(15-t*6)); } ASSERT_EQUAL_TOL(switchValue*expectedEnergy, state.getPotentialEnergy(), TOL); // See if the force is the gradient of the energy. double delta = 1e-3; positions[1] = Vec3(r-delta, 0, 0); context.setPositions(positions); double e1 = context.getState(State::Energy).getPotentialEnergy(); positions[1] = Vec3(r+delta, 0, 0); context.setPositions(positions); double e2 = context.getState(State::Energy).getPotentialEnergy(); ASSERT_EQUAL_TOL((e2-e1)/(2*delta), state.getForces()[0][0], 1e-3); } }
void testArgonBox() { const int gridSize = 8; const double mass = 40.0; // Ar atomic mass const double temp = 120.0; // K const double epsilon = BOLTZ * temp; // L-J well depth for Ar const double sigma = 0.34; // L-J size for Ar in nm const double density = 0.8; // atoms / sigma^3 double cellSize = sigma / pow(density, 0.333); double boxSize = gridSize * cellSize; double cutoff = 2.0 * sigma; // Create a box of argon atoms. System system; NonbondedForce* nonbonded = new NonbondedForce(); vector<Vec3> positions; OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); const Vec3 half(0.5, 0.5, 0.5); for (int i = 0; i < gridSize; i++) { for (int j = 0; j < gridSize; j++) { for (int k = 0; k < gridSize; k++) { system.addParticle(mass); nonbonded->addParticle(0, sigma, epsilon); positions.push_back((Vec3(i, j, k) + half + Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt))*0.1) * cellSize); } } } nonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic); nonbonded->setCutoffDistance(cutoff); system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); system.addForce(nonbonded); VariableVerletIntegrator integrator(1e-5); Context context(system, integrator, platform); context.setPositions(positions); context.setVelocitiesToTemperature(temp); // Equilibrate. integrator.stepTo(1.0); // Simulate it and see whether energy remains constant. State state0 = context.getState(State::Energy); double initialEnergy = state0.getKineticEnergy() + state0.getPotentialEnergy(); for (int i = 0; i < 20; i++) { double t = 1.0 + 0.05*(i+1); integrator.stepTo(t); State state = context.getState(State::Energy); double energy = state.getKineticEnergy() + state.getPotentialEnergy(); ASSERT_EQUAL_TOL(initialEnergy, energy, 0.01); } }
/** * Test an integrator that enforces constraints. */ void testConstraints() { const int numParticles = 8; System system; CustomIntegrator integrator(0.002); integrator.addPerDofVariable("oldx", 0); integrator.addComputePerDof("v", "v+dt*f/m"); integrator.addComputePerDof("oldx", "x"); integrator.addComputePerDof("x", "x+dt*v"); integrator.addConstrainPositions(); integrator.addComputePerDof("v", "(x-oldx)/dt"); integrator.setConstraintTolerance(1e-5); NonbondedForce* forceField = new NonbondedForce(); for (int i = 0; i < numParticles; ++i) { system.addParticle(i%2 == 0 ? 5.0 : 10.0); forceField->addParticle((i%2 == 0 ? 0.2 : -0.2), 0.5, 5.0); } for (int i = 0; i < numParticles-1; ++i) system.addConstraint(i, i+1, 1.0); system.addForce(forceField); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); vector<Vec3> velocities(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; ++i) { positions[i] = Vec3(i/2, (i+1)/2, 0); velocities[i] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5); } context.setPositions(positions); context.setVelocities(velocities); // Simulate it and see whether the constraints remain satisfied. double initialEnergy = 0.0; for (int i = 0; i < 1000; ++i) { State state = context.getState(State::Positions | State::Energy); for (int j = 0; j < system.getNumConstraints(); ++j) { int particle1, particle2; double distance; system.getConstraintParameters(j, particle1, particle2, distance); Vec3 p1 = state.getPositions()[particle1]; Vec3 p2 = state.getPositions()[particle2]; double dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2])); ASSERT_EQUAL_TOL(distance, dist, 2e-5); } double energy = state.getKineticEnergy()+state.getPotentialEnergy(); if (i == 1) initialEnergy = energy; else if (i > 1) ASSERT_EQUAL_TOL(initialEnergy, energy, 0.01); integrator.step(1); } }
/** * Test getting and setting per-DOF variables. */ void testPerDofVariables() { const int numParticles = 200; const double boxSize = 10; System system; system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); NonbondedForce* nb = new NonbondedForce(); system.addForce(nb); nb->setNonbondedMethod(NonbondedForce::CutoffNonPeriodic); vector<Vec3> positions(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; i++) { system.addParticle(1.5); nb->addParticle(i%2 == 0 ? 1 : -1, 0.1, 1); bool close = true; while (close) { positions[i] = Vec3(boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt)); close = false; for (int j = 0; j < i; ++j) { Vec3 delta = positions[i]-positions[j]; if (delta.dot(delta) < 0.1) close = true; } } } CustomIntegrator integrator(0.01); integrator.addPerDofVariable("temp", 0); integrator.addPerDofVariable("pos", 0); integrator.addComputePerDof("v", "v+dt*f/m"); integrator.addComputePerDof("x", "x+dt*v"); integrator.addComputePerDof("pos", "x"); Context context(system, integrator, platform); context.setPositions(positions); vector<Vec3> initialValues(numParticles); for (int i = 0; i < numParticles; i++) initialValues[i] = Vec3(i+0.1, i+0.2, i+0.3); integrator.setPerDofVariable(0, initialValues); // Run a simulation, then query per-DOF values and see if they are correct. vector<Vec3> values; context.getState(State::Forces); // Cause atom reordering to happen before the first step for (int i = 0; i < 200; ++i) { integrator.step(1); State state = context.getState(State::Positions); integrator.getPerDofVariable(0, values); for (int j = 0; j < numParticles; j++) ASSERT_EQUAL_VEC(initialValues[j], values[j], 1e-5); integrator.getPerDofVariable(1, values); for (int j = 0; j < numParticles; j++) ASSERT_EQUAL_VEC(state.getPositions()[j], values[j], 1e-5); } }
void testCoulomb() { System system; system.addParticle(1.0); system.addParticle(1.0); VerletIntegrator integrator(0.01); NonbondedForce* forceField = new NonbondedForce(); forceField->addParticle(0.5, 1, 0); forceField->addParticle(-1.5, 1, 0); system.addForce(forceField); Context context(system, integrator, platform); vector<Vec3> positions(2); positions[0] = Vec3(0, 0, 0); positions[1] = Vec3(2, 0, 0); context.setPositions(positions); State state = context.getState(State::Forces | State::Energy); const vector<Vec3>& forces = state.getForces(); double force = ONE_4PI_EPS0*(-0.75)/4.0; ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], TOL); ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[1], TOL); ASSERT_EQUAL_TOL(ONE_4PI_EPS0*(-0.75)/2.0, state.getPotentialEnergy(), TOL); }
void testConstraints() { const int numParticles = 8; const double temp = 100.0; const double collisionFreq = 10.0; const int numSteps = 15000; System system; VerletIntegrator integrator(0.004); NonbondedForce* forceField = new NonbondedForce(); for (int i = 0; i < numParticles; ++i) { system.addParticle(2.0); forceField->addParticle((i%2 == 0 ? 1.0 : -1.0), 1.0, 5.0); } system.addForce(forceField); system.addConstraint(0, 1, 1); system.addConstraint(1, 2, 1); system.addConstraint(2, 3, 1); system.addConstraint(3, 0, 1); system.addConstraint(4, 5, 1); system.addConstraint(5, 6, 1); system.addConstraint(6, 7, 1); system.addConstraint(7, 4, 1); AndersenThermostat* thermostat = new AndersenThermostat(temp, collisionFreq); system.addForce(thermostat); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); positions[0] = Vec3(0, 0, 0); positions[1] = Vec3(1, 0, 0); positions[2] = Vec3(1, 1, 0); positions[3] = Vec3(0, 1, 0); positions[4] = Vec3(1, 0, 1); positions[5] = Vec3(1, 1, 1); positions[6] = Vec3(0, 1, 1); positions[7] = Vec3(0, 0, 1); context.setPositions(positions); context.setVelocitiesToTemperature(temp); // Let it equilibrate. integrator.step(5000); // Now run it for a while and see if the temperature is correct. double ke = 0.0; for (int i = 0; i < numSteps; ++i) { State state = context.getState(State::Energy); ke += state.getKineticEnergy(); integrator.step(1); } ke /= numSteps; double expected = 0.5*(numParticles*3-system.getNumConstraints())*BOLTZ*temp; ASSERT_USUALLY_EQUAL_TOL(expected, ke, 0.1); }
void testErrorTolerance(NonbondedForce::NonbondedMethod method) { // Create a cloud of random point charges. const int numParticles = 51; const double boxWidth = 5.0; System system; system.setDefaultPeriodicBoxVectors(Vec3(boxWidth, 0, 0), Vec3(0, boxWidth, 0), Vec3(0, 0, boxWidth)); NonbondedForce* force = new NonbondedForce(); system.addForce(force); vector<Vec3> positions(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; i++) { system.addParticle(1.0); force->addParticle(-1.0+i*2.0/(numParticles-1), 1.0, 0.0); positions[i] = Vec3(boxWidth*genrand_real2(sfmt), boxWidth*genrand_real2(sfmt), boxWidth*genrand_real2(sfmt)); } force->setNonbondedMethod(method); ReferencePlatform platform; // For various values of the cutoff and error tolerance, see if the actual error is reasonable. for (double cutoff = 1.0; cutoff < boxWidth/2; cutoff *= 1.2) { force->setCutoffDistance(cutoff); vector<Vec3> refForces; double norm = 0.0; for (double tol = 5e-5; tol < 1e-3; tol *= 2.0) { force->setEwaldErrorTolerance(tol); VerletIntegrator integrator(0.01); Context context(system, integrator, platform); context.setPositions(positions); State state = context.getState(State::Forces); if (refForces.size() == 0) { refForces = state.getForces(); for (int i = 0; i < numParticles; i++) norm += refForces[i].dot(refForces[i]); norm = sqrt(norm); } else { double diff = 0.0; for (int i = 0; i < numParticles; i++) { Vec3 delta = refForces[i]-state.getForces()[i]; diff += delta.dot(delta); } diff = sqrt(diff)/norm; ASSERT(diff < 2*tol); } } } }
/** * Test a multiple time step r-RESPA integrator. */ void testRespa() { const int numParticles = 8; System system; system.setDefaultPeriodicBoxVectors(Vec3(4, 0, 0), Vec3(0, 4, 0), Vec3(0, 0, 4)); CustomIntegrator integrator(0.002); integrator.addComputePerDof("v", "v+0.5*dt*f1/m"); for (int i = 0; i < 2; i++) { integrator.addComputePerDof("v", "v+0.5*(dt/2)*f0/m"); integrator.addComputePerDof("x", "x+(dt/2)*v"); integrator.addComputePerDof("v", "v+0.5*(dt/2)*f0/m"); } integrator.addComputePerDof("v", "v+0.5*dt*f1/m"); HarmonicBondForce* bonds = new HarmonicBondForce(); for (int i = 0; i < numParticles-2; i++) bonds->addBond(i, i+1, 1.0, 0.5); system.addForce(bonds); NonbondedForce* nb = new NonbondedForce(); nb->setCutoffDistance(2.0); nb->setNonbondedMethod(NonbondedForce::Ewald); for (int i = 0; i < numParticles; ++i) { system.addParticle(i%2 == 0 ? 5.0 : 10.0); nb->addParticle((i%2 == 0 ? 0.2 : -0.2), 0.5, 5.0); } nb->setForceGroup(1); nb->setReciprocalSpaceForceGroup(0); system.addForce(nb); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); vector<Vec3> velocities(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; ++i) { positions[i] = Vec3(i/2, (i+1)/2, 0); velocities[i] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5); } context.setPositions(positions); context.setVelocities(velocities); // Simulate it and monitor energy conservations. double initialEnergy = 0.0; for (int i = 0; i < 1000; ++i) { State state = context.getState(State::Energy); double energy = state.getKineticEnergy()+state.getPotentialEnergy(); if (i == 1) initialEnergy = energy; else if (i > 1) ASSERT_EQUAL_TOL(initialEnergy, energy, 0.05); integrator.step(2); } }
/** * Test a System where multiple virtual sites are all calculated from the same particles. */ void testOverlappingSites() { System system; system.addParticle(1.0); system.addParticle(1.0); system.addParticle(1.0); NonbondedForce* nonbonded = new NonbondedForce(); system.addForce(nonbonded); nonbonded->addParticle(1.0, 0.0, 0.0); nonbonded->addParticle(-0.5, 0.0, 0.0); nonbonded->addParticle(-0.5, 0.0, 0.0); vector<Vec3> positions; positions.push_back(Vec3(0, 0, 0)); positions.push_back(Vec3(10, 0, 0)); positions.push_back(Vec3(0, 10, 0)); for (int i = 0; i < 20; i++) { system.addParticle(0.0); double u = 0.1*((i+1)%4); double v = 0.05*i; system.setVirtualSite(3+i, new ThreeParticleAverageSite(0, 1, 2, u, v, 1-u-v)); nonbonded->addParticle(i%2 == 0 ? -1.0 : 1.0, 0.0, 0.0); positions.push_back(Vec3()); } VerletIntegrator i1(0.002); VerletIntegrator i2(0.002); Context c1(system, i1, Platform::getPlatformByName("Reference")); Context c2(system, i2, platform); c1.setPositions(positions); c2.setPositions(positions); c1.applyConstraints(0.0001); c2.applyConstraints(0.0001); State s1 = c1.getState(State::Positions | State::Forces); State s2 = c2.getState(State::Positions | State::Forces); for (int i = 0; i < system.getNumParticles(); i++) ASSERT_EQUAL_VEC(s1.getPositions()[i], s2.getPositions()[i], 1e-5); for (int i = 0; i < 3; i++) ASSERT_EQUAL_VEC(s1.getForces()[i], s2.getForces()[i], 1e-5); }
void testPMEParameters() { // Create a cloud of random point charges. const int numParticles = 51; const double boxWidth = 4.7; System system; system.setDefaultPeriodicBoxVectors(Vec3(boxWidth, 0, 0), Vec3(0, boxWidth, 0), Vec3(0, 0, boxWidth)); NonbondedForce* force = new NonbondedForce(); system.addForce(force); vector<Vec3> positions(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; i++) { system.addParticle(1.0); force->addParticle(-1.0+i*2.0/(numParticles-1), 1.0, 0.0); positions[i] = Vec3(boxWidth*genrand_real2(sfmt), boxWidth*genrand_real2(sfmt), boxWidth*genrand_real2(sfmt)); } force->setNonbondedMethod(NonbondedForce::PME); ReferencePlatform platform; // Compute the energy with an error tolerance of 1e-3. force->setEwaldErrorTolerance(1e-3); VerletIntegrator integrator1(0.01); Context context1(system, integrator1, platform); context1.setPositions(positions); double energy1 = context1.getState(State::Energy).getPotentialEnergy(); // Try again with an error tolerance of 1e-4. force->setEwaldErrorTolerance(1e-4); VerletIntegrator integrator2(0.01); Context context2(system, integrator2, platform); context2.setPositions(positions); double energy2 = context2.getState(State::Energy).getPotentialEnergy(); // Now explicitly set the parameters. These should match the values that were // used for tolerance 1e-3. force->setPMEParameters(2.49291157051793, 32, 32, 32); VerletIntegrator integrator3(0.01); Context context3(system, integrator3, platform); context3.setPositions(positions); double energy3 = context3.getState(State::Energy).getPotentialEnergy(); ASSERT_EQUAL_TOL(energy1, energy3, 1e-6); ASSERT(fabs((energy1-energy2)/energy1) > 1e-5); }
void testConstraints() { const int numParticles = 8; const int numConstraints = 5; const double temp = 20.0; System system; BrownianIntegrator integrator(temp, 2.0, 0.001); integrator.setConstraintTolerance(1e-5); NonbondedForce* forceField = new NonbondedForce(); for (int i = 0; i < numParticles; ++i) { system.addParticle(10.0); forceField->addParticle((i%2 == 0 ? 0.2 : -0.2), 0.5, 5.0); } system.addConstraint(0, 1, 1.0); system.addConstraint(1, 2, 1.0); system.addConstraint(2, 3, 1.0); system.addConstraint(4, 5, 1.0); system.addConstraint(6, 7, 1.0); system.addForce(forceField); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); vector<Vec3> velocities(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; ++i) { positions[i] = Vec3(i, 0, 0); velocities[i] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5); } context.setPositions(positions); context.setVelocities(velocities); // Simulate it and see whether the constraints remain satisfied. for (int i = 0; i < 1000; ++i) { State state = context.getState(State::Positions); for (int j = 0; j < numConstraints; ++j) { int particle1, particle2; double distance; system.getConstraintParameters(j, particle1, particle2, distance); Vec3 p1 = state.getPositions()[particle1]; Vec3 p2 = state.getPositions()[particle2]; double dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2])); ASSERT_EQUAL_TOL(distance, dist, 1e-4); } integrator.step(1); } }
void testMotionRemoval() { const int numParticles = 8; const double temp = 100.0; const double collisionFreq = 10.0; ReferencePlatform platform; System system; VerletIntegrator integrator(0.01); HarmonicBondForce* bonds = new HarmonicBondForce(); bonds->addBond(2, 3, 2.0, 0.5); system.addForce(bonds); NonbondedForce* nonbonded = new NonbondedForce(); for (int i = 0; i < numParticles; ++i) { system.addParticle(i+1); nonbonded->addParticle((i%2 == 0 ? 1.0 : -1.0), 1.0, 5.0); } system.addForce(nonbonded); CMMotionRemover* remover = new CMMotionRemover(); system.addForce(remover); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); vector<Vec3> velocities(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; ++i) { positions[i] = Vec3((i%2 == 0 ? 2 : -2), (i%4 < 2 ? 2 : -2), (i < 4 ? 2 : -2)); velocities[i] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5); } context.setPositions(positions); context.setVelocities(velocities); // Now run it for a while and see if the center of mass remains fixed. Vec3 cmPos = calcCM(context.getState(State::Positions).getPositions(), system); for (int i = 0; i < 1000; ++i) { integrator.step(1); State state = context.getState(State::Positions | State::Velocities); Vec3 pos = calcCM(state.getPositions(), system); ASSERT_EQUAL_VEC(cmPos, pos, 1e-2); Vec3 vel = calcCM(state.getVelocities(), system); ASSERT_EQUAL_VEC(Vec3(0, 0, 0), vel, 1e-2); } }
/** * Test an integrator with an AndersenThermostat to see if updateContextState() * is being handled correctly. */ void testWithThermostat() { const int numParticles = 8; const double temp = 100.0; const double collisionFreq = 20.0; const int numSteps = 5000; System system; CustomIntegrator integrator(0.003); integrator.addUpdateContextState(); integrator.addComputePerDof("v", "v+dt*f/m"); integrator.addComputePerDof("x", "x+dt*v"); NonbondedForce* forceField = new NonbondedForce(); for (int i = 0; i < numParticles; ++i) { system.addParticle(2.0); forceField->addParticle((i%2 == 0 ? 1.0 : -1.0), 1.0, 5.0); } system.addForce(forceField); AndersenThermostat* thermostat = new AndersenThermostat(temp, collisionFreq); system.addForce(thermostat); integrator.setRandomNumberSeed(thermostat->getRandomNumberSeed()); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); for (int i = 0; i < numParticles; ++i) positions[i] = Vec3((i%2 == 0 ? 2 : -2), (i%4 < 2 ? 2 : -2), (i < 4 ? 2 : -2)); context.setPositions(positions); context.setVelocitiesToTemperature(temp); // Let it equilibrate. integrator.step(10000); // Now run it for a while and see if the temperature is correct. double ke = 0.0; for (int i = 0; i < numSteps; ++i) { State state = context.getState(State::Energy); ke += state.getKineticEnergy(); integrator.step(10); } ke /= numSteps; double expected = 0.5*numParticles*3*BOLTZ*temp; ASSERT_USUALLY_EQUAL_TOL(expected, ke, 0.1); }
/** * Test the ComputeSum operation. */ void testSum() { const int numParticles = 200; const double boxSize = 10; System system; system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); NonbondedForce* nb = new NonbondedForce(); system.addForce(nb); vector<Vec3> positions(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; i++) { system.addParticle(i%10 == 0 ? 0.0 : 1.5); nb->addParticle(i%2 == 0 ? 0.1 : -0.1, 0.1, 1); bool close = true; while (close) { positions[i] = Vec3(boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt)); close = false; for (int j = 0; j < i; ++j) { Vec3 delta = positions[i]-positions[j]; if (delta.dot(delta) < 1) close = true; } } } CustomIntegrator integrator(0.005); integrator.addGlobalVariable("ke", 0); integrator.addComputePerDof("v", "v+dt*f/m"); integrator.addComputePerDof("x", "x+dt*v"); integrator.addComputeSum("ke", "m*v*v/2"); Context context(system, integrator, platform); context.setPositions(positions); // See if the sum is being computed correctly. for (int i = 0; i < 100; ++i) { State state = context.getState(State::Energy); ASSERT_EQUAL_TOL(state.getKineticEnergy(), integrator.getGlobalVariable(0), 1e-5); integrator.step(1); } }
void testChangingBoxSize() { ReferencePlatform platform; System system; system.setDefaultPeriodicBoxVectors(Vec3(4, 0, 0), Vec3(0, 5, 0), Vec3(0, 0, 6)); system.addParticle(1.0); NonbondedForce* nb = new NonbondedForce(); nb->setNonbondedMethod(NonbondedForce::CutoffPeriodic); nb->setCutoffDistance(2.0); nb->addParticle(1, 0.5, 0.5); system.addForce(nb); LangevinIntegrator integrator(300.0, 1.0, 0.01); Context context(system, integrator, platform); vector<Vec3> positions; positions.push_back(Vec3()); context.setPositions(positions); Vec3 x, y, z; context.getState(State::Forces).getPeriodicBoxVectors(x, y, z); ASSERT_EQUAL_VEC(Vec3(4, 0, 0), x, 0); ASSERT_EQUAL_VEC(Vec3(0, 5, 0), y, 0); ASSERT_EQUAL_VEC(Vec3(0, 0, 6), z, 0); context.setPeriodicBoxVectors(Vec3(7, 0, 0), Vec3(0, 8, 0), Vec3(0, 0, 9)); context.getState(State::Forces).getPeriodicBoxVectors(x, y, z); ASSERT_EQUAL_VEC(Vec3(7, 0, 0), x, 0); ASSERT_EQUAL_VEC(Vec3(0, 8, 0), y, 0); ASSERT_EQUAL_VEC(Vec3(0, 0, 9), z, 0); // Shrinking the box too small should produce an exception. context.setPeriodicBoxVectors(Vec3(7, 0, 0), Vec3(0, 3.9, 0), Vec3(0, 0, 9)); bool ok = true; try { context.getState(State::Forces).getPeriodicBoxVectors(x, y, z); ok = false; } catch (exception& ex) { } ASSERT(ok); }