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 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 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 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 testLJPME(bool triclinic) { // Create a cloud of random LJ particles. const int numParticles = 51; const double boxWidth = 5.0; const double cutoff = 1.0; const double alpha = 2.91842; Vec3 boxVectors[3]; if (triclinic) { boxVectors[0] = Vec3(boxWidth, 0, 0); boxVectors[1] = Vec3(0.2*boxWidth, boxWidth, 0); boxVectors[2] = Vec3(-0.3*boxWidth, -0.1*boxWidth, boxWidth); } else { boxVectors[0] = Vec3(boxWidth, 0, 0); boxVectors[1] = Vec3(0, boxWidth, 0); boxVectors[2] = Vec3(0, 0, boxWidth); } System system; system.setDefaultPeriodicBoxVectors(boxVectors[0], boxVectors[1], boxVectors[2]); 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(0, 0.5, 1.0); positions[i] = Vec3(boxWidth*genrand_real2(sfmt), boxWidth*genrand_real2(sfmt), boxWidth*genrand_real2(sfmt)); } force->setNonbondedMethod(NonbondedForce::LJPME); force->setCutoffDistance(cutoff); force->setReciprocalSpaceForceGroup(1); force->setLJPMEParameters(alpha, 64, 64, 64); // Compute the reciprocal space forces with the reference platform. Platform& platform = Platform::getPlatformByName("Reference"); VerletIntegrator integrator(0.01); Context context(system, integrator, platform); context.setPositions(positions); State refState = context.getState(State::Forces | State::Energy, false, 1<<1); // Now compute them with the optimized kernel. CpuCalcDispersionPmeReciprocalForceKernel pme(CalcDispersionPmeReciprocalForceKernel::Name(), platform); IO io; double ewaldSelfEnergy = 0; for (int i = 0; i < numParticles; i++) { io.posq.push_back(positions[i][0]); io.posq.push_back(positions[i][1]); io.posq.push_back(positions[i][2]); double charge, sigma, epsilon; force->getParticleParameters(i, charge, sigma, epsilon); io.posq.push_back(pow(sigma, 3.0) * 2.0*sqrt(epsilon)); ewaldSelfEnergy += pow(alpha*sigma, 6.0) * epsilon / 3.0; } pme.initialize(64, 64, 64, numParticles, alpha, true); pme.beginComputation(io, boxVectors, true); double energy = pme.finishComputation(io); // See if they match. ASSERT_EQUAL_TOL(refState.getPotentialEnergy(), energy+ewaldSelfEnergy, 1e-3); for (int i = 0; i < numParticles; i++) ASSERT_EQUAL_VEC(refState.getForces()[i], Vec3(io.force[4*i], io.force[4*i+1], io.force[4*i+2]), 1e-3); }
/** * 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 testLargeSystem() { const int numMolecules = 600; const int numParticles = numMolecules*2; const double cutoff = 2.0; const double boxSize = 20.0; const double tol = 2e-3; ReferencePlatform reference; System system; for (int i = 0; i < numParticles; i++) system.addParticle(1.0); NonbondedForce* nonbonded = new NonbondedForce(); HarmonicBondForce* bonds = new HarmonicBondForce(); vector<Vec3> positions(numParticles); vector<Vec3> velocities(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numMolecules; i++) { if (i < numMolecules/2) { nonbonded->addParticle(-1.0, 0.2, 0.1); nonbonded->addParticle(1.0, 0.1, 0.1); } else { nonbonded->addParticle(-1.0, 0.2, 0.2); nonbonded->addParticle(1.0, 0.1, 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]); 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)); bonds->addBond(2*i, 2*i+1, 1.0, 0.1); nonbonded->addException(2*i, 2*i+1, 0.0, 0.15, 0.0); } // Try with cutoffs but not periodic boundary conditions, and make sure the cl and Reference // platforms agree. nonbonded->setNonbondedMethod(NonbondedForce::CutoffNonPeriodic); nonbonded->setCutoffDistance(cutoff); system.addForce(nonbonded); system.addForce(bonds); VerletIntegrator integrator1(0.01); VerletIntegrator integrator2(0.01); Context cuContext(system, integrator1, platform); Context referenceContext(system, integrator2, reference); cuContext.setPositions(positions); cuContext.setVelocities(velocities); referenceContext.setPositions(positions); referenceContext.setVelocities(velocities); State cuState = cuContext.getState(State::Positions | State::Velocities | State::Forces | State::Energy); State referenceState = referenceContext.getState(State::Positions | State::Velocities | State::Forces | State::Energy); for (int i = 0; i < numParticles; i++) { ASSERT_EQUAL_VEC(cuState.getPositions()[i], referenceState.getPositions()[i], tol); ASSERT_EQUAL_VEC(cuState.getVelocities()[i], referenceState.getVelocities()[i], tol); ASSERT_EQUAL_VEC(cuState.getForces()[i], referenceState.getForces()[i], tol); } ASSERT_EQUAL_TOL(cuState.getPotentialEnergy(), referenceState.getPotentialEnergy(), tol); // Now do the same thing with periodic boundary conditions. nonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic); system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); cuContext.reinitialize(); referenceContext.reinitialize(); cuContext.setPositions(positions); cuContext.setVelocities(velocities); referenceContext.setPositions(positions); referenceContext.setVelocities(velocities); cuState = cuContext.getState(State::Positions | State::Velocities | State::Forces | State::Energy); referenceState = referenceContext.getState(State::Positions | State::Velocities | State::Forces | State::Energy); for (int i = 0; i < numParticles; i++) { double dx = cuState.getPositions()[i][0]-referenceState.getPositions()[i][0]; double dy = cuState.getPositions()[i][1]-referenceState.getPositions()[i][1]; double dz = cuState.getPositions()[i][2]-referenceState.getPositions()[i][2]; ASSERT_EQUAL_TOL(fmod(cuState.getPositions()[i][0]-referenceState.getPositions()[i][0], boxSize), 0, tol); ASSERT_EQUAL_TOL(fmod(cuState.getPositions()[i][1]-referenceState.getPositions()[i][1], boxSize), 0, tol); ASSERT_EQUAL_TOL(fmod(cuState.getPositions()[i][2]-referenceState.getPositions()[i][2], boxSize), 0, tol); ASSERT_EQUAL_VEC(cuState.getVelocities()[i], referenceState.getVelocities()[i], tol); ASSERT_EQUAL_VEC(cuState.getForces()[i], referenceState.getForces()[i], tol); } ASSERT_EQUAL_TOL(cuState.getPotentialEnergy(), referenceState.getPotentialEnergy(), tol); }
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 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); } }
void testDispersionCorrection() { // Create a box full of identical particles. int gridSize = 5; int numParticles = gridSize*gridSize*gridSize; double boxSize = gridSize*0.7; double cutoff = boxSize/3; System system; VerletIntegrator integrator(0.01); NonbondedForce* nonbonded = new NonbondedForce(); vector<Vec3> positions(numParticles); int index = 0; for (int i = 0; i < gridSize; i++) for (int j = 0; j < gridSize; j++) for (int k = 0; k < gridSize; k++) { system.addParticle(1.0); nonbonded->addParticle(0, 1.1, 0.5); positions[index] = Vec3(i*boxSize/gridSize, j*boxSize/gridSize, k*boxSize/gridSize); index++; } nonbonded->setNonbondedMethod(NonbondedForce::CutoffPeriodic); nonbonded->setCutoffDistance(cutoff); system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); system.addForce(nonbonded); // See if the correction has the correct value. Context context(system, integrator, platform); context.setPositions(positions); double energy1 = context.getState(State::Energy).getPotentialEnergy(); nonbonded->setUseDispersionCorrection(false); context.reinitialize(); context.setPositions(positions); double energy2 = context.getState(State::Energy).getPotentialEnergy(); double term1 = (0.5*pow(1.1, 12)/pow(cutoff, 9))/9; double term2 = (0.5*pow(1.1, 6)/pow(cutoff, 3))/3; double expected = 8*M_PI*numParticles*numParticles*(term1-term2)/(boxSize*boxSize*boxSize); ASSERT_EQUAL_TOL(expected, energy1-energy2, 1e-4); // Now modify half the particles to be different, and see if it is still correct. int numType2 = 0; for (int i = 0; i < numParticles; i += 2) { nonbonded->setParticleParameters(i, 0, 1, 1); numType2++; } int numType1 = numParticles-numType2; nonbonded->updateParametersInContext(context); energy2 = context.getState(State::Energy).getPotentialEnergy(); nonbonded->setUseDispersionCorrection(true); context.reinitialize(); context.setPositions(positions); energy1 = context.getState(State::Energy).getPotentialEnergy(); term1 = ((numType1*(numType1+1))/2)*(0.5*pow(1.1, 12)/pow(cutoff, 9))/9; term2 = ((numType1*(numType1+1))/2)*(0.5*pow(1.1, 6)/pow(cutoff, 3))/3; term1 += ((numType2*(numType2+1))/2)*(1*pow(1.0, 12)/pow(cutoff, 9))/9; term2 += ((numType2*(numType2+1))/2)*(1*pow(1.0, 6)/pow(cutoff, 3))/3; double combinedSigma = 0.5*(1+1.1); double combinedEpsilon = sqrt(1*0.5); term1 += (numType1*numType2)*(combinedEpsilon*pow(combinedSigma, 12)/pow(cutoff, 9))/9; term2 += (numType1*numType2)*(combinedEpsilon*pow(combinedSigma, 6)/pow(cutoff, 3))/3; term1 /= (numParticles*(numParticles+1))/2; term2 /= (numParticles*(numParticles+1))/2; expected = 8*M_PI*numParticles*numParticles*(term1-term2)/(boxSize*boxSize*boxSize); ASSERT_EQUAL_TOL(expected, energy1-energy2, 1e-4); }
void test_water2_dpme_energies_forces_no_exclusions() { const double cutoff = 7.0*OpenMM::NmPerAngstrom; const double dalpha = 4.0124063605; const int grid = 32; NonbondedForce* forceField = new NonbondedForce(); vector<Vec3> positions; vector<double> epsvals; vector<double> sigvals; vector<pair<int, int> > bonds; System system; const int NATOMS = 6; double boxEdgeLength = 25*OpenMM::NmPerAngstrom; make_waterbox(NATOMS, boxEdgeLength, forceField, positions, epsvals, sigvals, bonds, system, false); forceField->setNonbondedMethod(OpenMM::NonbondedForce::LJPME); forceField->setPMEParameters(0.0f, grid, grid, grid); forceField->setReciprocalSpaceForceGroup(1); forceField->setLJPMEParameters(dalpha, grid, grid, grid); forceField->setCutoffDistance(cutoff); forceField->setReactionFieldDielectric(1.0); system.addForce(forceField); // Reference calculation VerletIntegrator integrator(0.01); Platform& platform = Platform::getPlatformByName("Reference"); Context context(system, integrator, platform); context.setPositions(positions); State state = context.getState(State::Forces | State::Energy, false, 1<<1); double refenergy = state.getPotentialEnergy(); const vector<Vec3>& refforces = state.getForces(); // Optimized CPU calculation CpuCalcDispersionPmeReciprocalForceKernel pme(CalcPmeReciprocalForceKernel::Name(), platform); IO io; double selfEwaldEnergy = 0; double dalpha6 = pow(dalpha, 6.0); for (int i = 0; i < NATOMS; i++) { io.posq.push_back((float)positions[i][0]); io.posq.push_back((float)positions[i][1]); io.posq.push_back((float)positions[i][2]); double c6 = 8.0f * pow(sigvals[i], 3) * epsvals[i]; io.posq.push_back(c6); selfEwaldEnergy += dalpha6 * c6 * c6 / 12.0; } pme.initialize(grid, grid, grid, NATOMS, dalpha, false); Vec3 boxVectors[3]; system.getDefaultPeriodicBoxVectors(boxVectors[0], boxVectors[1], boxVectors[2]); pme.beginComputation(io, boxVectors, true); double recenergy = pme.finishComputation(io); ASSERT_EQUAL_TOL(recenergy, -2.179629087, 5e-3); ASSERT_EQUAL_TOL(selfEwaldEnergy, 1.731404285, 1e-5); std::vector<Vec3> knownforces(6); knownforces[0] = Vec3( -1.890360546, -1.890723915, -1.879662698); knownforces[1] = Vec3( -0.003161352455, -0.000922244929, -0.005391616425); knownforces[2] = Vec3( 0.0009199035545, -0.001453894176, -0.006188087146); knownforces[3] = Vec3( 1.887108856, 1.887241446, 1.89644647); knownforces[4] = Vec3( 0.0008242336483, 0.003778910089, -0.002116131106); knownforces[5] = Vec3( 0.004912763044, 0.002324059399, -0.002844482646); for (int i = 0; i < NATOMS; i++) ASSERT_EQUAL_VEC(refforces[i], knownforces[i], 5e-3); recenergy += selfEwaldEnergy; // See if they match. ASSERT_EQUAL_TOL(refenergy, recenergy, 1e-3); for (int i = 0; i < NATOMS; i++) ASSERT_EQUAL_VEC(refforces[i], Vec3(io.force[4*i], io.force[4*i+1], io.force[4*i+2]), 5e-3); }
void testChangingParameters() { const int numMolecules = 600; const int numParticles = numMolecules*2; const double cutoff = 2.0; const double boxSize = 20.0; const double tol = 2e-3; ReferencePlatform reference; System system; for (int i = 0; i < numParticles; i++) system.addParticle(1.0); NonbondedForce* nonbonded = new NonbondedForce(); vector<Vec3> positions(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numMolecules; i++) { if (i < numMolecules/2) { nonbonded->addParticle(-1.0, 0.2, 0.1); nonbonded->addParticle(1.0, 0.1, 0.1); } else { nonbonded->addParticle(-1.0, 0.2, 0.2); nonbonded->addParticle(1.0, 0.1, 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); nonbonded->addException(2*i, 2*i+1, 0.0, 0.15, 0.0); } nonbonded->setNonbondedMethod(NonbondedForce::PME); nonbonded->setCutoffDistance(cutoff); system.addForce(nonbonded); system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); // See if Reference and Cuda give the same forces and energies. VerletIntegrator integrator1(0.01); VerletIntegrator integrator2(0.01); Context cuContext(system, integrator1, platform); Context referenceContext(system, integrator2, reference); cuContext.setPositions(positions); referenceContext.setPositions(positions); State cuState = cuContext.getState(State::Forces | State::Energy); State referenceState = referenceContext.getState(State::Forces | State::Energy); for (int i = 0; i < numParticles; i++) ASSERT_EQUAL_VEC(cuState.getForces()[i], referenceState.getForces()[i], tol); ASSERT_EQUAL_TOL(cuState.getPotentialEnergy(), referenceState.getPotentialEnergy(), tol); // Now modify parameters and see if they still agree. for (int i = 0; i < numParticles; i += 5) { double charge, sigma, epsilon; nonbonded->getParticleParameters(i, charge, sigma, epsilon); nonbonded->setParticleParameters(i, 1.5*charge, 1.1*sigma, 1.7*epsilon); } nonbonded->updateParametersInContext(cuContext); nonbonded->updateParametersInContext(referenceContext); cuState = cuContext.getState(State::Forces | State::Energy); referenceState = referenceContext.getState(State::Forces | State::Energy); for (int i = 0; i < numParticles; i++) ASSERT_EQUAL_VEC(cuState.getForces()[i], referenceState.getForces()[i], tol); ASSERT_EQUAL_TOL(cuState.getPotentialEnergy(), referenceState.getPotentialEnergy(), 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); }
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 testPME(bool triclinic) { // Create a cloud of random point charges. const int numParticles = 51; const double boxWidth = 5.0; const double cutoff = 1.0; Vec3 boxVectors[3]; if (triclinic) { boxVectors[0] = Vec3(boxWidth, 0, 0); boxVectors[1] = Vec3(0.2*boxWidth, boxWidth, 0); boxVectors[2] = Vec3(-0.3*boxWidth, -0.1*boxWidth, boxWidth); } else { boxVectors[0] = Vec3(boxWidth, 0, 0); boxVectors[1] = Vec3(0, boxWidth, 0); boxVectors[2] = Vec3(0, 0, boxWidth); } System system; system.setDefaultPeriodicBoxVectors(boxVectors[0], boxVectors[1], boxVectors[2]); 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); force->setCutoffDistance(cutoff); force->setReciprocalSpaceForceGroup(1); force->setEwaldErrorTolerance(1e-4); // Compute the reciprocal space forces with the reference platform. Platform& platform = Platform::getPlatformByName("Reference"); VerletIntegrator integrator(0.01); Context context(system, integrator, platform); context.setPositions(positions); State refState = context.getState(State::Forces | State::Energy, false, 1<<1); // Now compute them with the optimized kernel. double alpha; int gridx, gridy, gridz; NonbondedForceImpl::calcPMEParameters(system, *force, alpha, gridx, gridy, gridz, false); CpuCalcPmeReciprocalForceKernel pme(CalcPmeReciprocalForceKernel::Name(), platform); IO io; double sumSquaredCharges = 0; for (int i = 0; i < numParticles; i++) { io.posq.push_back(positions[i][0]); io.posq.push_back(positions[i][1]); io.posq.push_back(positions[i][2]); double charge, sigma, epsilon; force->getParticleParameters(i, charge, sigma, epsilon); io.posq.push_back(charge); sumSquaredCharges += charge*charge; } double ewaldSelfEnergy = -ONE_4PI_EPS0*alpha*sumSquaredCharges/sqrt(M_PI); pme.initialize(gridx, gridy, gridz, numParticles, alpha, true); pme.beginComputation(io, boxVectors, true); double energy = pme.finishComputation(io); // See if they match. ASSERT_EQUAL_TOL(refState.getPotentialEnergy(), energy+ewaldSelfEnergy, 1e-3); for (int i = 0; i < numParticles; i++) ASSERT_EQUAL_VEC(refState.getForces()[i], Vec3(io.force[4*i], io.force[4*i+1], io.force[4*i+2]), 1e-3); }
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 ReferenceCalcMBPolElectrostaticsForceKernel::initialize(const OpenMM::System& system, const MBPolElectrostaticsForce& force) { numElectrostatics = force.getNumElectrostatics(); charges.resize(numElectrostatics); tholes.resize(5*numElectrostatics); dampingFactors.resize(numElectrostatics); polarity.resize(numElectrostatics); axisTypes.resize(numElectrostatics); multipoleAtomZs.resize(numElectrostatics); multipoleAtomXs.resize(numElectrostatics); multipoleAtomYs.resize(numElectrostatics); multipoleAtomCovalentInfo.resize(numElectrostatics); int dipoleIndex = 0; int quadrupoleIndex = 0; int tholeIndex = 0; int maxCovalentRange = 0; double totalCharge = 0.0; for( int ii = 0; ii < numElectrostatics; ii++ ){ // multipoles int axisType, multipoleAtomZ, multipoleAtomX, multipoleAtomY; double charge, dampingFactorD, polarityD; std::vector<double> dipolesD; std::vector<double> tholesD; force.getElectrostaticsParameters(ii, charge, axisType, multipoleAtomZ, multipoleAtomX, multipoleAtomY, tholesD, dampingFactorD, polarityD ); totalCharge += charge; axisTypes[ii] = axisType; multipoleAtomZs[ii] = multipoleAtomZ; multipoleAtomXs[ii] = multipoleAtomX; multipoleAtomYs[ii] = multipoleAtomY; charges[ii] = static_cast<RealOpenMM>(charge); dampingFactors[ii] = static_cast<RealOpenMM>(dampingFactorD); polarity[ii] = static_cast<RealOpenMM>(polarityD); tholes[tholeIndex++] = static_cast<RealOpenMM>(tholesD[0]); tholes[tholeIndex++] = static_cast<RealOpenMM>(tholesD[1]); tholes[tholeIndex++] = static_cast<RealOpenMM>(tholesD[2]); tholes[tholeIndex++] = static_cast<RealOpenMM>(tholesD[3]); tholes[tholeIndex++] = static_cast<RealOpenMM>(tholesD[4]); // covalent info std::vector< std::vector<int> > covalentLists; force.getCovalentMaps(ii, covalentLists ); multipoleAtomCovalentInfo[ii] = covalentLists; } polarizationType = force.getPolarizationType(); if( polarizationType == MBPolElectrostaticsForce::Mutual ){ mutualInducedMaxIterations = force.getMutualInducedMaxIterations(); mutualInducedTargetEpsilon = force.getMutualInducedTargetEpsilon(); } includeChargeRedistribution = force.getIncludeChargeRedistribution(); // PME nonbondedMethod = force.getNonbondedMethod(); if( nonbondedMethod == MBPolElectrostaticsForce::PME ){ usePme = true; alphaEwald = force.getAEwald(); cutoffDistance = force.getCutoffDistance(); force.getPmeGridDimensions(pmeGridDimension); if (pmeGridDimension[0] == 0 || alphaEwald == 0.0) { NonbondedForce nb; nb.setEwaldErrorTolerance(force.getEwaldErrorTolerance()); nb.setCutoffDistance(force.getCutoffDistance()); int gridSizeX, gridSizeY, gridSizeZ; NonbondedForceImpl::calcPMEParameters(system, nb, alphaEwald, gridSizeX, gridSizeY, gridSizeZ); pmeGridDimension[0] = gridSizeX; pmeGridDimension[1] = gridSizeY; pmeGridDimension[2] = gridSizeZ; std::cout << "Computed PME parameters for MBPolElectrostaticsForce, alphaEwald:" << alphaEwald << " pmeGrid: " << gridSizeX << "," << gridSizeY << ","<< gridSizeZ << std::endl; } } else { usePme = false; } return; }