void testParallelComputation() { System system; const int numParticles = 200; for (int i = 0; i < numParticles; i++) system.addParticle(1.0); CustomCompoundBondForce* force = new CustomCompoundBondForce(2, ("(distance(p1,p2)-1.1)^2")); vector<int> particles(2); vector<double> params; for (int i = 1; i < numParticles; i++) { particles[0] = i-1; particles[1] = i; force->addBond(particles, params); } system.addForce(force); vector<Vec3> positions(numParticles); for (int i = 0; i < numParticles; i++) positions[i] = Vec3(i, 0, 0); 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); 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 testPositionDependence() { ReferencePlatform platform; System customSystem; customSystem.addParticle(1.0); customSystem.addParticle(1.0); CustomCompoundBondForce* custom = new CustomCompoundBondForce(2, "scale1*distance(p1,p2)+scale2*x1+2*y2"); custom->addGlobalParameter("scale1", 0.3); custom->addGlobalParameter("scale2", 0.2); vector<int> particles(2); particles[0] = 0; particles[1] = 1; vector<double> parameters; custom->addBond(particles, parameters); customSystem.addForce(custom); vector<Vec3> positions(2); positions[0] = Vec3(0.5, 1, 0); positions[1] = Vec3(1.5, 1, 0); VerletIntegrator integrator(0.01); Context context(customSystem, integrator, platform); context.setPositions(positions); State state = context.getState(State::Forces | State::Energy); ASSERT_EQUAL_TOL(0.3*1.0+0.2*0.5+2*1, state.getPotentialEnergy(), 1e-5); ASSERT_EQUAL_VEC(Vec3(0.3-0.2, 0, 0), state.getForces()[0], 1e-5); ASSERT_EQUAL_VEC(Vec3(-0.3, -2, 0), state.getForces()[1], 1e-5); }
void testContinuous3DFunction() { const int xsize = 10; const int ysize = 11; const int zsize = 12; const double xmin = 0.4; const double xmax = 1.1; const double ymin = 0.0; const double ymax = 0.9; const double zmin = 0.2; const double zmax = 1.3; ReferencePlatform platform; System system; system.addParticle(1.0); VerletIntegrator integrator(0.01); CustomCompoundBondForce* forceField = new CustomCompoundBondForce(1, "fn(x1,y1,z1)+1"); vector<int> particles(1, 0); forceField->addBond(particles, vector<double>()); vector<double> table(xsize*ysize*zsize); for (int i = 0; i < xsize; i++) { for (int j = 0; j < ysize; j++) { for (int k = 0; k < zsize; k++) { double x = xmin + i*(xmax-xmin)/xsize; double y = ymin + j*(ymax-ymin)/ysize; double z = zmin + k*(zmax-zmin)/zsize; table[i+xsize*j+xsize*ysize*k] = sin(0.25*x)*cos(0.33*y)*(1+z); } } } forceField->addTabulatedFunction("fn", new Continuous3DFunction(xsize, ysize, zsize, table, xmin, xmax, ymin, ymax, zmin, zmax)); system.addForce(forceField); Context context(system, integrator, platform); vector<Vec3> positions(1); for (double x = xmin-0.15; x < xmax+0.2; x += 0.1) { for (double y = ymin-0.15; y < ymax+0.2; y += 0.1) { for (double z = zmin-0.15; z < zmax+0.2; z += 0.1) { positions[0] = Vec3(x, y, z); context.setPositions(positions); State state = context.getState(State::Forces | State::Energy); const vector<Vec3>& forces = state.getForces(); double energy = 1; Vec3 force(0, 0, 0); if (x >= xmin && x <= xmax && y >= ymin && y <= ymax && z >= zmin && z <= zmax) { energy = sin(0.25*x)*cos(0.33*y)*(1.0+z)+1; force[0] = -0.25*cos(0.25*x)*cos(0.33*y)*(1.0+z); force[1] = 0.3*sin(0.25*x)*sin(0.33*y)*(1.0+z); force[2] = -sin(0.25*x)*cos(0.33*y); } ASSERT_EQUAL_VEC(force, forces[0], 0.1); ASSERT_EQUAL_TOL(energy, state.getPotentialEnergy(), 0.05); } } } }
void testMultipleBonds() { // Two compound bonds using Urey-Bradley example from API doc ReferencePlatform platform; System customSystem; customSystem.addParticle(1.0); customSystem.addParticle(1.0); customSystem.addParticle(1.0); customSystem.addParticle(1.0); CustomCompoundBondForce* custom = new CustomCompoundBondForce(3, "0.5*(kangle*(angle(p1,p2,p3)-theta0)^2+kbond*(distance(p1,p3)-r0)^2)"); custom->addPerBondParameter("kangle"); custom->addPerBondParameter("kbond"); custom->addPerBondParameter("theta0"); custom->addPerBondParameter("r0"); vector<double> parameters(4); parameters[0] = 1.0; parameters[1] = 1.0; parameters[2] = 2 * M_PI / 3; parameters[3] = sqrt(3.0) / 2; vector<int> particles0(3); particles0[0] = 0; particles0[1] = 1; particles0[2] = 2; vector<int> particles1(3); particles1[0] = 1; particles1[1] = 2; particles1[2] = 3; custom->addBond(particles0, parameters); custom->addBond(particles1, parameters); customSystem.addForce(custom); vector<Vec3> positions(4); positions[0] = Vec3(0, 0.5, 0); positions[1] = Vec3(0, 0, 0); positions[2] = Vec3(0.5, 0, 0); positions[3] = Vec3(0.6, 0, 0.4); VerletIntegrator integrator(0.01); Context context(customSystem, integrator, platform); context.setPositions(positions); State state = context.getState(State::Forces | State::Energy); ASSERT_EQUAL_TOL(0.199, state.getPotentialEnergy(), 1e-3); vector<Vec3> forces(state.getForces()); ASSERT_EQUAL_VEC(Vec3(-1.160, 0.112, 0.0), forces[0], 1e-3); ASSERT_EQUAL_VEC(Vec3(0.927, 1.047, -0.638), forces[1], 1e-3); ASSERT_EQUAL_VEC(Vec3(-0.543, -1.160, 0.721), forces[2], 1e-3); ASSERT_EQUAL_VEC(Vec3(0.776, 0.0, -0.084), forces[3], 1e-3); }
void testBond() { // Create a system using a CustomCompoundBondForce. System customSystem; customSystem.addParticle(1.0); customSystem.addParticle(1.0); customSystem.addParticle(1.0); customSystem.addParticle(1.0); CustomCompoundBondForce* custom = new CustomCompoundBondForce(4, "0.5*kb*((distance(p1,p2)-b0)^2+(distance(p2,p3)-b0)^2)+0.5*ka*(angle(p2,p3,p4)-a0)^2+kt*(1+cos(dihedral(p1,p2,p3,p4)-t0))"); custom->addPerBondParameter("kb"); custom->addPerBondParameter("ka"); custom->addPerBondParameter("kt"); custom->addPerBondParameter("b0"); custom->addPerBondParameter("a0"); custom->addPerBondParameter("t0"); vector<int> particles(4); particles[0] = 0; particles[1] = 1; particles[2] = 3; particles[3] = 2; vector<double> parameters(6); parameters[0] = 1.5; parameters[1] = 0.8; parameters[2] = 0.6; parameters[3] = 1.1; parameters[4] = 2.9; parameters[5] = 1.3; custom->addBond(particles, parameters); customSystem.addForce(custom); // Create an identical system using standard forces. System standardSystem; standardSystem.addParticle(1.0); standardSystem.addParticle(1.0); standardSystem.addParticle(1.0); standardSystem.addParticle(1.0); HarmonicBondForce* bonds = new HarmonicBondForce(); bonds->addBond(0, 1, 1.1, 1.5); bonds->addBond(1, 3, 1.1, 1.5); standardSystem.addForce(bonds); HarmonicAngleForce* angles = new HarmonicAngleForce(); angles->addAngle(1, 3, 2, 2.9, 0.8); standardSystem.addForce(angles); PeriodicTorsionForce* torsions = new PeriodicTorsionForce(); torsions->addTorsion(0, 1, 3, 2, 1, 1.3, 0.6); standardSystem.addForce(torsions); // Set the atoms in various positions, and verify that both systems give identical forces and energy. OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); VerletIntegrator integrator1(0.01); VerletIntegrator integrator2(0.01); Context c1(customSystem, integrator1, platform); Context c2(standardSystem, integrator2, platform); vector<Vec3> positions(4); for (int i = 0; i < 10; i++) { for (int j = 0; j < (int) positions.size(); j++) positions[j] = Vec3(5.0*genrand_real2(sfmt), 5.0*genrand_real2(sfmt), 5.0*genrand_real2(sfmt)); c1.setPositions(positions); c2.setPositions(positions); State s1 = c1.getState(State::Forces | State::Energy); State s2 = c2.getState(State::Forces | State::Energy); for (int i = 0; i < customSystem.getNumParticles(); i++) ASSERT_EQUAL_VEC(s1.getForces()[i], s2.getForces()[i], TOL); ASSERT_EQUAL_TOL(s1.getPotentialEnergy(), s2.getPotentialEnergy(), TOL); } // Try changing the bond parameters and make sure it's still correct. parameters[0] = 1.6; parameters[3] = 1.3; custom->setBondParameters(0, particles, parameters); custom->updateParametersInContext(c1); bonds->setBondParameters(0, 0, 1, 1.3, 1.6); bonds->setBondParameters(1, 1, 3, 1.3, 1.6); bonds->updateParametersInContext(c2); { State s1 = c1.getState(State::Forces | State::Energy); State s2 = c2.getState(State::Forces | State::Energy); const vector<Vec3>& forces = s1.getForces(); for (int i = 0; i < customSystem.getNumParticles(); i++) ASSERT_EQUAL_VEC(s1.getForces()[i], s2.getForces()[i], TOL); ASSERT_EQUAL_TOL(s1.getPotentialEnergy(), s2.getPotentialEnergy(), TOL); } }
void testComplexFunction() { int numParticles = 5; System system; for (int i = 0; i < numParticles; i++) system.addParticle(2.0); vector<double> table(20); for (int i = 0; i < 20; i++) table[i] = sin(0.11*i); // When every group contains only one particle, a CustomCentroidBondForce is identical to a // CustomCompoundBondForce. Use that to test a complicated energy function with lots of terms. CustomCompoundBondForce* compound = new CustomCompoundBondForce(4, "x1+y2+z4+fn(distance(p1,p2))*angle(p3,p2,p4)+scale*dihedral(p2,p1,p4,p3)"); CustomCentroidBondForce* centroid = new CustomCentroidBondForce(4, "x1+y2+z4+fn(distance(g1,g2))*angle(g3,g2,g4)+scale*dihedral(g2,g1,g4,g3)"); compound->addGlobalParameter("scale", 0.5); centroid->addGlobalParameter("scale", 0.5); compound->addTabulatedFunction("fn", new Continuous1DFunction(table, -1, 10)); centroid->addTabulatedFunction("fn", new Continuous1DFunction(table, -1, 10)); // Add two bonds to the CustomCompoundBondForce. vector<int> particles(4); vector<double> parameters; particles[0] = 0; particles[1] = 1; particles[2] = 2; particles[3] = 3; compound->addBond(particles, parameters); particles[0] = 2; particles[1] = 4; particles[2] = 3; particles[3] = 1; compound->addBond(particles, parameters); // Add identical bonds to the CustomCentroidBondForce. As a stronger test, make sure that // group number is different from particle number. vector<int> groupMembers(1); groupMembers[0] = 3; centroid->addGroup(groupMembers); groupMembers[0] = 0; centroid->addGroup(groupMembers); groupMembers[0] = 1; centroid->addGroup(groupMembers); groupMembers[0] = 2; centroid->addGroup(groupMembers); groupMembers[0] = 4; centroid->addGroup(groupMembers); vector<int> groups(4); groups[0] = 1; groups[1] = 2; groups[2] = 3; groups[3] = 0; centroid->addBond(groups, parameters); groups[0] = 3; groups[1] = 4; groups[2] = 0; groups[3] = 2; centroid->addBond(groups, parameters); // Add both forces as different force groups, and create a context. centroid->setForceGroup(1); system.addForce(compound); system.addForce(centroid); VerletIntegrator integrator(0.01); Context context(system, integrator, platform); // Evaluate the force and energy for various positions and see if they match. OpenMM_SFMT::SFMT sfmt; init_gen_rand(0, sfmt); vector<Vec3> positions(numParticles); for (int i = 0; i < 10; i++) { for (int j = 0; j < numParticles; j++) positions[j] = Vec3(5.0*genrand_real2(sfmt), 5.0*genrand_real2(sfmt), 5.0*genrand_real2(sfmt)); context.setPositions(positions); State state1 = context.getState(State::Forces | State::Energy, false, 1<<0); State state2 = context.getState(State::Forces | State::Energy, false, 1<<1); ASSERT_EQUAL_TOL(state1.getPotentialEnergy(), state2.getPotentialEnergy(), TOL); for (int i = 0; i < numParticles; i++) ASSERT_EQUAL_VEC(state1.getForces()[i], state2.getForces()[i], TOL); } }
void* CustomCompoundBondForceProxy::deserialize(const SerializationNode& node) const { int version = node.getIntProperty("version"); if (version < 1 || version > 3) throw OpenMMException("Unsupported version number"); CustomCompoundBondForce* force = NULL; try { CustomCompoundBondForce* force = new CustomCompoundBondForce(node.getIntProperty("particles"), node.getStringProperty("energy")); force->setForceGroup(node.getIntProperty("forceGroup", 0)); if (version > 1) force->setUsesPeriodicBoundaryConditions(node.getBoolProperty("usesPeriodic")); const SerializationNode& perBondParams = node.getChildNode("PerBondParameters"); for (auto& parameter : perBondParams.getChildren()) force->addPerBondParameter(parameter.getStringProperty("name")); const SerializationNode& globalParams = node.getChildNode("GlobalParameters"); for (auto& parameter : globalParams.getChildren()) force->addGlobalParameter(parameter.getStringProperty("name"), parameter.getDoubleProperty("default")); if (version > 2) { const SerializationNode& energyDerivs = node.getChildNode("EnergyParameterDerivatives"); for (auto& parameter : energyDerivs.getChildren()) force->addEnergyParameterDerivative(parameter.getStringProperty("name")); } const SerializationNode& bonds = node.getChildNode("Bonds"); vector<int> particles(force->getNumParticlesPerBond()); vector<double> params(force->getNumPerBondParameters()); for (auto& bond : bonds.getChildren()) { for (int j = 0; j < (int) particles.size(); j++) { stringstream key; key << "p"; key << j+1; particles[j] = bond.getIntProperty(key.str()); } for (int j = 0; j < (int) params.size(); j++) { stringstream key; key << "param"; key << j+1; params[j] = bond.getDoubleProperty(key.str()); } force->addBond(particles, params); } const SerializationNode& functions = node.getChildNode("Functions"); for (auto& function : functions.getChildren()) { if (function.hasProperty("type")) { force->addTabulatedFunction(function.getStringProperty("name"), function.decodeObject<TabulatedFunction>()); } else { // This is an old file created before TabulatedFunction existed. const SerializationNode& valuesNode = function.getChildNode("Values"); vector<double> values; for (auto& child : valuesNode.getChildren()) values.push_back(child.getDoubleProperty("v")); force->addTabulatedFunction(function.getStringProperty("name"), new Continuous1DFunction(values, function.getDoubleProperty("min"), function.getDoubleProperty("max"))); } } return force; } catch (...) { if (force != NULL) delete force; throw; } }