/** * 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 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); }
/** * Test evaluating force groups separately. */ void testForceGroups() { System system; system.addParticle(2.0); system.addParticle(2.0); CustomIntegrator integrator(0.01); integrator.addPerDofVariable("outf", 0); integrator.addPerDofVariable("outf1", 0); integrator.addPerDofVariable("outf2", 0); integrator.addGlobalVariable("oute", 0); integrator.addGlobalVariable("oute1", 0); integrator.addGlobalVariable("oute2", 0); integrator.addComputePerDof("outf", "f"); integrator.addComputePerDof("outf1", "f1"); integrator.addComputePerDof("outf2", "f2"); integrator.addComputeGlobal("oute", "energy"); integrator.addComputeGlobal("oute1", "energy1"); integrator.addComputeGlobal("oute2", "energy2"); HarmonicBondForce* bonds = new HarmonicBondForce(); bonds->addBond(0, 1, 1.5, 1.1); bonds->setForceGroup(1); system.addForce(bonds); NonbondedForce* nb = new NonbondedForce(); nb->addParticle(0.2, 1, 0); nb->addParticle(0.2, 1, 0); nb->setForceGroup(2); system.addForce(nb); Context context(system, integrator, platform); vector<Vec3> positions(2); positions[0] = Vec3(-1, 0, 0); positions[1] = Vec3(1, 0, 0); context.setPositions(positions); // See if the various forces are computed correctly. integrator.step(1); vector<Vec3> f, f1, f2; double e1 = 0.5*1.1*0.5*0.5; double e2 = 138.935456*0.2*0.2/2.0; integrator.getPerDofVariable(0, f); integrator.getPerDofVariable(1, f1); integrator.getPerDofVariable(2, f2); ASSERT_EQUAL_VEC(Vec3(1.1*0.5, 0, 0), f1[0], 1e-5); ASSERT_EQUAL_VEC(Vec3(-1.1*0.5, 0, 0), f1[1], 1e-5); ASSERT_EQUAL_VEC(Vec3(-138.935456*0.2*0.2/4.0, 0, 0), f2[0], 1e-5); ASSERT_EQUAL_VEC(Vec3(138.935456*0.2*0.2/4.0, 0, 0), f2[1], 1e-5); ASSERT_EQUAL_VEC(f1[0]+f2[0], f[0], 1e-5); ASSERT_EQUAL_VEC(f1[1]+f2[1], f[1], 1e-5); ASSERT_EQUAL_TOL(e1, integrator.getGlobalVariable(1), 1e-5); ASSERT_EQUAL_TOL(e2, integrator.getGlobalVariable(2), 1e-5); ASSERT_EQUAL_TOL(e1+e2, integrator.getGlobalVariable(0), 1e-5); // Make sure they also match the values returned by the Context. State s = context.getState(State::Forces | State::Energy, false); State s1 = context.getState(State::Forces | State::Energy, false, 2); State s2 = context.getState(State::Forces | State::Energy, false, 4); vector<Vec3> c, c1, c2; c = context.getState(State::Forces, false).getForces(); c1 = context.getState(State::Forces, false, 2).getForces(); c2 = context.getState(State::Forces, false, 4).getForces(); ASSERT_EQUAL_VEC(f[0], c[0], 1e-5); ASSERT_EQUAL_VEC(f[1], c[1], 1e-5); ASSERT_EQUAL_VEC(f1[0], c1[0], 1e-5); ASSERT_EQUAL_VEC(f1[1], c1[1], 1e-5); ASSERT_EQUAL_VEC(f2[0], c2[0], 1e-5); ASSERT_EQUAL_VEC(f2[1], c2[1], 1e-5); ASSERT_EQUAL_TOL(s.getPotentialEnergy(), integrator.getGlobalVariable(0), 1e-5); ASSERT_EQUAL_TOL(s1.getPotentialEnergy(), integrator.getGlobalVariable(1), 1e-5); ASSERT_EQUAL_TOL(s2.getPotentialEnergy(), integrator.getGlobalVariable(2), 1e-5); }
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); } }