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 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 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 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 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 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 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 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 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); } }
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 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); } }
/** * 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); } }
/** * 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); } }
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); } } } }
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 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 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); }
void testRandomSeed() { const int numParticles = 8; const double temp = 100.0; const double pressure = 1.5; ReferencePlatform platform; System system; system.setDefaultPeriodicBoxVectors(Vec3(8, 0, 0), Vec3(0, 8, 0), Vec3(0, 0, 8)); VerletIntegrator integrator(0.01); NonbondedForce* forceField = new NonbondedForce(); forceField->setNonbondedMethod(NonbondedForce::CutoffPeriodic); 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); MonteCarloBarostat* barostat = new MonteCarloBarostat(pressure, temp, 1); system.addForce(barostat); ASSERT(barostat->usesPeriodicBoundaryConditions()); ASSERT(system.usesPeriodicBoundaryConditions()); 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. barostat->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. barostat->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]); } } }
/** * Make sure that atom reordering respects virtual sites. */ void testReordering() { const double cutoff = 2.0; const double boxSize = 20.0; System system; NonbondedForce* nonbonded = new NonbondedForce(); system.addForce(nonbonded); nonbonded->setNonbondedMethod(NonbondedForce::CutoffNonPeriodic); nonbonded->setCutoffDistance(cutoff); vector<Vec3> positions; OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); // Create linear molecules with TwoParticleAverage virtual sites. for (int i = 0; i < 50; i++) { int start = system.getNumParticles(); system.addParticle(1.0); system.addParticle(1.0); system.addParticle(0.0); system.setVirtualSite(start+2, new TwoParticleAverageSite(start, start+1, 0.4, 0.6)); system.addConstraint(start, start+1, 2.0); for (int i = 0; i < 3; i++) { nonbonded->addParticle(0, 0.2, 1); for (int j = 0; j < i; j++) nonbonded->addException(start+i, start+j, 0, 1, 0); } Vec3 pos(boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt)); positions.push_back(pos); positions.push_back(pos+Vec3(2, 0, 0)); positions.push_back(Vec3()); } // Create planar molecules with ThreeParticleAverage virtual sites. for (int i = 0; i < 50; i++) { int start = system.getNumParticles(); system.addParticle(1.0); system.addParticle(1.0); system.addParticle(1.0); system.addParticle(0.0); system.setVirtualSite(start+3, new ThreeParticleAverageSite(start, start+1, start+2, 0.3, 0.5, 0.2)); system.addConstraint(start, start+1, 1.0); system.addConstraint(start, start+2, 1.0); system.addConstraint(start+1, start+2, sqrt(2.0)); for (int i = 0; i < 4; i++) { nonbonded->addParticle(0, 0.2, 1); for (int j = 0; j < i; j++) nonbonded->addException(start+i, start+j, 0, 1, 0); } Vec3 pos(boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt)); positions.push_back(pos); positions.push_back(pos+Vec3(1, 0, 0)); positions.push_back(pos+Vec3(0, 1, 0)); positions.push_back(Vec3()); } // Create tetrahedral molecules with OutOfPlane virtual sites. for (int i = 0; i < 50; i++) { int start = system.getNumParticles(); system.addParticle(1.0); system.addParticle(1.0); system.addParticle(1.0); system.addParticle(0.0); system.setVirtualSite(start+3, new OutOfPlaneSite(start, start+1, start+2, 0.3, 0.5, 0.2)); system.addConstraint(start, start+1, 1.0); system.addConstraint(start, start+2, 1.0); system.addConstraint(start+1, start+2, sqrt(2.0)); for (int i = 0; i < 4; i++) { nonbonded->addParticle(0, 0.2, 1); for (int j = 0; j < i; j++) nonbonded->addException(start+i, start+j, 0, 1, 0); } Vec3 pos(boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt)); positions.push_back(pos); positions.push_back(pos+Vec3(1, 0, 0)); positions.push_back(pos+Vec3(0, 1, 0)); positions.push_back(Vec3()); } // Simulate it and check conservation laws. LangevinIntegrator integrator(300.0, 0.1, 0.002); Context context(system, integrator, platform); context.setPositions(positions); context.applyConstraints(0.0001); for (int i = 0; i < 1000; i++) { State state = context.getState(State::Positions); const vector<Vec3>& pos = state.getPositions(); for (int j = 0; j < 150; j += 3) ASSERT_EQUAL_VEC(pos[j]*0.4+pos[j+1]*0.6, pos[j+2], 1e-5); for (int j = 150; j < 350; j += 4) ASSERT_EQUAL_VEC(pos[j]*0.3+pos[j+1]*0.5+pos[j+2]*0.2, pos[j+3], 1e-5); for (int j = 350; j < 550; j += 4) { Vec3 v12 = pos[j+1]-pos[j]; Vec3 v13 = pos[j+2]-pos[j]; Vec3 cross = v12.cross(v13); ASSERT_EQUAL_VEC(pos[j]+v12*0.3+v13*0.5+cross*0.2, pos[j+3], 1e-5); } integrator.step(1); } }
void testLongRangeCorrection() { // Create a box of particles. int gridSize = 5; int numParticles = gridSize*gridSize*gridSize; double boxSize = gridSize*0.7; double cutoff = boxSize/3; System standardSystem; System customSystem; VerletIntegrator integrator1(0.01); VerletIntegrator integrator2(0.01); NonbondedForce* standardNonbonded = new NonbondedForce(); CustomNonbondedForce* customNonbonded = new CustomNonbondedForce("4*eps*((sigma/r)^12-(sigma/r)^6); sigma=0.5*(sigma1+sigma2); eps=sqrt(eps1*eps2)"); customNonbonded->addPerParticleParameter("sigma"); customNonbonded->addPerParticleParameter("eps"); vector<Vec3> positions(numParticles); int index = 0; vector<double> params1(2); params1[0] = 1.1; params1[1] = 0.5; vector<double> params2(2); params2[0] = 1; params2[1] = 1; for (int i = 0; i < gridSize; i++) for (int j = 0; j < gridSize; j++) for (int k = 0; k < gridSize; k++) { standardSystem.addParticle(1.0); customSystem.addParticle(1.0); if (index%2 == 0) { standardNonbonded->addParticle(0, params1[0], params1[1]); customNonbonded->addParticle(params1); } else { standardNonbonded->addParticle(0, params2[0], params2[1]); customNonbonded->addParticle(params2); } positions[index] = Vec3(i*boxSize/gridSize, j*boxSize/gridSize, k*boxSize/gridSize); index++; } standardNonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic); customNonbonded->setNonbondedMethod(CustomNonbondedForce::CutoffPeriodic); standardNonbonded->setCutoffDistance(cutoff); customNonbonded->setCutoffDistance(cutoff); standardSystem.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); customSystem.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); standardNonbonded->setUseDispersionCorrection(true); customNonbonded->setUseLongRangeCorrection(true); standardNonbonded->setUseSwitchingFunction(true); customNonbonded->setUseSwitchingFunction(true); standardNonbonded->setSwitchingDistance(0.8*cutoff); customNonbonded->setSwitchingDistance(0.8*cutoff); standardSystem.addForce(standardNonbonded); customSystem.addForce(customNonbonded); // Compute the correction for the standard force. Context context1(standardSystem, integrator1, platform); context1.setPositions(positions); double standardEnergy1 = context1.getState(State::Energy).getPotentialEnergy(); standardNonbonded->setUseDispersionCorrection(false); context1.reinitialize(); context1.setPositions(positions); double standardEnergy2 = context1.getState(State::Energy).getPotentialEnergy(); // Compute the correction for the custom force. Context context2(customSystem, integrator2, platform); context2.setPositions(positions); double customEnergy1 = context2.getState(State::Energy).getPotentialEnergy(); customNonbonded->setUseLongRangeCorrection(false); context2.reinitialize(); context2.setPositions(positions); double customEnergy2 = context2.getState(State::Energy).getPotentialEnergy(); // See if they agree. ASSERT_EQUAL_TOL(standardEnergy1-standardEnergy2, customEnergy1-customEnergy2, 1e-4); }
void testWithBarostat() { const int gridSize = 3; const int numMolecules = gridSize*gridSize*gridSize; const int numParticles = numMolecules*2; const int numCopies = 5; const double spacing = 2.0; const double cutoff = 3.0; const double boxSize = spacing*(gridSize+1); const double temperature = 300.0; System system; system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); HarmonicBondForce* bonds = new HarmonicBondForce(); system.addForce(bonds); NonbondedForce* nonbonded = new NonbondedForce(); nonbonded->setCutoffDistance(cutoff); nonbonded->setNonbondedMethod(NonbondedForce::PME); nonbonded->setForceGroup(1); nonbonded->setReciprocalSpaceForceGroup(2); system.addForce(nonbonded); system.addForce(new MonteCarloBarostat(0.5, temperature)); // 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(-0.2, 0.2, 0.2); nonbonded->addParticle(0.2, 0.2, 0.2); nonbonded->addException(2*i, 2*i+1, 0, 1, 0); bonds->addBond(2*i, 2*i+1, 1.0, 10000.0); } RPMDIntegrator integ(numCopies, temperature, 50.0, 0.001); Platform& platform = Platform::getPlatformByName("Reference"); Context context(system, integ, platform); for (int copy = 0; copy < numCopies; copy++) { for (int i = 0; i < gridSize; i++) for (int j = 0; j < gridSize; j++) for (int k = 0; k < gridSize; k++) { Vec3 pos = Vec3(spacing*(i+0.02*genrand_real2(sfmt)), spacing*(j+0.02*genrand_real2(sfmt)), spacing*(k+0.02*genrand_real2(sfmt))); int index = k+gridSize*(j+gridSize*i); positions[2*index] = pos; positions[2*index+1] = Vec3(pos[0]+1.0, pos[1], pos[2]); } integ.setPositions(copy, positions); } // Check the temperature. const int numSteps = 500; integ.step(100); vector<double> ke(numCopies, 0.0); for (int i = 0; i < numSteps; i++) { integ.step(1); vector<State> state(numCopies); for (int j = 0; j < numCopies; j++) state[j] = integ.getState(j, State::Velocities, true); for (int j = 0; j < numParticles; j++) { for (int k = 0; k < numCopies; k++) { Vec3 v = state[k].getVelocities()[j]; ke[k] += 0.5*system.getParticleMass(j)*v.dot(v); } } } double meanKE = 0.0; for (int i = 0; i < numCopies; i++) meanKE += ke[i]; meanKE /= numSteps*numCopies; double expectedKE = 0.5*numCopies*numParticles*3*BOLTZ*temperature; ASSERT_USUALLY_EQUAL_TOL(expectedKE, meanKE, 1e-2); }
void testEnergyEthane(int applyBornRadiiScaling) { ReferencePlatform platform; const int numParticles = 8; System system; LangevinIntegrator integrator(0, 0.1, 0.01); // harmonic bond double C_HBondDistance = 0.1097; double C_CBondDistance = 0.1504; HarmonicBondForce* bonds = new HarmonicBondForce(); bonds->addBond(0, 1, C_HBondDistance, 0.0); bonds->addBond(2, 1, C_HBondDistance, 0.0); bonds->addBond(3, 1, C_HBondDistance, 0.0); bonds->addBond(1, 4, C_CBondDistance, 0.0); bonds->addBond(5, 4, C_HBondDistance, 0.0); bonds->addBond(6, 4, C_HBondDistance, 0.0); bonds->addBond(7, 4, C_HBondDistance, 0.0); system.addForce(bonds); double C_radius, C_gamma, C_charge, H_radius, H_gamma, H_charge; int AM1_BCC = 1; H_charge = -0.053; C_charge = -3.0*H_charge; if (AM1_BCC) { C_radius = 0.180; C_gamma = -0.2863; H_radius = 0.125; H_gamma = 0.2437; } else { C_radius = 0.215; C_gamma = -1.1087; H_radius = 0.150; H_gamma = 0.1237; } NonbondedForce* nonbonded = new NonbondedForce(); nonbonded->setNonbondedMethod(NonbondedForce::NoCutoff); GBVIForce* forceField = new GBVIForce(); if (applyBornRadiiScaling) { forceField->setBornRadiusScalingMethod(GBVIForce::QuinticSpline); } else { forceField->setBornRadiusScalingMethod(GBVIForce::NoScaling); } for (int i = 0; i < numParticles; i++) { system.addParticle(1.0); forceField->addParticle(H_charge, H_radius, H_gamma); nonbonded->addParticle( H_charge, H_radius, 0.0); } forceField->setParticleParameters(1, C_charge, C_radius, C_gamma); forceField->setParticleParameters(4, C_charge, C_radius, C_gamma); nonbonded->setParticleParameters( 1, C_charge, C_radius, 0.0); nonbonded->setParticleParameters( 4, C_charge, C_radius, 0.0); forceField->addBond(0, 1, C_HBondDistance); forceField->addBond(2, 1, C_HBondDistance); forceField->addBond(3, 1, C_HBondDistance); forceField->addBond(1, 4, C_CBondDistance); forceField->addBond(5, 4, C_HBondDistance); forceField->addBond(6, 4, C_HBondDistance); forceField->addBond(7, 4, C_HBondDistance); std::vector<pair<int, int> > bondExceptions; std::vector<double> bondDistances; bondExceptions.push_back(pair<int, int>(0, 1)); bondDistances.push_back(C_HBondDistance); bondExceptions.push_back(pair<int, int>(2, 1)); bondDistances.push_back(C_HBondDistance); bondExceptions.push_back(pair<int, int>(3, 1)); bondDistances.push_back(C_HBondDistance); bondExceptions.push_back(pair<int, int>(1, 4)); bondDistances.push_back(C_CBondDistance); bondExceptions.push_back(pair<int, int>(5, 4)); bondDistances.push_back(C_HBondDistance); bondExceptions.push_back(pair<int, int>(6, 4)); bondDistances.push_back(C_HBondDistance); bondExceptions.push_back(pair<int, int>(7, 4)); bondDistances.push_back(C_HBondDistance); nonbonded->createExceptionsFromBonds(bondExceptions, 0.0, 0.0); system.addForce(forceField); system.addForce(nonbonded); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); positions[0] = Vec3(0.5480, 1.7661, 0.0000); positions[1] = Vec3(0.7286, 0.8978, 0.6468); positions[2] = Vec3(0.4974, 0.0000, 0.0588); positions[3] = Vec3(0.0000, 0.9459, 1.4666); positions[4] = Vec3(2.1421, 0.8746, 1.1615); positions[5] = Vec3(2.3239, 0.0050, 1.8065); positions[6] = Vec3(2.8705, 0.8295, 0.3416); positions[7] = Vec3(2.3722, 1.7711, 1.7518); context.setPositions(positions); State state = context.getState(State::Forces | State::Energy); // Take a small step in the direction of the energy gradient. double norm = 0.0; double forceSum[3] = { 0.0, 0.0, 0.0 }; for (int i = 0; i < numParticles; ++i) { Vec3 f = state.getForces()[i]; norm += f[0]*f[0] + f[1]*f[1] + f[2]*f[2]; forceSum[0] += f[0]; forceSum[1] += f[1]; forceSum[2] += f[2]; } norm = std::sqrt(norm); const double delta = 1e-4; double step = delta/norm; for (int i = 0; i < numParticles; ++i) { Vec3 p = positions[i]; Vec3 f = state.getForces()[i]; positions[i] = Vec3(p[0]-f[0]*step, p[1]-f[1]*step, p[2]-f[2]*step); } context.setPositions(positions); State state2 = context.getState(State::Energy); // See whether the potential energy changed by the expected amount. ASSERT_EQUAL_TOL(norm, (state2.getPotentialEnergy()-state.getPotentialEnergy())/delta, 0.01) }
void testCoulombLennardJones() { const int numMolecules = 300; const int numParticles = numMolecules*2; const double boxSize = 20.0; // Create two systems: one with a NonbondedForce, and one using a CustomNonbondedForce to implement the same interaction. System standardSystem; System customSystem; for (int i = 0; i < numParticles; i++) { standardSystem.addParticle(1.0); customSystem.addParticle(1.0); } NonbondedForce* standardNonbonded = new NonbondedForce(); CustomNonbondedForce* customNonbonded = new CustomNonbondedForce("4*eps*((sigma/r)^12-(sigma/r)^6)+138.935456*q/r; q=q1*q2; sigma=0.5*(sigma1+sigma2); eps=sqrt(eps1*eps2)"); customNonbonded->addPerParticleParameter("q"); customNonbonded->addPerParticleParameter("sigma"); customNonbonded->addPerParticleParameter("eps"); vector<Vec3> positions(numParticles); vector<Vec3> velocities(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); vector<double> params(3); for (int i = 0; i < numMolecules; i++) { if (i < numMolecules/2) { standardNonbonded->addParticle(1.0, 0.2, 0.1); params[0] = 1.0; params[1] = 0.2; params[2] = 0.1; customNonbonded->addParticle(params); standardNonbonded->addParticle(-1.0, 0.1, 0.1); params[0] = -1.0; params[1] = 0.1; customNonbonded->addParticle(params); } else { standardNonbonded->addParticle(1.0, 0.2, 0.2); params[0] = 1.0; params[1] = 0.2; params[2] = 0.2; customNonbonded->addParticle(params); standardNonbonded->addParticle(-1.0, 0.1, 0.2); params[0] = -1.0; params[1] = 0.1; customNonbonded->addParticle(params); } 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]); velocities[2*i] = Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt)); velocities[2*i+1] = Vec3(genrand_real2(sfmt), genrand_real2(sfmt), genrand_real2(sfmt)); standardNonbonded->addException(2*i, 2*i+1, 0.0, 1.0, 0.0); customNonbonded->addExclusion(2*i, 2*i+1); } standardNonbonded->setNonbondedMethod(NonbondedForce::NoCutoff); customNonbonded->setNonbondedMethod(CustomNonbondedForce::NoCutoff); standardSystem.addForce(standardNonbonded); customSystem.addForce(customNonbonded); VerletIntegrator integrator1(0.01); VerletIntegrator integrator2(0.01); Context context1(standardSystem, integrator1, platform); Context context2(customSystem, integrator2, platform); context1.setPositions(positions); context2.setPositions(positions); context1.setVelocities(velocities); context2.setVelocities(velocities); State state1 = context1.getState(State::Forces | State::Energy); State state2 = context2.getState(State::Forces | State::Energy); ASSERT_EQUAL_TOL(state1.getPotentialEnergy(), state2.getPotentialEnergy(), 1e-4); for (int i = 0; i < numParticles; i++) { ASSERT_EQUAL_VEC(state1.getForces()[i], state2.getForces()[i], 1e-4); } }
void testWater() { // Create a box of SWM4-NDP water molecules. This involves constraints, virtual sites, // and Drude particles. const int gridSize = 3; const int numMolecules = gridSize*gridSize*gridSize; const double spacing = 0.6; const double boxSize = spacing*(gridSize+1); System system; 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::CutoffPeriodic); nonbonded->setCutoffDistance(1.0); for (int i = 0; i < numMolecules; i++) { int startIndex = system.getNumParticles(); system.addParticle(15.6); // O system.addParticle(0.4); // D system.addParticle(1.0); // H1 system.addParticle(1.0); // H2 system.addParticle(0.0); // M nonbonded->addParticle(1.71636, 0.318395, 0.21094*4.184); nonbonded->addParticle(-1.71636, 1, 0); nonbonded->addParticle(0.55733, 1, 0); nonbonded->addParticle(0.55733, 1, 0); nonbonded->addParticle(-1.11466, 1, 0); for (int j = 0; j < 5; j++) for (int k = 0; k < j; k++) nonbonded->addException(startIndex+j, startIndex+k, 0, 1, 0); system.addConstraint(startIndex, startIndex+2, 0.09572); system.addConstraint(startIndex, startIndex+3, 0.09572); system.addConstraint(startIndex+2, startIndex+3, 0.15139); system.setVirtualSite(startIndex+4, new ThreeParticleAverageSite(startIndex, startIndex+2, startIndex+3, 0.786646558, 0.106676721, 0.106676721)); drude->addParticle(startIndex+1, startIndex, -1, -1, -1, -1.71636, ONE_4PI_EPS0*1.71636*1.71636/(100000*4.184), 1, 1); } vector<Vec3> positions; 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); positions.push_back(pos+Vec3(0.09572, 0, 0)); positions.push_back(pos+Vec3(-0.023999, 0.092663, 0)); positions.push_back(pos); } // Simulate it and check energy conservation and the total force on the Drude particles. DrudeSCFIntegrator integ(0.0005); Platform& platform = Platform::getPlatformByName("Reference"); Context context(system, integ, platform); context.setPositions(positions); context.applyConstraints(1e-5); context.setVelocitiesToTemperature(300.0); State state = context.getState(State::Energy); double initialEnergy; int numSteps = 1000; for (int i = 0; i < numSteps; i++) { integ.step(1); state = context.getState(State::Energy | State::Forces); if (i == 0) initialEnergy = state.getPotentialEnergy()+state.getKineticEnergy(); else ASSERT_EQUAL_TOL(initialEnergy, state.getPotentialEnergy()+state.getKineticEnergy(), 0.01); const vector<Vec3>& force = state.getForces(); double norm = 0.0; for (int j = 1; j < (int) force.size(); j += 5) norm += sqrt(force[j].dot(force[j])); norm = (norm/numMolecules); ASSERT(norm < 1.0); } }
/** * Run a constant pressure simulation on an anisotropic Einstein crystal * using isotropic and anisotropic barostats. There are a total of 15 simulations: * * 1) 3 pressures: 9.0, 10.0, 11.0 bar, for each of the following groups: * 2) 3 groups of simulations that scale just one axis: x, y, z * 3) 1 group of simulations that scales all three axes in the anisotropic barostat * 4) 1 group of simulations that scales all three axes in the isotropic barostat * * Results that we will check: * * a) In each group of simulations, the volume should decrease with increasing pressure * b) In the three simulation groups that scale just one axis, the compressibility (i.e. incremental volume change * with increasing pressure) should go like kx > ky > kz (because the spring constant is largest in the z-direction) * c) The anisotropic barostat should produce the same result as the isotropic barostat when all three axes are scaled */ void testEinsteinCrystal() { const int numParticles = 64; const int frequency = 2; const int equil = 10000; const int steps = 5000; const double pressure = 10.0; const double pressureInMD = pressure*(AVOGADRO*1e-25); // pressure in kJ/mol/nm^3 const double temp = 300.0; // Only test one temperature since we're looking at three pressures. const double pres3[] = {2.0, 8.0, 15.0}; const double initialVolume = numParticles*BOLTZ*temp/pressureInMD; const double initialLength = std::pow(initialVolume, 1.0/3.0); vector<double> initialPositions(3); vector<double> results; // Run four groups of anisotropic simulations; scaling just x, y, z, then all three. for (int a = 0; a < 4; a++) { // Test barostat for three different pressures. for (int p = 0; p < 3; p++) { // Create a system of noninteracting particles attached by harmonic springs to their initial positions. System system; system.setDefaultPeriodicBoxVectors(Vec3(initialLength, 0, 0), Vec3(0, initialLength, 0), Vec3(0, 0, initialLength)); vector<Vec3> positions(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); // Anisotropic force constants. CustomExternalForce* force = new CustomExternalForce("0.005*(x-x0)^2 + 0.01*(y-y0)^2 + 0.02*(z-z0)^2"); force->addPerParticleParameter("x0"); force->addPerParticleParameter("y0"); force->addPerParticleParameter("z0"); NonbondedForce* nb = new NonbondedForce(); nb->setNonbondedMethod(NonbondedForce::CutoffPeriodic); for (int i = 0; i < numParticles; ++i) { system.addParticle(1.0); positions[i] = Vec3(((i/16)%4+0.5)*initialLength/4, ((i/4)%4+0.5)*initialLength/4, (i%4+0.5)*initialLength/4); initialPositions[0] = positions[i][0]; initialPositions[1] = positions[i][1]; initialPositions[2] = positions[i][2]; force->addParticle(i, initialPositions); nb->addParticle(0, initialLength/6, 0.1); } system.addForce(force); system.addForce(nb); // Create the barostat. MonteCarloAnisotropicBarostat* barostat = new MonteCarloAnisotropicBarostat(Vec3(pres3[p], pres3[p], pres3[p]), temp, (a==0||a==3), (a==1||a==3), (a==2||a==3), frequency); system.addForce(barostat); barostat->setTemperature(temp); LangevinIntegrator integrator(temp, 0.1, 0.01); Context context(system, integrator, platform); context.setPositions(positions); // Let it equilibrate. integrator.step(equil); // Now run it for a while and see if the volume is correct. double volume = 0.0; for (int j = 0; j < steps; ++j) { Vec3 box[3]; context.getState(0).getPeriodicBoxVectors(box[0], box[1], box[2]); volume += box[0][0]*box[1][1]*box[2][2]; integrator.step(frequency); } volume /= steps; results.push_back(volume); } } for (int p = 0; p < 3; p++) { // Create a system of noninteracting particles attached by harmonic springs to their initial positions. System system; system.setDefaultPeriodicBoxVectors(Vec3(initialLength, 0, 0), Vec3(0, initialLength, 0), Vec3(0, 0, initialLength)); vector<Vec3> positions(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); // Anisotropic force constants. CustomExternalForce* force = new CustomExternalForce("0.005*(x-x0)^2 + 0.01*(y-y0)^2 + 0.02*(z-z0)^2"); force->addPerParticleParameter("x0"); force->addPerParticleParameter("y0"); force->addPerParticleParameter("z0"); NonbondedForce* nb = new NonbondedForce(); nb->setNonbondedMethod(NonbondedForce::CutoffPeriodic); for (int i = 0; i < numParticles; ++i) { system.addParticle(1.0); positions[i] = Vec3(((i/16)%4+0.5)*initialLength/4, ((i/4)%4+0.5)*initialLength/4, (i%4+0.5)*initialLength/4); initialPositions[0] = positions[i][0]; initialPositions[1] = positions[i][1]; initialPositions[2] = positions[i][2]; force->addParticle(i, initialPositions); nb->addParticle(0, initialLength/6, 0.1); } system.addForce(force); system.addForce(nb); // Create the barostat. MonteCarloBarostat* barostat = new MonteCarloBarostat(pres3[p], temp, frequency); system.addForce(barostat); barostat->setTemperature(temp); LangevinIntegrator integrator(temp, 0.1, 0.001); Context context(system, integrator, platform); context.setPositions(positions); // Let it equilibrate. integrator.step(equil); // Now run it for a while and see if the volume is correct. double volume = 0.0; for (int j = 0; j < steps; ++j) { Vec3 box[3]; context.getState(0).getPeriodicBoxVectors(box[0], box[1], box[2]); volume += box[0][0]*box[1][1]*box[2][2]; integrator.step(frequency); } volume /= steps; results.push_back(volume); } // Check to see if volumes decrease with increasing pressure. ASSERT_USUALLY_TRUE(results[0] > results[1]); ASSERT_USUALLY_TRUE(results[1] > results[2]); ASSERT_USUALLY_TRUE(results[3] > results[4]); ASSERT_USUALLY_TRUE(results[4] > results[5]); ASSERT_USUALLY_TRUE(results[6] > results[7]); ASSERT_USUALLY_TRUE(results[7] > results[8]); // Check to see if incremental volume changes with increasing pressure go like kx > ky > kz. ASSERT_USUALLY_TRUE((results[0] - results[1]) > (results[3] - results[4])); ASSERT_USUALLY_TRUE((results[1] - results[2]) > (results[4] - results[5])); ASSERT_USUALLY_TRUE((results[3] - results[4]) > (results[6] - results[7])); ASSERT_USUALLY_TRUE((results[4] - results[5]) > (results[7] - results[8])); // Check to see if the volumes are equal for isotropic and anisotropic (all axis). ASSERT_USUALLY_EQUAL_TOL(results[9], results[12], 3/std::sqrt((double) steps)); ASSERT_USUALLY_EQUAL_TOL(results[10], results[13], 3/std::sqrt((double) steps)); ASSERT_USUALLY_EQUAL_TOL(results[11], results[14], 3/std::sqrt((double) steps)); }
void testSerialization() { // Create a Force. NonbondedForce force; force.setForceGroup(3); force.setNonbondedMethod(NonbondedForce::CutoffPeriodic); force.setSwitchingDistance(1.5); force.setUseSwitchingFunction(true); force.setCutoffDistance(2.0); force.setEwaldErrorTolerance(1e-3); force.setReactionFieldDielectric(50.0); force.setUseDispersionCorrection(false); double alpha = 0.5; int nx = 3, ny = 5, nz = 7; force.setPMEParameters(alpha, nx, ny, nz); double dalpha = 0.8; int dnx = 4, dny = 6, dnz = 7; force.setLJPMEParameters(dalpha, dnx, dny, dnz); 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); force.addGlobalParameter("scale1", 1.0); force.addGlobalParameter("scale2", 2.0); force.addParticleParameterOffset("scale1", 2, 1.5, 2.0, 2.5); force.addExceptionParameterOffset("scale2", 1, -0.1, -0.2, -0.3); // 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.getForceGroup(), force2.getForceGroup()); ASSERT_EQUAL(force.getNonbondedMethod(), force2.getNonbondedMethod()); ASSERT_EQUAL(force.getSwitchingDistance(), force2.getSwitchingDistance()); ASSERT_EQUAL(force.getUseSwitchingFunction(), force2.getUseSwitchingFunction()); 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()); ASSERT_EQUAL(force.getNumExceptions(), force2.getNumExceptions()); ASSERT_EQUAL(force.getNumGlobalParameters(), force2.getNumGlobalParameters()); ASSERT_EQUAL(force.getNumParticleParameterOffsets(), force2.getNumParticleParameterOffsets()); ASSERT_EQUAL(force.getNumExceptionParameterOffsets(), force2.getNumExceptionParameterOffsets()); double alpha2; int nx2, ny2, nz2; force2.getPMEParameters(alpha2, nx2, ny2, nz2); ASSERT_EQUAL(alpha, alpha2); ASSERT_EQUAL(nx, nx2); ASSERT_EQUAL(ny, ny2); ASSERT_EQUAL(nz, nz2); double dalpha2; int dnx2, dny2, dnz2; force2.getLJPMEParameters(dalpha2, dnx2, dny2, dnz2); ASSERT_EQUAL(dalpha, dalpha2); ASSERT_EQUAL(dnx, dnx2); ASSERT_EQUAL(dny, dny2); ASSERT_EQUAL(dnz, dnz2); for (int i = 0; i < force.getNumGlobalParameters(); i++) { ASSERT_EQUAL(force.getGlobalParameterName(i), force2.getGlobalParameterName(i)); ASSERT_EQUAL(force.getGlobalParameterDefaultValue(i), force2.getGlobalParameterDefaultValue(i)); } for (int i = 0; i < force.getNumParticleParameterOffsets(); i++) { int index1, index2; string param1, param2; double charge1, sigma1, epsilon1; double charge2, sigma2, epsilon2; force.getParticleParameterOffset(i, param1, index1, charge1, sigma1, epsilon1); force2.getParticleParameterOffset(i, param2, index2, charge2, sigma2, epsilon2); ASSERT_EQUAL(index1, index1); ASSERT_EQUAL(param1, param2); ASSERT_EQUAL(charge1, charge2); ASSERT_EQUAL(sigma1, sigma2); ASSERT_EQUAL(epsilon1, epsilon2); } for (int i = 0; i < force.getNumExceptionParameterOffsets(); i++) { int index1, index2; string param1, param2; double charge1, sigma1, epsilon1; double charge2, sigma2, epsilon2; force.getExceptionParameterOffset(i, param1, index1, charge1, sigma1, epsilon1); force2.getExceptionParameterOffset(i, param2, index2, charge2, sigma2, epsilon2); ASSERT_EQUAL(index1, index1); ASSERT_EQUAL(param1, param2); ASSERT_EQUAL(charge1, charge2); ASSERT_EQUAL(sigma1, sigma2); ASSERT_EQUAL(epsilon1, epsilon2); } 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 testEwaldPME(bool includeExceptions) { // Use amorphous NaCl system for the tests const int numParticles = 894; const double cutoff = 1.2; const double boxSize = 3.00646; double tol = 1e-5; ReferencePlatform reference; System system; NonbondedForce* nonbonded = new NonbondedForce(); nonbonded->setNonbondedMethod(NonbondedForce::Ewald); nonbonded->setCutoffDistance(cutoff); nonbonded->setEwaldErrorTolerance(tol); for (int i = 0; i < numParticles/2; i++) system.addParticle(22.99); for (int i = 0; i < numParticles/2; i++) system.addParticle(35.45); 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); system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); system.addForce(nonbonded); vector<Vec3> positions(numParticles); #include "nacl_amorph.dat" if (includeExceptions) { // Add some exclusions. for (int i = 0; i < numParticles-1; i++) { Vec3 delta = positions[i]-positions[i+1]; if (sqrt(delta.dot(delta)) < 0.5*cutoff) nonbonded->addException(i, i+1, i%2 == 0 ? 0.0 : 0.5, 1.0, 0.0); } } // (1) Check whether the Reference and CPU platforms agree when using Ewald Method VerletIntegrator integrator1(0.01); VerletIntegrator integrator2(0.01); Context cpuContext(system, integrator1, platform); Context referenceContext(system, integrator2, reference); cpuContext.setPositions(positions); referenceContext.setPositions(positions); State cpuState = cpuContext.getState(State::Forces | State::Energy); State referenceState = referenceContext.getState(State::Forces | State::Energy); tol = 1e-2; for (int i = 0; i < numParticles; i++) { ASSERT_EQUAL_VEC(referenceState.getForces()[i], cpuState.getForces()[i], tol); } tol = 1e-5; ASSERT_EQUAL_TOL(referenceState.getPotentialEnergy(), cpuState.getPotentialEnergy(), tol); // (2) Check whether Ewald method in CPU is self-consistent double norm = 0.0; for (int i = 0; i < numParticles; ++i) { Vec3 f = cpuState.getForces()[i]; norm += f[0]*f[0] + f[1]*f[1] + f[2]*f[2]; } norm = std::sqrt(norm); const double delta = 5e-3; double step = delta/norm; for (int i = 0; i < numParticles; ++i) { Vec3 p = positions[i]; Vec3 f = cpuState.getForces()[i]; positions[i] = Vec3(p[0]-f[0]*step, p[1]-f[1]*step, p[2]-f[2]*step); } VerletIntegrator integrator3(0.01); Context cpuContext2(system, integrator3, platform); cpuContext2.setPositions(positions); tol = 1e-2; State cpuState2 = cpuContext2.getState(State::Energy); ASSERT_EQUAL_TOL(norm, (cpuState2.getPotentialEnergy()-cpuState.getPotentialEnergy())/delta, tol) // (3) Check whether the Reference and CPU platforms agree when using PME nonbonded->setNonbondedMethod(NonbondedForce::PME); cpuContext.reinitialize(); referenceContext.reinitialize(); cpuContext.setPositions(positions); referenceContext.setPositions(positions); cpuState = cpuContext.getState(State::Forces | State::Energy); referenceState = referenceContext.getState(State::Forces | State::Energy); tol = 1e-2; for (int i = 0; i < numParticles; i++) { ASSERT_EQUAL_VEC(referenceState.getForces()[i], cpuState.getForces()[i], tol); } tol = 1e-5; ASSERT_EQUAL_TOL(referenceState.getPotentialEnergy(), cpuState.getPotentialEnergy(), tol); // (4) Check whether PME method in CPU is self-consistent norm = 0.0; for (int i = 0; i < numParticles; ++i) { Vec3 f = cpuState.getForces()[i]; norm += f[0]*f[0] + f[1]*f[1] + f[2]*f[2]; } norm = std::sqrt(norm); step = delta/norm; for (int i = 0; i < numParticles; ++i) { Vec3 p = positions[i]; Vec3 f = cpuState.getForces()[i]; positions[i] = Vec3(p[0]-f[0]*step, p[1]-f[1]*step, p[2]-f[2]*step); } VerletIntegrator integrator4(0.01); Context cpuContext3(system, integrator4, platform); cpuContext3.setPositions(positions); tol = 1e-2; State cpuState3 = cpuContext3.getState(State::Energy); ASSERT_EQUAL_TOL(norm, (cpuState3.getPotentialEnergy()-cpuState.getPotentialEnergy())/delta, tol) }
void testWater() { // Create a box of SWM4-NDP water molecules. This involves constraints, virtual sites, // and Drude particles. const int gridSize = 3; const int numMolecules = 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; 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::CutoffPeriodic); nonbonded->setCutoffDistance(1.0); for (int i = 0; i < numMolecules; i++) { int startIndex = system.getNumParticles(); system.addParticle(15.6); // O system.addParticle(0.4); // D system.addParticle(1.0); // H1 system.addParticle(1.0); // H2 system.addParticle(0.0); // M nonbonded->addParticle(1.71636, 0.318395, 0.21094*4.184); nonbonded->addParticle(-1.71636, 1, 0); nonbonded->addParticle(0.55733, 1, 0); nonbonded->addParticle(0.55733, 1, 0); nonbonded->addParticle(-1.11466, 1, 0); for (int j = 0; j < 5; j++) for (int k = 0; k < j; k++) nonbonded->addException(startIndex+j, startIndex+k, 0, 1, 0); system.addConstraint(startIndex, startIndex+2, 0.09572); system.addConstraint(startIndex, startIndex+3, 0.09572); system.addConstraint(startIndex+2, startIndex+3, 0.15139); system.setVirtualSite(startIndex+4, new ThreeParticleAverageSite(startIndex, startIndex+2, startIndex+3, 0.786646558, 0.106676721, 0.106676721)); drude->addParticle(startIndex+1, startIndex, -1, -1, -1, -1.71636, ONE_4PI_EPS0*1.71636*1.71636/(100000*4.184), 1, 1); } vector<Vec3> positions; 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); positions.push_back(pos+Vec3(0.09572, 0, 0)); positions.push_back(pos+Vec3(-0.023999, 0.092663, 0)); positions.push_back(pos); } // Simulate it and check the temperature. DrudeLangevinIntegrator integ(temperature, 50.0, temperatureDrude, 50.0, 0.0005); Platform& platform = Platform::getPlatformByName("Reference"); Context context(system, integ, platform); context.setPositions(positions); context.applyConstraints(1e-5); // Equilibrate. integ.step(500); // Compute the internal and center of mass temperatures. double ke = 0; int numSteps = 4000; for (int i = 0; i < numSteps; i++) { integ.step(1); ke += context.getState(State::Energy).getKineticEnergy(); } ke /= numSteps; int numStandardDof = 3*3*numMolecules-system.getNumConstraints(); int numDrudeDof = 3*numMolecules; int numDof = numStandardDof+numDrudeDof; double expectedTemp = (numStandardDof*temperature+numDrudeDof*temperatureDrude)/numDof; ASSERT_USUALLY_EQUAL_TOL(expectedTemp, ke/(0.5*numDof*BOLTZ), 0.03); }