void NonbondedForceImpl::calcPMEParameters(const System& system, const NonbondedForce& force, double& alpha, int& xsize, int& ysize, int& zsize, bool lj) { if (lj) force.getLJPMEParameters(alpha, xsize, ysize, zsize); else force.getPMEParameters(alpha, xsize, ysize, zsize); if (alpha == 0.0) { Vec3 boxVectors[3]; system.getDefaultPeriodicBoxVectors(boxVectors[0], boxVectors[1], boxVectors[2]); double tol = force.getEwaldErrorTolerance(); alpha = (1.0/force.getCutoffDistance())*std::sqrt(-log(2.0*tol)); if (lj) { xsize = (int) ceil(alpha*boxVectors[0][0]/(3*pow(tol, 0.2))); ysize = (int) ceil(alpha*boxVectors[1][1]/(3*pow(tol, 0.2))); zsize = (int) ceil(alpha*boxVectors[2][2]/(3*pow(tol, 0.2))); } else { xsize = (int) ceil(2*alpha*boxVectors[0][0]/(3*pow(tol, 0.2))); ysize = (int) ceil(2*alpha*boxVectors[1][1]/(3*pow(tol, 0.2))); zsize = (int) ceil(2*alpha*boxVectors[2][2]/(3*pow(tol, 0.2))); } xsize = max(xsize, 6); ysize = max(ysize, 6); zsize = max(zsize, 6); } }
void testConstraints() { const int numParticles = 8; const int numConstraints = 5; System system; VariableVerletIntegrator integrator(1e-5); integrator.setConstraintTolerance(1e-5); NonbondedForce* forceField = new NonbondedForce(); for (int i = 0; i < numParticles; ++i) { system.addParticle(10.0); forceField->addParticle((i%2 == 0 ? 0.2 : -0.2), 0.5, 5.0); } system.addConstraint(0, 1, 1.0); system.addConstraint(1, 2, 1.0); system.addConstraint(2, 3, 1.0); system.addConstraint(4, 5, 1.0); system.addConstraint(6, 7, 1.0); system.addForce(forceField); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); vector<Vec3> velocities(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; ++i) { positions[i] = Vec3(i/2, (i+1)/2, 0); velocities[i] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5); } context.setPositions(positions); context.setVelocities(velocities); // Simulate it and see whether the constraints remain satisfied. double initialEnergy = 0.0; for (int i = 0; i < 1000; ++i) { State state = context.getState(State::Positions | State::Energy | State::Velocities | State::Forces); for (int j = 0; j < numConstraints; ++j) { int particle1, particle2; double distance; system.getConstraintParameters(j, particle1, particle2, distance); Vec3 p1 = state.getPositions()[particle1]; Vec3 p2 = state.getPositions()[particle2]; double dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2])); ASSERT_EQUAL_TOL(distance, dist, 1e-4); } double energy = state.getKineticEnergy()+state.getPotentialEnergy(); if (i == 1) initialEnergy = energy; else if (i > 1) ASSERT_EQUAL_TOL(initialEnergy, energy, 0.01); integrator.step(1); } double finalTime = context.getState(State::Positions).getTime(); ASSERT(finalTime > 0.1); // Now try the stepTo() method. finalTime += 0.5; integrator.stepTo(finalTime); ASSERT_EQUAL(finalTime, context.getState(State::Positions).getTime()); }
void testRandomSeed() { const int numParticles = 8; const double temp = 100.0; const double collisionFreq = 10.0; System system; VerletIntegrator integrator(0.01); NonbondedForce* forceField = new NonbondedForce(); for (int i = 0; i < numParticles; ++i) { system.addParticle(2.0); forceField->addParticle((i%2 == 0 ? 1.0 : -1.0), 1.0, 5.0); } system.addForce(forceField); AndersenThermostat* thermostat = new AndersenThermostat(temp, collisionFreq); system.addForce(thermostat); vector<Vec3> positions(numParticles); vector<Vec3> velocities(numParticles); for (int i = 0; i < numParticles; ++i) { positions[i] = Vec3((i%2 == 0 ? 2 : -2), (i%4 < 2 ? 2 : -2), (i < 4 ? 2 : -2)); velocities[i] = Vec3(0, 0, 0); } // Try twice with the same random seed. thermostat->setRandomNumberSeed(5); Context context(system, integrator, platform); context.setPositions(positions); context.setVelocities(velocities); integrator.step(10); State state1 = context.getState(State::Positions); context.reinitialize(); context.setPositions(positions); context.setVelocities(velocities); integrator.step(10); State state2 = context.getState(State::Positions); // Try twice with a different random seed. thermostat->setRandomNumberSeed(10); context.reinitialize(); context.setPositions(positions); context.setVelocities(velocities); integrator.step(10); State state3 = context.getState(State::Positions); context.reinitialize(); context.setPositions(positions); context.setVelocities(velocities); integrator.step(10); State state4 = context.getState(State::Positions); // Compare the results. for (int i = 0; i < numParticles; i++) { for (int j = 0; j < 3; j++) { ASSERT(state1.getPositions()[i][j] == state2.getPositions()[i][j]); ASSERT(state3.getPositions()[i][j] == state4.getPositions()[i][j]); ASSERT(state1.getPositions()[i][j] != state3.getPositions()[i][j]); } } }
void 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); } }
/** * Test an integrator that enforces constraints. */ void testConstraints() { const int numParticles = 8; System system; CustomIntegrator integrator(0.002); integrator.addPerDofVariable("oldx", 0); integrator.addComputePerDof("v", "v+dt*f/m"); integrator.addComputePerDof("oldx", "x"); integrator.addComputePerDof("x", "x+dt*v"); integrator.addConstrainPositions(); integrator.addComputePerDof("v", "(x-oldx)/dt"); integrator.setConstraintTolerance(1e-5); NonbondedForce* forceField = new NonbondedForce(); for (int i = 0; i < numParticles; ++i) { system.addParticle(i%2 == 0 ? 5.0 : 10.0); forceField->addParticle((i%2 == 0 ? 0.2 : -0.2), 0.5, 5.0); } for (int i = 0; i < numParticles-1; ++i) system.addConstraint(i, i+1, 1.0); system.addForce(forceField); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); vector<Vec3> velocities(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; ++i) { positions[i] = Vec3(i/2, (i+1)/2, 0); velocities[i] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5); } context.setPositions(positions); context.setVelocities(velocities); // Simulate it and see whether the constraints remain satisfied. double initialEnergy = 0.0; for (int i = 0; i < 1000; ++i) { State state = context.getState(State::Positions | State::Energy); for (int j = 0; j < system.getNumConstraints(); ++j) { int particle1, particle2; double distance; system.getConstraintParameters(j, particle1, particle2, distance); Vec3 p1 = state.getPositions()[particle1]; Vec3 p2 = state.getPositions()[particle2]; double dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2])); ASSERT_EQUAL_TOL(distance, dist, 2e-5); } double energy = state.getKineticEnergy()+state.getPotentialEnergy(); if (i == 1) initialEnergy = energy; else if (i > 1) ASSERT_EQUAL_TOL(initialEnergy, energy, 0.01); integrator.step(1); } }
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 testConstraints() { const int numMolecules = 10; const int numParticles = numMolecules*3; const int numConstraints = numMolecules*3; const double temp = 100.0; System system; LangevinIntegrator integrator(temp, 2.0, 0.001); integrator.setConstraintTolerance(1e-5); NonbondedForce* forceField = new NonbondedForce(); for (int i = 0; i < numMolecules; ++i) { system.addParticle(16.0); system.addParticle(1.0); system.addParticle(1.0); forceField->addParticle(-0.82, 0.317, 0.65); forceField->addParticle(0.41, 1.0, 0.0); forceField->addParticle(0.41, 1.0, 0.0); system.addConstraint(i*3, i*3+1, 0.1); system.addConstraint(i*3, i*3+2, 0.1); system.addConstraint(i*3+1, i*3+2, 0.163); } system.addForce(forceField); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); vector<Vec3> velocities(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numMolecules; ++i) { positions[i*3] = Vec3((i%4)*0.4, (i/4)*0.4, 0); positions[i*3+1] = positions[i*3]+Vec3(0.1, 0, 0); positions[i*3+2] = positions[i*3]+Vec3(-0.03333, 0.09428, 0); velocities[i*3] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5); velocities[i*3+1] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5); velocities[i*3+2] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5); } context.setPositions(positions); context.setVelocities(velocities); // Simulate it and see whether the constraints remain satisfied. for (int i = 0; i < 1000; ++i) { integrator.step(1); State state = context.getState(State::Positions | State::Forces); for (int j = 0; j < numConstraints; ++j) { int particle1, particle2; double distance; system.getConstraintParameters(j, particle1, particle2, distance); Vec3 p1 = state.getPositions()[particle1]; Vec3 p2 = state.getPositions()[particle2]; double dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2])); ASSERT_EQUAL_TOL(distance, dist, 1e-5); } } }
/** * Test getting and setting per-DOF variables. */ void testPerDofVariables() { const int numParticles = 200; const double boxSize = 10; System system; system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); NonbondedForce* nb = new NonbondedForce(); system.addForce(nb); nb->setNonbondedMethod(NonbondedForce::CutoffNonPeriodic); vector<Vec3> positions(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; i++) { system.addParticle(1.5); nb->addParticle(i%2 == 0 ? 1 : -1, 0.1, 1); bool close = true; while (close) { positions[i] = Vec3(boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt)); close = false; for (int j = 0; j < i; ++j) { Vec3 delta = positions[i]-positions[j]; if (delta.dot(delta) < 0.1) close = true; } } } CustomIntegrator integrator(0.01); integrator.addPerDofVariable("temp", 0); integrator.addPerDofVariable("pos", 0); integrator.addComputePerDof("v", "v+dt*f/m"); integrator.addComputePerDof("x", "x+dt*v"); integrator.addComputePerDof("pos", "x"); Context context(system, integrator, platform); context.setPositions(positions); vector<Vec3> initialValues(numParticles); for (int i = 0; i < numParticles; i++) initialValues[i] = Vec3(i+0.1, i+0.2, i+0.3); integrator.setPerDofVariable(0, initialValues); // Run a simulation, then query per-DOF values and see if they are correct. vector<Vec3> values; context.getState(State::Forces); // Cause atom reordering to happen before the first step for (int i = 0; i < 200; ++i) { integrator.step(1); State state = context.getState(State::Positions); integrator.getPerDofVariable(0, values); for (int j = 0; j < numParticles; j++) ASSERT_EQUAL_VEC(initialValues[j], values[j], 1e-5); integrator.getPerDofVariable(1, values); for (int j = 0; j < numParticles; j++) ASSERT_EQUAL_VEC(state.getPositions()[j], values[j], 1e-5); } }
void testConstraints() { const int numParticles = 8; const double temp = 100.0; const double collisionFreq = 10.0; const int numSteps = 15000; System system; VerletIntegrator integrator(0.004); NonbondedForce* forceField = new NonbondedForce(); for (int i = 0; i < numParticles; ++i) { system.addParticle(2.0); forceField->addParticle((i%2 == 0 ? 1.0 : -1.0), 1.0, 5.0); } system.addForce(forceField); system.addConstraint(0, 1, 1); system.addConstraint(1, 2, 1); system.addConstraint(2, 3, 1); system.addConstraint(3, 0, 1); system.addConstraint(4, 5, 1); system.addConstraint(5, 6, 1); system.addConstraint(6, 7, 1); system.addConstraint(7, 4, 1); AndersenThermostat* thermostat = new AndersenThermostat(temp, collisionFreq); system.addForce(thermostat); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); positions[0] = Vec3(0, 0, 0); positions[1] = Vec3(1, 0, 0); positions[2] = Vec3(1, 1, 0); positions[3] = Vec3(0, 1, 0); positions[4] = Vec3(1, 0, 1); positions[5] = Vec3(1, 1, 1); positions[6] = Vec3(0, 1, 1); positions[7] = Vec3(0, 0, 1); context.setPositions(positions); context.setVelocitiesToTemperature(temp); // Let it equilibrate. integrator.step(5000); // Now run it for a while and see if the temperature is correct. double ke = 0.0; for (int i = 0; i < numSteps; ++i) { State state = context.getState(State::Energy); ke += state.getKineticEnergy(); integrator.step(1); } ke /= numSteps; double expected = 0.5*(numParticles*3-system.getNumConstraints())*BOLTZ*temp; ASSERT_USUALLY_EQUAL_TOL(expected, ke, 0.1); }
void testErrorTolerance(NonbondedForce::NonbondedMethod method) { // Create a cloud of random point charges. const int numParticles = 51; const double boxWidth = 5.0; System system; system.setDefaultPeriodicBoxVectors(Vec3(boxWidth, 0, 0), Vec3(0, boxWidth, 0), Vec3(0, 0, boxWidth)); NonbondedForce* force = new NonbondedForce(); system.addForce(force); vector<Vec3> positions(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; i++) { system.addParticle(1.0); force->addParticle(-1.0+i*2.0/(numParticles-1), 1.0, 0.0); positions[i] = Vec3(boxWidth*genrand_real2(sfmt), boxWidth*genrand_real2(sfmt), boxWidth*genrand_real2(sfmt)); } force->setNonbondedMethod(method); ReferencePlatform platform; // For various values of the cutoff and error tolerance, see if the actual error is reasonable. for (double cutoff = 1.0; cutoff < boxWidth/2; cutoff *= 1.2) { force->setCutoffDistance(cutoff); vector<Vec3> refForces; double norm = 0.0; for (double tol = 5e-5; tol < 1e-3; tol *= 2.0) { force->setEwaldErrorTolerance(tol); VerletIntegrator integrator(0.01); Context context(system, integrator, platform); context.setPositions(positions); State state = context.getState(State::Forces); if (refForces.size() == 0) { refForces = state.getForces(); for (int i = 0; i < numParticles; i++) norm += refForces[i].dot(refForces[i]); norm = sqrt(norm); } else { double diff = 0.0; for (int i = 0; i < numParticles; i++) { Vec3 delta = refForces[i]-state.getForces()[i]; diff += delta.dot(delta); } diff = sqrt(diff)/norm; ASSERT(diff < 2*tol); } } } }
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 ValidateOpenMM::writeNonbondedForce( FILE* filePtr, const NonbondedForce & nonbondedForce ) const { // charge and vdw parameters (void) fprintf( filePtr, "NonbondedForce %d\n", nonbondedForce.getNumParticles() ); for(int ii = 0; ii < nonbondedForce.getNumParticles(); ii++ ){ double charge, sigma, epsilon; nonbondedForce.getParticleParameters( ii, charge, sigma, epsilon ); (void) fprintf( filePtr, "%8d %14.7e %14.7e %14.7e\n", ii, charge, sigma, epsilon ); } // cutoff, dielectric, Ewald tolerance (void) fprintf( filePtr, "CutoffDistance %14.7e\n", nonbondedForce.getCutoffDistance() ); (void) fprintf( filePtr, "RFDielectric %14.7e\n", nonbondedForce.getReactionFieldDielectric() ); (void) fprintf( filePtr, "EwaldRTolerance %14.7e\n", nonbondedForce.getEwaldErrorTolerance() ); // cutoff mode std::string nonbondedForceMethod; switch( nonbondedForce.getNonbondedMethod() ){ case NonbondedForce::NoCutoff: nonbondedForceMethod = "NoCutoff"; break; case NonbondedForce::CutoffNonPeriodic: nonbondedForceMethod = "CutoffNonPeriodic"; break; case NonbondedForce::CutoffPeriodic: nonbondedForceMethod = "CutoffPeriodic"; break; case NonbondedForce::Ewald: nonbondedForceMethod = "Ewald"; break; case NonbondedForce::PME: nonbondedForceMethod = "PME"; break; default: nonbondedForceMethod = "Unknown"; } (void) fprintf( filePtr, "NonbondedForceMethod %s\n", nonbondedForceMethod.c_str() ); (void) fprintf( filePtr, "NonbondedForceExceptions %d\n", nonbondedForce.getNumExceptions() ); for(int ii = 0; ii < nonbondedForce.getNumExceptions(); ii++ ){ int particle1, particle2; double chargeProd, sigma, epsilon; nonbondedForce.getExceptionParameters( ii, particle1, particle2, chargeProd, sigma, epsilon ); (void) fprintf( filePtr, "%8d %8d %8d %14.7e %14.7e %14.7e\n", ii, particle1, particle2, chargeProd, sigma, epsilon ); } }
void NonbondedForceImpl::calcEwaldParameters(const System& system, const NonbondedForce& force, double& alpha, int& kmaxx, int& kmaxy, int& kmaxz) { Vec3 boxVectors[3]; system.getDefaultPeriodicBoxVectors(boxVectors[0], boxVectors[1], boxVectors[2]); double tol = force.getEwaldErrorTolerance(); alpha = (1.0/force.getCutoffDistance())*std::sqrt(-log(2.0*tol)); kmaxx = findZero(EwaldErrorFunction(boxVectors[0][0], alpha, tol), 10); kmaxy = findZero(EwaldErrorFunction(boxVectors[1][1], alpha, tol), 10); kmaxz = findZero(EwaldErrorFunction(boxVectors[2][2], alpha, tol), 10); if (kmaxx%2 == 0) kmaxx++; if (kmaxy%2 == 0) kmaxy++; if (kmaxz%2 == 0) kmaxz++; }
void testConstraints() { const int numParticles = 8; const int numConstraints = 5; const double temp = 20.0; System system; BrownianIntegrator integrator(temp, 2.0, 0.001); integrator.setConstraintTolerance(1e-5); NonbondedForce* forceField = new NonbondedForce(); for (int i = 0; i < numParticles; ++i) { system.addParticle(10.0); forceField->addParticle((i%2 == 0 ? 0.2 : -0.2), 0.5, 5.0); } system.addConstraint(0, 1, 1.0); system.addConstraint(1, 2, 1.0); system.addConstraint(2, 3, 1.0); system.addConstraint(4, 5, 1.0); system.addConstraint(6, 7, 1.0); system.addForce(forceField); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); vector<Vec3> velocities(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; ++i) { positions[i] = Vec3(i, 0, 0); velocities[i] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5); } context.setPositions(positions); context.setVelocities(velocities); // Simulate it and see whether the constraints remain satisfied. for (int i = 0; i < 1000; ++i) { State state = context.getState(State::Positions); for (int j = 0; j < numConstraints; ++j) { int particle1, particle2; double distance; system.getConstraintParameters(j, particle1, particle2, distance); Vec3 p1 = state.getPositions()[particle1]; Vec3 p2 = state.getPositions()[particle2]; double dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2])); ASSERT_EQUAL_TOL(distance, dist, 1e-4); } integrator.step(1); } }
void 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 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 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 testMotionRemoval() { const int numParticles = 8; const double temp = 100.0; const double collisionFreq = 10.0; ReferencePlatform platform; System system; VerletIntegrator integrator(0.01); HarmonicBondForce* bonds = new HarmonicBondForce(); bonds->addBond(2, 3, 2.0, 0.5); system.addForce(bonds); NonbondedForce* nonbonded = new NonbondedForce(); for (int i = 0; i < numParticles; ++i) { system.addParticle(i+1); nonbonded->addParticle((i%2 == 0 ? 1.0 : -1.0), 1.0, 5.0); } system.addForce(nonbonded); CMMotionRemover* remover = new CMMotionRemover(); system.addForce(remover); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); vector<Vec3> velocities(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; ++i) { positions[i] = Vec3((i%2 == 0 ? 2 : -2), (i%4 < 2 ? 2 : -2), (i < 4 ? 2 : -2)); velocities[i] = Vec3(genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5, genrand_real2(sfmt)-0.5); } context.setPositions(positions); context.setVelocities(velocities); // Now run it for a while and see if the center of mass remains fixed. Vec3 cmPos = calcCM(context.getState(State::Positions).getPositions(), system); for (int i = 0; i < 1000; ++i) { integrator.step(1); State state = context.getState(State::Positions | State::Velocities); Vec3 pos = calcCM(state.getPositions(), system); ASSERT_EQUAL_VEC(cmPos, pos, 1e-2); Vec3 vel = calcCM(state.getVelocities(), system); ASSERT_EQUAL_VEC(Vec3(0, 0, 0), vel, 1e-2); } }
/** * Test an integrator with an AndersenThermostat to see if updateContextState() * is being handled correctly. */ void testWithThermostat() { const int numParticles = 8; const double temp = 100.0; const double collisionFreq = 20.0; const int numSteps = 5000; System system; CustomIntegrator integrator(0.003); integrator.addUpdateContextState(); integrator.addComputePerDof("v", "v+dt*f/m"); integrator.addComputePerDof("x", "x+dt*v"); NonbondedForce* forceField = new NonbondedForce(); for (int i = 0; i < numParticles; ++i) { system.addParticle(2.0); forceField->addParticle((i%2 == 0 ? 1.0 : -1.0), 1.0, 5.0); } system.addForce(forceField); AndersenThermostat* thermostat = new AndersenThermostat(temp, collisionFreq); system.addForce(thermostat); integrator.setRandomNumberSeed(thermostat->getRandomNumberSeed()); Context context(system, integrator, platform); vector<Vec3> positions(numParticles); for (int i = 0; i < numParticles; ++i) positions[i] = Vec3((i%2 == 0 ? 2 : -2), (i%4 < 2 ? 2 : -2), (i < 4 ? 2 : -2)); context.setPositions(positions); context.setVelocitiesToTemperature(temp); // Let it equilibrate. integrator.step(10000); // Now run it for a while and see if the temperature is correct. double ke = 0.0; for (int i = 0; i < numSteps; ++i) { State state = context.getState(State::Energy); ke += state.getKineticEnergy(); integrator.step(10); } ke /= numSteps; double expected = 0.5*numParticles*3*BOLTZ*temp; ASSERT_USUALLY_EQUAL_TOL(expected, ke, 0.1); }
double NonbondedForceImpl::calcDispersionCorrection(const System& system, const NonbondedForce& force) { if (force.getNonbondedMethod() == NonbondedForce::NoCutoff || force.getNonbondedMethod() == NonbondedForce::CutoffNonPeriodic) return 0.0; // Identify all particle classes (defined by sigma and epsilon), and count the number of // particles in each class. map<pair<double, double>, int> classCounts; for (int i = 0; i < force.getNumParticles(); i++) { double charge, sigma, epsilon; force.getParticleParameters(i, charge, sigma, epsilon); pair<double, double> key = make_pair(sigma, epsilon); map<pair<double, double>, int>::iterator entry = classCounts.find(key); if (entry == classCounts.end()) classCounts[key] = 1; else entry->second++; } // Loop over all pairs of classes to compute the coefficient. double sum1 = 0, sum2 = 0, sum3 = 0; bool useSwitch = force.getUseSwitchingFunction(); double cutoff = force.getCutoffDistance(); double switchDist = force.getSwitchingDistance(); for (map<pair<double, double>, int>::const_iterator entry = classCounts.begin(); entry != classCounts.end(); ++entry) { double sigma = entry->first.first; double epsilon = entry->first.second; double count = (double) entry->second; count *= (count + 1) / 2; double sigma2 = sigma*sigma; double sigma6 = sigma2*sigma2*sigma2; sum1 += count*epsilon*sigma6*sigma6; sum2 += count*epsilon*sigma6; if (useSwitch) sum3 += count*epsilon*(evalIntegral(cutoff, switchDist, cutoff, sigma)-evalIntegral(switchDist, switchDist, cutoff, sigma)); } for (map<pair<double, double>, int>::const_iterator class1 = classCounts.begin(); class1 != classCounts.end(); ++class1) for (map<pair<double, double>, int>::const_iterator class2 = classCounts.begin(); class2 != class1; ++class2) { double sigma = 0.5*(class1->first.first+class2->first.first); double epsilon = sqrt(class1->first.second*class2->first.second); double count = (double) class1->second; count *= (double) class2->second; double sigma2 = sigma*sigma; double sigma6 = sigma2*sigma2*sigma2; sum1 += count*epsilon*sigma6*sigma6; sum2 += count*epsilon*sigma6; if (useSwitch) sum3 += count*epsilon*(evalIntegral(cutoff, switchDist, cutoff, sigma)-evalIntegral(switchDist, switchDist, cutoff, sigma)); } double numParticles = (double) system.getNumParticles(); double numInteractions = (numParticles*(numParticles+1))/2; sum1 /= numInteractions; sum2 /= numInteractions; sum3 /= numInteractions; return 8*numParticles*numParticles*M_PI*(sum1/(9*pow(cutoff, 9))-sum2/(3*pow(cutoff, 3))+sum3); }
void testCoulomb() { System system; system.addParticle(1.0); system.addParticle(1.0); VerletIntegrator integrator(0.01); NonbondedForce* forceField = new NonbondedForce(); forceField->addParticle(0.5, 1, 0); forceField->addParticle(-1.5, 1, 0); system.addForce(forceField); Context context(system, integrator, platform); vector<Vec3> positions(2); positions[0] = Vec3(0, 0, 0); positions[1] = Vec3(2, 0, 0); context.setPositions(positions); State state = context.getState(State::Forces | State::Energy); const vector<Vec3>& forces = state.getForces(); double force = ONE_4PI_EPS0*(-0.75)/4.0; ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], TOL); ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[1], TOL); ASSERT_EQUAL_TOL(ONE_4PI_EPS0*(-0.75)/2.0, state.getPotentialEnergy(), TOL); }
void 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 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 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); }
/** * Test the ComputeSum operation. */ void testSum() { const int numParticles = 200; const double boxSize = 10; System system; system.setDefaultPeriodicBoxVectors(Vec3(boxSize, 0, 0), Vec3(0, boxSize, 0), Vec3(0, 0, boxSize)); NonbondedForce* nb = new NonbondedForce(); system.addForce(nb); vector<Vec3> positions(numParticles); OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); for (int i = 0; i < numParticles; i++) { system.addParticle(i%10 == 0 ? 0.0 : 1.5); nb->addParticle(i%2 == 0 ? 0.1 : -0.1, 0.1, 1); bool close = true; while (close) { positions[i] = Vec3(boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt), boxSize*genrand_real2(sfmt)); close = false; for (int j = 0; j < i; ++j) { Vec3 delta = positions[i]-positions[j]; if (delta.dot(delta) < 1) close = true; } } } CustomIntegrator integrator(0.005); integrator.addGlobalVariable("ke", 0); integrator.addComputePerDof("v", "v+dt*f/m"); integrator.addComputePerDof("x", "x+dt*v"); integrator.addComputeSum("ke", "m*v*v/2"); Context context(system, integrator, platform); context.setPositions(positions); // See if the sum is being computed correctly. for (int i = 0; i < 100; ++i) { State state = context.getState(State::Energy); ASSERT_EQUAL_TOL(state.getKineticEnergy(), integrator.getGlobalVariable(0), 1e-5); integrator.step(1); } }
void 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 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 testLJ() { System system; system.addParticle(1.0); system.addParticle(1.0); VerletIntegrator integrator(0.01); NonbondedForce* forceField = new NonbondedForce(); forceField->addParticle(0, 1.2, 1); forceField->addParticle(0, 1.4, 2); system.addForce(forceField); Context context(system, integrator, platform); vector<Vec3> positions(2); positions[0] = Vec3(0, 0, 0); positions[1] = Vec3(2, 0, 0); context.setPositions(positions); State state = context.getState(State::Forces | State::Energy); const vector<Vec3>& forces = state.getForces(); double x = 1.3/2.0; double eps = SQRT_TWO; double force = 4.0*eps*(12*std::pow(x, 12.0)-6*std::pow(x, 6.0))/2.0; ASSERT_EQUAL_VEC(Vec3(-force, 0, 0), forces[0], TOL); ASSERT_EQUAL_VEC(Vec3(force, 0, 0), forces[1], TOL); ASSERT_EQUAL_TOL(4.0*eps*(std::pow(x, 12.0)-std::pow(x, 6.0)), state.getPotentialEnergy(), TOL); }
/** * Test a System where multiple virtual sites are all calculated from the same particles. */ void testOverlappingSites() { System system; system.addParticle(1.0); system.addParticle(1.0); system.addParticle(1.0); NonbondedForce* nonbonded = new NonbondedForce(); system.addForce(nonbonded); nonbonded->addParticle(1.0, 0.0, 0.0); nonbonded->addParticle(-0.5, 0.0, 0.0); nonbonded->addParticle(-0.5, 0.0, 0.0); vector<Vec3> positions; positions.push_back(Vec3(0, 0, 0)); positions.push_back(Vec3(10, 0, 0)); positions.push_back(Vec3(0, 10, 0)); for (int i = 0; i < 20; i++) { system.addParticle(0.0); double u = 0.1*((i+1)%4); double v = 0.05*i; system.setVirtualSite(3+i, new ThreeParticleAverageSite(0, 1, 2, u, v, 1-u-v)); nonbonded->addParticle(i%2 == 0 ? -1.0 : 1.0, 0.0, 0.0); positions.push_back(Vec3()); } VerletIntegrator i1(0.002); VerletIntegrator i2(0.002); Context c1(system, i1, Platform::getPlatformByName("Reference")); Context c2(system, i2, platform); c1.setPositions(positions); c2.setPositions(positions); c1.applyConstraints(0.0001); c2.applyConstraints(0.0001); State s1 = c1.getState(State::Positions | State::Forces); State s2 = c2.getState(State::Positions | State::Forces); for (int i = 0; i < system.getNumParticles(); i++) ASSERT_EQUAL_VEC(s1.getPositions()[i], s2.getPositions()[i], 1e-5); for (int i = 0; i < 3; i++) ASSERT_EQUAL_VEC(s1.getForces()[i], s2.getForces()[i], 1e-5); }