Merge https://github.com/openmm/openmm

plugins/drude/platforms/reference/tests/TestReferenceDrudeNoseHoover.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2013 Stanford University and the Authors.           *
+ * Authors: Peter Eastman                                                     *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+//#include "ReferenceTests.h"
+#include "openmm/Platform.h"
+
+
+using namespace OpenMM;
+using namespace std;
+//extern "C" OPENMM_EXPORT void registerDrudeReferenceKernelFactories();
+
+
+Platform& initializePlatform(int argc, char* argv[]) {
+/*    registerDrudeReferenceKernelFactories();
+    */
+    return Platform::getPlatformByName("Reference");
+}
+
+#include "TestDrudeNoseHoover.h"
+
+void runPlatformTests() { }
+

plugins/drude/serialization/include/openmm/serialization/DrudeNoseHooverIntegratorProxy.h

+#ifndef OPENMM_DRUDE_NOSE_HOOVER_INTEGRATOR_PROXY_H_
+#define OPENMM_DRUDE_NOSE_HOOVER_INTEGRATOR_PROXY_H_
+
+#include "openmm/serialization/SerializationProxy.h"
+#include "openmm/internal/windowsExportDrude.h"
+
+namespace OpenMM {
+
+class OPENMM_EXPORT_DRUDE DrudeNoseHooverIntegratorProxy : public SerializationProxy {
+public:
+    DrudeNoseHooverIntegratorProxy();
+    void serialize(const void* object, SerializationNode& node) const;
+    void* deserialize(const SerializationNode& node) const;
+};
+
+}
+
+#endif /*OPENMM_DRUDE_NOSE_HOOVER_INTEGRATOR_PROXY_H_*/

plugins/drude/serialization/src/DrudeNoseHooverIntegratorProxy.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2010 Stanford University and the Authors.           *
+ * Authors: Andrew C. Simmonett, Andreas Krämer                               *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#include "openmm/serialization/DrudeNoseHooverIntegratorProxy.h"
+#include "openmm/serialization/SerializationNode.h"
+#include "openmm/DrudeNoseHooverIntegrator.h"
+#include <vector>
+#include <assert.h>
+#include <OpenMM.h>
+
+using namespace std;
+using namespace OpenMM;
+
+DrudeNoseHooverIntegratorProxy::DrudeNoseHooverIntegratorProxy() : SerializationProxy("DrudeNoseHooverIntegrator") {
+
+}
+
+void DrudeNoseHooverIntegratorProxy::serialize(const void* object, SerializationNode& node) const {
+    node.setIntProperty("version", 1);
+    const DrudeNoseHooverIntegrator& integrator = *reinterpret_cast<const DrudeNoseHooverIntegrator*>(object);
+    node.setDoubleProperty("stepSize", integrator.getStepSize());
+    node.setDoubleProperty("constraintTolerance", integrator.getConstraintTolerance());
+    node.setDoubleProperty("maximumPairDistance", integrator.getMaximumPairDistance());
+    assert(not integrator.hasSubsystemThermostats());
+    node.setDoubleProperty("temperature", integrator.getTemperature());
+    node.setDoubleProperty("relativeTemperature", integrator.getRelativeTemperature());
+    node.setDoubleProperty("collisionFrequency", integrator.getCollisionFrequency());
+    node.setDoubleProperty("relativeCollisionFrequency", integrator.getRelativeCollisionFrequency());
+    node.setIntProperty("chainLength", integrator.getThermostat().getChainLength());
+    node.setIntProperty("numMTS", integrator.getThermostat().getNumMultiTimeSteps());
+    node.setIntProperty("numYS", integrator.getThermostat().getNumYoshidaSuzukiTimeSteps());
+}
+
+void* DrudeNoseHooverIntegratorProxy::deserialize(const SerializationNode& node) const {
+    if (node.getIntProperty("version") != 1)
+        throw OpenMMException("Unsupported version number");
+    DrudeNoseHooverIntegrator* integrator;
+    integrator = new DrudeNoseHooverIntegrator(
+        node.getDoubleProperty("temperature"),
+        node.getDoubleProperty("collisionFrequency"),
+        node.getDoubleProperty("relativeTemperature"),
+        node.getDoubleProperty("relativeCollisionFrequency"),
+        node.getDoubleProperty("stepSize"),
+        node.getIntProperty("chainLength"),
+        node.getIntProperty("numMTS"),
+        node.getIntProperty("numYS")
+    );
+    integrator->setConstraintTolerance(node.getDoubleProperty("constraintTolerance"));
+    integrator->setMaximumPairDistance(node.getDoubleProperty("maximumPairDistance"));
+
+    return integrator;
+}

plugins/drude/serialization/src/DrudeSerializationProxyRegistration.cpp

@@ -42,11 +42,13 @@
 
 #include "openmm/DrudeForce.h"
 #include "openmm/DrudeLangevinIntegrator.h"
+#include "openmm/DrudeNoseHooverIntegrator.h"
 
 #include "openmm/serialization/SerializationProxy.h"
 
 #include "openmm/serialization/DrudeForceProxy.h"
 #include "openmm/serialization/DrudeLangevinIntegratorProxy.h"
+#include "openmm/serialization/DrudeNoseHooverIntegratorProxy.h"
 
 #if defined(WIN32)
     #include <windows.h>
@@ -65,4 +67,5 @@ using namespace OpenMM;
 extern "C" OPENMM_EXPORT_DRUDE void registerDrudeSerializationProxies() {
     SerializationProxy::registerProxy(typeid(DrudeForce), new DrudeForceProxy());
     SerializationProxy::registerProxy(typeid(DrudeLangevinIntegrator), new DrudeLangevinIntegratorProxy());
+    SerializationProxy::registerProxy(typeid(DrudeNoseHooverIntegrator), new DrudeNoseHooverIntegratorProxy());
 }

plugins/drude/serialization/tests/TestSerializeDrudeNoseHooverIntegrator.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2010-2014 Stanford University and the Authors.      *
+ * Authors: Andrew C. Simmonett and Andreas Kraemer
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#include "openmm/internal/AssertionUtilities.h"
+#include "openmm/DrudeNoseHooverIntegrator.h"
+#include "ReferencePlatform.h"
+#include "openmm/serialization/XmlSerializer.h"
+#include "openmm/System.h"
+#include "openmm/DrudeForce.h"
+#include "openmm/Context.h"
+#include <iostream>
+#include <sstream>
+
+using namespace OpenMM;
+using namespace std;
+
+extern "C" void registerDrudeSerializationProxies();
+//extern "C" OPENMM_EXPORT void registerDrudeReferenceKernelFactories(); 
+//extern "C" OPENMM_EXPORT void registerKernelFactories();
+
+void assertIntegratorsEqual(const DrudeNoseHooverIntegrator& integrator1, const DrudeNoseHooverIntegrator& integrator2){
+    ASSERT_EQUAL(integrator1.getStepSize(), integrator2.getStepSize());
+    ASSERT_EQUAL(integrator1.getConstraintTolerance(), integrator2.getConstraintTolerance());
+    ASSERT_EQUAL(integrator1.getMaximumPairDistance(), integrator2.getMaximumPairDistance());
+    ASSERT_EQUAL(integrator1.getNumThermostats(), integrator2.getNumThermostats());
+    for (int i = 0; i < integrator1.getNumThermostats(); i++) {
+        const auto &thermostat1 = integrator1.getThermostat(i);
+        const auto &thermostat2 = integrator2.getThermostat(i);
+        ASSERT_EQUAL(thermostat1.getTemperature(), thermostat2.getTemperature());
+        ASSERT_EQUAL(thermostat1.getCollisionFrequency(), thermostat2.getCollisionFrequency());
+        ASSERT_EQUAL(thermostat1.getRelativeTemperature(), thermostat2.getRelativeTemperature());
+        ASSERT_EQUAL(thermostat1.getRelativeCollisionFrequency(), thermostat2.getRelativeCollisionFrequency());
+        ASSERT_EQUAL(thermostat1.getChainLength(), thermostat2.getChainLength());
+        ASSERT_EQUAL(thermostat1.getNumMultiTimeSteps(), thermostat2.getNumMultiTimeSteps());
+        ASSERT_EQUAL(thermostat1.getNumYoshidaSuzukiTimeSteps(), thermostat2.getNumYoshidaSuzukiTimeSteps());
+        ASSERT_EQUAL(thermostat1.getChainID(), thermostat2.getChainID());
+        const auto &thermostat1Atoms = thermostat1.getThermostatedAtoms();
+        const auto &thermostat2Atoms = thermostat2.getThermostatedAtoms();
+        ASSERT_EQUAL(thermostat1Atoms.size(), thermostat2Atoms.size());
+        for (int j = 0; j < thermostat1Atoms.size(); ++j) {
+            ASSERT_EQUAL(thermostat1Atoms[j], thermostat2Atoms[j]);
+        }
+        const auto &thermostat1Pairs = thermostat1.getThermostatedPairs();
+        const auto &thermostat2Pairs = thermostat2.getThermostatedPairs();
+        ASSERT_EQUAL(thermostat1Pairs.size(), thermostat2Pairs.size());
+        for (int j = 0; j < thermostat1Pairs.size(); ++j) {
+            ASSERT_EQUAL(thermostat1Pairs[j].first, thermostat2Pairs[j].first);
+            ASSERT_EQUAL(thermostat1Pairs[j].second, thermostat2Pairs[j].second);
+        }
+    }
+}
+
+void testSerialization() {
+    // Check with default constructor
+    System system;
+    system.addForce(new DrudeForce());
+    for (int i=0; i<10; i++) system.addParticle(1.0);
+    DrudeNoseHooverIntegrator integrator(331, 0.21, 1.1, 0.1, 0.004, 5, 5, 5);
+
+    // Serialize and then deserialize it.
+    stringstream buffer2;
+    XmlSerializer::serialize<DrudeNoseHooverIntegrator>(&integrator, "Integrator", buffer2);
+    DrudeNoseHooverIntegrator* copy = XmlSerializer::deserialize<DrudeNoseHooverIntegrator>(buffer2);
+
+    ASSERT_EQUAL(copy->getThermostat(0).getThermostatedAtoms().size(), 0);
+    assertIntegratorsEqual(integrator, *copy);
+
+}
+
+int main() {
+    try {
+        testSerialization();
+    }
+    catch(const exception& e) {
+        cout << "exception: " << e.what() << endl;
+        return 1;
+    }
+    cout << "Done" << endl;
+    return 0;
+}
+

plugins/drude/tests/TestDrudeNoseHoover.h

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2019 Stanford University and the Authors.           *
+ * Authors: Andreas Krämer and Andrew C. Simmonett                            *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#include "openmm/internal/AssertionUtilities.h"
+#include "openmm/NoseHooverChain.h"
+#include "openmm/CMMotionRemover.h"
+#include "openmm/DrudeNoseHooverIntegrator.h"
+#include "openmm/Context.h"
+#include "openmm/State.h"
+#include "openmm/HarmonicBondForce.h"
+#include "openmm/VirtualSite.h"
+#include "openmm/NonbondedForce.h"
+#include "openmm/CustomExternalForce.h"
+#include "openmm/System.h"
+#include "openmm/DrudeForce.h"
+#include "SimTKOpenMMRealType.h"
+#include "sfmt/SFMT.h"
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <algorithm>
+#include <numeric>
+
+using namespace OpenMM;
+using namespace std;
+extern "C" OPENMM_EXPORT void registerDrudeReferenceKernelFactories();
+extern "C" OPENMM_EXPORT void registerKernelFactories();
+Platform& initializePlatform(int argc, char* argv[]);
+
+void build_waterbox(System &system, int gridSize, double polarizability, vector<Vec3> & positions) {
+    // Create a box of SWM4-NDP water molecules.  This involves constraints, virtual sites,
+    // and Drude particles.
+    const int numMolecules = gridSize*gridSize*gridSize;
+    const double spacing = 0.8;
+    const double boxSize = spacing*(gridSize+1);
+    NonbondedForce* nonbonded = new NonbondedForce();
+    DrudeForce* drude = new DrudeForce();
+    CMMotionRemover* cmm = new CMMotionRemover(1);
+    system.addForce(cmm);
+    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.2);
+    nonbonded->setSwitchingDistance(0.8);
+    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, polarizability, 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);
+                positions.push_back(pos+Vec3(0.09572, 0, 0));
+                positions.push_back(pos+Vec3(-0.023999, 0.092663, 0));
+                positions.push_back(pos);
+            }
+        }
+    }
+}
+
+void testWaterBox(Platform& platform) {
+    // Create a box of SWM4-NDP water molecules.  This involves constraints, virtual sites,
+    // and Drude particles.
+    System system;
+    const int gridSize = 3;
+    vector<Vec3> positions;
+    double polarizability = ONE_4PI_EPS0*1.71636*1.71636/(100000*4.184);
+
+    build_waterbox(system, gridSize, polarizability, positions);
+
+    const int numMolecules = gridSize*gridSize*gridSize;
+    int numStandardDof = 3*3*numMolecules - system.getNumConstraints();
+    int numDrudeDof = 3*numMolecules;
+    int numDof = numStandardDof+numDrudeDof;
+    const double temperature = 300.0;
+    const double temperatureDrude = 10.0;
+
+    // Simulate it and check the temperature.
+    int chainLength = 4;
+    int numMTS = 4;
+    int numYS = 5;
+    double frequency = 800.0;
+    double frequencyDrude = 2000.0;
+    int randomSeed = 100;
+    DrudeNoseHooverIntegrator integ(temperature, frequency, 
+                                    temperatureDrude, frequencyDrude, 0.0005, 
+                                    chainLength, numMTS, numYS);
+    Context context(system, integ, platform);
+    context.setPositions(positions);
+    context.setVelocitiesToTemperature(temperature, randomSeed);
+    std::vector<Vec3> velocities = context.getState(State::Velocities).getVelocities();
+    for (int i = 0; i < numMolecules; i++){
+        Vec3 noize;
+        for (int j = 0; j < 3; j++){
+            noize[j] = float(((i+18311)*(j+18253) * 313419097822414) % 18313) / float(18313);
+            noize[j] *= sqrt(3 * BOLTZ * temperatureDrude / 0.4);
+        }
+        velocities[5*i+1] = velocities[5*i] + noize;
+    }
+    context.setVelocities(velocities);
+    context.applyConstraints(1e-6);
+
+    // Equilibrate.
+    integ.step(500);
+
+    // Compute the internal and center of mass temperatures.
+
+    double totalKE = 0;
+    const int numSteps = 4000;
+    double meanTemp = 0.0;
+    double meanDrudeTemp = 0.0;
+    double meanConserved = 0.0;
+    for (int i = 0; i < numSteps; i++) {
+        integ.step(1);
+        State state = context.getState(State::Energy);
+        double KE = state.getKineticEnergy();
+        double PE = state.getPotentialEnergy();
+        double fullKE = integ.computeTotalKineticEnergy();
+        double drudeKE = integ.computeDrudeKineticEnergy();
+        double temp = KE/(0.5*numStandardDof*BOLTZ);
+        double drudeTemp = drudeKE/(0.5*numDrudeDof*BOLTZ);
+        meanTemp = (i*meanTemp + temp)/(i+1);
+        meanDrudeTemp = (i*meanDrudeTemp + drudeTemp)/(i+1);
+        double heatBathEnergy = integ.computeHeatBathEnergy();
+        double conserved = PE + fullKE + heatBathEnergy;
+        meanConserved = (i*meanConserved + conserved)/(i+1);
+        totalKE += KE;
+        ASSERT(fabs(meanConserved - conserved) < 0.6);
+    }
+    totalKE /= numSteps;
+    ASSERT_USUALLY_EQUAL_TOL(temperature, meanTemp,  0.004);
+    ASSERT_USUALLY_EQUAL_TOL(temperatureDrude, meanDrudeTemp,  0.004);
+}
+
+
+double testWaterBoxWithHardWallConstraint(Platform& platform, double hardWallConstraint){
+    // Create a box of SWM4-NDP water molecules.  This involves constraints, virtual sites,
+    // and Drude particles.
+    System system;
+    const int gridSize = 3;
+    vector<Vec3> positions;
+
+    double polarizability = 1e-2;
+    build_waterbox(system, gridSize, polarizability, positions);
+
+    const int numMolecules = gridSize*gridSize*gridSize;
+    int numStandardDof = 3*3*numMolecules - system.getNumConstraints();
+    int numDrudeDof = 3*numMolecules;
+    int numDof = numStandardDof+numDrudeDof;
+    const double temperature = 300.0;
+    const double temperatureDrude = 10.0;
+
+    // Simulate it and check the temperature.
+    int chainLength = 4;
+    int numMTS = 3;
+    int numYS = 3;
+    double frequency = 25.0;
+    double frequencyDrude = 25.0;
+    int randomSeed = 100;
+    DrudeNoseHooverIntegrator integ(temperature, frequency, 
+                                    temperatureDrude, frequencyDrude, 0.0005, 
+                                    chainLength, numMTS, numYS);
+    integ.setMaxDrudeDistance(hardWallConstraint);
+    Context context(system, integ, platform);
+    context.setPositions(positions);
+    context.setVelocitiesToTemperature(temperature, randomSeed);
+    std::vector<Vec3> velocities = context.getState(State::Velocities).getVelocities();
+    for (int i = 0; i < numMolecules; i++){
+        Vec3 noize;
+        for (int j = 0; j < 3; j++){
+            noize[j] = float(((i+18311)*(j+18253) * 313419097822414) % 18313) / float(18313);
+            noize[j] *= sqrt(3 * BOLTZ * temperatureDrude / 0.4);
+        }
+        velocities[5*i+1] = velocities[5*i] + noize;
+    }
+    context.setVelocities(velocities);
+    context.applyConstraints(1e-6);
+    // Equilibrate.
+    
+    integ.step(10);
+    // Compute the internal and center of mass temperatures.
+    
+    double totalKE = 0;
+    const int numSteps = 10;
+    double meanTemp = 0.0;
+    double meanDrudeTemp = 0.0;
+    double meanConserved = 0.0;
+    double maxR = 0.0;
+    for (int i = 0; i < numSteps; i++) {
+        integ.step(1);
+        State state = context.getState(State::Energy | State::Positions);
+        double KE = state.getKineticEnergy();
+        double PE = state.getPotentialEnergy();
+        double fullKE = integ.computeTotalKineticEnergy();
+        double drudeKE = integ.computeDrudeKineticEnergy();
+        double temp = KE/(0.5*numStandardDof*BOLTZ);
+        double drudeTemp = drudeKE/(0.5*numDrudeDof*BOLTZ);
+        meanTemp = (i*meanTemp + temp)/(i+1);
+        meanDrudeTemp = (i*meanDrudeTemp + drudeTemp)/(i+1);
+        double heatBathEnergy = integ.computeHeatBathEnergy();
+        double conserved = PE + fullKE + heatBathEnergy;
+        meanConserved = (i*meanConserved + conserved)/(i+1);
+        const auto & positions = state.getPositions();
+        for(int mol = 0; mol < gridSize*gridSize*gridSize; ++mol) {
+            auto dR = positions[5*mol+1] - positions[5*mol];
+            maxR = std::max(maxR, std::sqrt(dR.dot(dR)));
+        }
+        totalKE += KE;
+    }
+    totalKE /= numSteps;
+    return maxR;
+}
+
+
+int main(int argc, char* argv[]) {
+    try {
+        registerKernelFactories();
+
+        Platform& platform = initializePlatform(argc, argv);
+        testWaterBox(platform);
+        double maxDrudeDistance = 0.005;
+        double observedDrudeDistance = testWaterBoxWithHardWallConstraint(platform, 0.0);
+        ASSERT(observedDrudeDistance > maxDrudeDistance);
+        observedDrudeDistance = testWaterBoxWithHardWallConstraint(platform, maxDrudeDistance);
+        ASSERT(observedDrudeDistance < maxDrudeDistance);
+    }
+    catch(const exception& e) {
+        cout << "exception: " << e.what() << endl;
+        return 1;
+    }
+    cout << "Done" << endl;
+    return 0;
+}
+

plugins/rpmd/platforms/cuda/CMakeLists.txt

@@ -63,27 +63,28 @@ INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/src)
 INCLUDE_DIRECTORIES(BEFORE ${CMAKE_SOURCE_DIR}/platforms/cuda/include)
 INCLUDE_DIRECTORIES(BEFORE ${CMAKE_SOURCE_DIR}/platforms/cuda/src)
 INCLUDE_DIRECTORIES(BEFORE ${CMAKE_BINARY_DIR}/platforms/cuda/src)
+INCLUDE_DIRECTORIES(BEFORE ${CMAKE_SOURCE_DIR}/platforms/common/include)
 
 # Set variables needed for encoding kernel sources into a C++ class
 
-SET(CUDA_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
-SET(CUDA_SOURCE_CLASS CudaRpmdKernelSources)
-SET(CUDA_KERNELS_CPP ${CMAKE_CURRENT_BINARY_DIR}/src/${CUDA_SOURCE_CLASS}.cpp)
-SET(CUDA_KERNELS_H ${CMAKE_CURRENT_BINARY_DIR}/src/${CUDA_SOURCE_CLASS}.h)
-SET(SOURCE_FILES ${SOURCE_FILES} ${CUDA_KERNELS_CPP} ${CUDA_KERNELS_H})
+SET(KERNEL_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
+SET(KERNEL_SOURCE_CLASS CudaRpmdKernelSources)
+SET(KERNELS_CPP ${CMAKE_CURRENT_BINARY_DIR}/src/${KERNEL_SOURCE_CLASS}.cpp)
+SET(KERNELS_H ${CMAKE_CURRENT_BINARY_DIR}/src/${KERNEL_SOURCE_CLASS}.h)
+SET(SOURCE_FILES ${SOURCE_FILES} ${KERNELS_CPP} ${KERNELS_H})
 INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/src)
 
 # Create the library
 
 INCLUDE_DIRECTORIES(${CUDA_TOOLKIT_INCLUDE})
 
-FILE(GLOB CUDA_KERNELS ${CUDA_SOURCE_DIR}/kernels/*.cu)
-ADD_CUSTOM_COMMAND(OUTPUT ${CUDA_KERNELS_CPP} ${CUDA_KERNELS_H}
+FILE(GLOB CUDA_KERNELS ${KERNEL_SOURCE_DIR}/kernels/*.cu)
+ADD_CUSTOM_COMMAND(OUTPUT ${KERNELS_CPP} ${KERNELS_H}
     COMMAND ${CMAKE_COMMAND}
-    ARGS -D CUDA_SOURCE_DIR=${CUDA_SOURCE_DIR} -D CUDA_KERNELS_CPP=${CUDA_KERNELS_CPP} -D CUDA_KERNELS_H=${CUDA_KERNELS_H} -D CUDA_SOURCE_CLASS=${CUDA_SOURCE_CLASS} -P ${CMAKE_SOURCE_DIR}/platforms/cuda/EncodeCUDAFiles.cmake
+    ARGS -D KERNEL_SOURCE_DIR=${KERNEL_SOURCE_DIR} -D KERNELS_CPP=${KERNELS_CPP} -D KERNELS_H=${KERNELS_H} -D KERNEL_SOURCE_CLASS=${KERNEL_SOURCE_CLASS} -D KERNEL_FILE_EXTENSION=cu -P ${CMAKE_SOURCE_DIR}/cmake_modules/EncodeKernelFiles.cmake
     DEPENDS ${CUDA_KERNELS}
 )
-SET_SOURCE_FILES_PROPERTIES(${CUDA_KERNELS_CPP} ${CUDA_KERNELS_H} PROPERTIES GENERATED TRUE)
+SET_SOURCE_FILES_PROPERTIES(${KERNELS_CPP} ${KERNELS_H} PROPERTIES GENERATED TRUE)
 ADD_LIBRARY(${SHARED_TARGET} SHARED ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
 
 TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${OPENMM_LIBRARY_NAME} ${PTHREADS_LIB})

plugins/rpmd/platforms/cuda/src/CudaRpmdKernelSources.h.in

@@ -39,7 +39,7 @@ namespace OpenMM {
 
 class CudaRpmdKernelSources {
 public:
-@CUDA_FILE_DECLARATIONS@
+@KERNEL_FILE_DECLARATIONS@
 };
 
 } // namespace OpenMM

plugins/rpmd/platforms/cuda/src/CudaRpmdKernels.cpp

@@ -307,7 +307,7 @@ void CudaIntegrateRPMDStepKernel::setPositions(int copy, const vector<Vec3>& pos
     double4 periodicBoxSize = cu.getPeriodicBoxSize();
     vector<Vec3> offsetPos(numParticles);
     for (int i = 0; i < numParticles; ++i) {
-        int4 offset = cu.getPosCellOffsets()[i];
+        mm_int4 offset = cu.getPosCellOffsets()[i];
         offsetPos[order[i]] = pos[order[i]] + Vec3(offset.x*periodicBoxSize.x, offset.y*periodicBoxSize.y, offset.z*periodicBoxSize.z);
     }
 

plugins/rpmd/platforms/opencl/CMakeLists.txt

@@ -62,27 +62,28 @@ ENDFOREACH(subdir)
 INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/src)
 INCLUDE_DIRECTORIES(BEFORE ${CMAKE_SOURCE_DIR}/platforms/opencl/include)
 INCLUDE_DIRECTORIES(BEFORE ${CMAKE_SOURCE_DIR}/platforms/opencl/src)
+INCLUDE_DIRECTORIES(BEFORE ${CMAKE_SOURCE_DIR}/platforms/common/include)
 
 # Set variables needed for encoding kernel sources into a C++ class
 
-SET(CL_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
-SET(CL_SOURCE_CLASS OpenCLRpmdKernelSources)
-SET(CL_KERNELS_CPP ${CMAKE_CURRENT_BINARY_DIR}/src/${CL_SOURCE_CLASS}.cpp)
-SET(CL_KERNELS_H ${CMAKE_CURRENT_BINARY_DIR}/src/${CL_SOURCE_CLASS}.h)
-SET(SOURCE_FILES ${SOURCE_FILES} ${CL_KERNELS_CPP} ${CL_KERNELS_H})
+SET(KERNEL_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
+SET(KERNEL_SOURCE_CLASS OpenCLRpmdKernelSources)
+SET(KERNELS_CPP ${CMAKE_CURRENT_BINARY_DIR}/src/${KERNEL_SOURCE_CLASS}.cpp)
+SET(KERNELS_H ${CMAKE_CURRENT_BINARY_DIR}/src/${KERNEL_SOURCE_CLASS}.h)
+SET(SOURCE_FILES ${SOURCE_FILES} ${KERNELS_CPP} ${KERNELS_H})
 INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/src)
 
 # Create the library
 
 INCLUDE_DIRECTORIES(${OPENCL_INCLUDE_DIR})
 
-FILE(GLOB OPENCL_KERNELS ${CL_SOURCE_DIR}/kernels/*.cl)
-ADD_CUSTOM_COMMAND(OUTPUT ${CL_KERNELS_CPP} ${CL_KERNELS_H}
+FILE(GLOB OPENCL_KERNELS ${KERNEL_SOURCE_DIR}/kernels/*.cl)
+ADD_CUSTOM_COMMAND(OUTPUT ${KERNELS_CPP} ${KERNELS_H}
     COMMAND ${CMAKE_COMMAND}
-    ARGS -D CL_SOURCE_DIR=${CL_SOURCE_DIR} -D CL_KERNELS_CPP=${CL_KERNELS_CPP} -D CL_KERNELS_H=${CL_KERNELS_H} -D CL_SOURCE_CLASS=${CL_SOURCE_CLASS} -P ${CMAKE_SOURCE_DIR}/platforms/opencl/EncodeCLFiles.cmake
+    ARGS -D KERNEL_SOURCE_DIR=${KERNEL_SOURCE_DIR} -D KERNELS_CPP=${KERNELS_CPP} -D KERNELS_H=${KERNELS_H} -D KERNEL_SOURCE_CLASS=${KERNEL_SOURCE_CLASS} -D KERNEL_FILE_EXTENSION=cl -P ${CMAKE_SOURCE_DIR}/cmake_modules/EncodeKernelFiles.cmake
     DEPENDS ${OPENCL_KERNELS}
 )
-SET_SOURCE_FILES_PROPERTIES(${CL_KERNELS_CPP} ${CL_KERNELS_H} PROPERTIES GENERATED TRUE)
+SET_SOURCE_FILES_PROPERTIES(${KERNELS_CPP} ${KERNELS_H} PROPERTIES GENERATED TRUE)
 ADD_LIBRARY(${SHARED_TARGET} SHARED ${SOURCE_FILES} ${SOURCE_INCLUDE_FILES} ${API_ABS_INCLUDE_FILES})
 
 TARGET_LINK_LIBRARIES(${SHARED_TARGET} ${OPENMM_LIBRARY_NAME}  ${OPENCL_LIBRARIES} ${PTHREADS_LIB})

plugins/rpmd/platforms/opencl/src/OpenCLRpmdKernelSources.h.in

@@ -39,7 +39,7 @@ namespace OpenMM {
 
 class OpenCLRpmdKernelSources {
 public:
-@CL_FILE_DECLARATIONS@
+@KERNEL_FILE_DECLARATIONS@
 };
 
 } // namespace OpenMM

serialization/include/openmm/serialization/LangevinMiddleIntegratorProxy.h

+#ifndef OPENMM_LANGEVIN_MIDDLE_INTEGRATOR_PROXY_H_
+#define OPENMM_LANGEVIN_MIDDLE_INTEGRATOR_PROXY_H_
+
+#include "openmm/serialization/XmlSerializer.h"
+
+namespace OpenMM {
+
+class LangevinMiddleIntegratorProxy : public SerializationProxy {
+public:
+    LangevinMiddleIntegratorProxy();
+    void serialize(const void* object, SerializationNode& node) const;
+    void* deserialize(const SerializationNode& node) const;
+};
+
+}
+
+#endif /*OPENMM_LANGEVIN_MIDDLE_INTEGRATOR_PROXY_H_*/
\ No newline at end of file

serialization/include/openmm/serialization/BAOABLangevinIntegratorProxy.h → serialization/include/openmm/serialization/NoseHooverIntegratorProxy.h

-#ifndef OPENMM_BAOAB_LANGEVIN_INTEGRATOR_PROXY_H_
-#define OPENMM_BAOAB_LANGEVIN_INTEGRATOR_PROXY_H_
-
-#include "openmm/serialization/XmlSerializer.h"
-
-namespace OpenMM {
-
-class BAOABLangevinIntegratorProxy : public SerializationProxy {
-public:
-    BAOABLangevinIntegratorProxy();
-    void serialize(const void* object, SerializationNode& node) const;
-    void* deserialize(const SerializationNode& node) const;
-};
-
-}
-
-#endif /*OPENMM_BAOAB_LANGEVIN_INTEGRATOR_PROXY_H_*/
+#ifndef OPENMM_NOSE_HOOVER_INTEGRATOR_PROXY_H_
+#define OPENMM_NOSE_HOOVER_INTEGRATOR_PROXY_H_
+
+#include "openmm/serialization/XmlSerializer.h"
+
+namespace OpenMM {
+
+class NoseHooverIntegratorProxy : public SerializationProxy {
+public:
+    NoseHooverIntegratorProxy();
+    void serialize(const void* object, SerializationNode& node) const;
+    void* deserialize(const SerializationNode& node) const;
+};
+
+}
+
+#endif /*OPENMM_NOSE_HOOVER_INTEGRATOR_PROXY_H_*/
\ No newline at end of file

serialization/src/BAOABLangevinIntegratorProxy.cpp → serialization/src/LangevinMiddleIntegratorProxy.cpp

@@ -29,19 +29,19 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
  * -------------------------------------------------------------------------- */
 
-#include "openmm/serialization/BAOABLangevinIntegratorProxy.h"
+#include "openmm/serialization/LangevinMiddleIntegratorProxy.h"
 #include <OpenMM.h>
 
 using namespace std;
 using namespace OpenMM;
 
-BAOABLangevinIntegratorProxy::BAOABLangevinIntegratorProxy() : SerializationProxy("BAOABLangevinIntegrator") {
+LangevinMiddleIntegratorProxy::LangevinMiddleIntegratorProxy() : SerializationProxy("LangevinMiddleIntegrator") {
 
 }
 
-void BAOABLangevinIntegratorProxy::serialize(const void* object, SerializationNode& node) const {
+void LangevinMiddleIntegratorProxy::serialize(const void* object, SerializationNode& node) const {
     node.setIntProperty("version", 1);
-    const BAOABLangevinIntegrator& integrator = *reinterpret_cast<const BAOABLangevinIntegrator*>(object);
+    const LangevinMiddleIntegrator& integrator = *reinterpret_cast<const LangevinMiddleIntegrator*>(object);
     node.setDoubleProperty("stepSize", integrator.getStepSize());
     node.setDoubleProperty("constraintTolerance", integrator.getConstraintTolerance());
     node.setDoubleProperty("temperature", integrator.getTemperature());
@@ -49,10 +49,10 @@ void BAOABLangevinIntegratorProxy::serialize(const void* object, SerializationNo
     node.setIntProperty("randomSeed", integrator.getRandomNumberSeed());
 }
 
-void* BAOABLangevinIntegratorProxy::deserialize(const SerializationNode& node) const {
+void* LangevinMiddleIntegratorProxy::deserialize(const SerializationNode& node) const {
     if (node.getIntProperty("version") != 1)
         throw OpenMMException("Unsupported version number");
-    BAOABLangevinIntegrator *integrator = new BAOABLangevinIntegrator(node.getDoubleProperty("temperature"),
+    LangevinMiddleIntegrator *integrator = new LangevinMiddleIntegrator(node.getDoubleProperty("temperature"),
             node.getDoubleProperty("friction"), node.getDoubleProperty("stepSize"));
     integrator->setConstraintTolerance(node.getDoubleProperty("constraintTolerance"));
     integrator->setRandomNumberSeed(node.getIntProperty("randomSeed"));

serialization/src/NonbondedForceProxy.cpp

@@ -6,7 +6,7 @@
  * Biological Structures at Stanford, funded under the NIH Roadmap for        *
  * Medical Research, grant U54 GM072970. See https://simtk.org.               *
  *                                                                            *
- * Portions copyright (c) 2010-2018 Stanford University and the Authors.      *
+ * Portions copyright (c) 2010-2020 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -42,7 +42,7 @@ NonbondedForceProxy::NonbondedForceProxy() : SerializationProxy("NonbondedForce"
 }
 
 void NonbondedForceProxy::serialize(const void* object, SerializationNode& node) const {
-    node.setIntProperty("version", 3);
+    node.setIntProperty("version", 4);
     const NonbondedForce& force = *reinterpret_cast<const NonbondedForce*>(object);
     node.setIntProperty("forceGroup", force.getForceGroup());
     node.setIntProperty("method", (int) force.getNonbondedMethod());
@@ -52,6 +52,7 @@ void NonbondedForceProxy::serialize(const void* object, SerializationNode& node)
     node.setDoubleProperty("ewaldTolerance", force.getEwaldErrorTolerance());
     node.setDoubleProperty("rfDielectric", force.getReactionFieldDielectric());
     node.setIntProperty("dispersionCorrection", force.getUseDispersionCorrection());
+    node.setIntProperty("exceptionsUsePeriodic", force.getExceptionsUsePeriodicBoundaryConditions());
     double alpha;
     int nx, ny, nz;
     force.getPMEParameters(alpha, nx, ny, nz);
@@ -101,7 +102,7 @@ void NonbondedForceProxy::serialize(const void* object, SerializationNode& node)
 
 void* NonbondedForceProxy::deserialize(const SerializationNode& node) const {
     int version = node.getIntProperty("version");
-    if (version < 1 || version > 3)
+    if (version < 1 || version > 4)
         throw OpenMMException("Unsupported version number");
     NonbondedForce* force = new NonbondedForce();
     try {
@@ -137,6 +138,8 @@ void* NonbondedForceProxy::deserialize(const SerializationNode& node) const {
             for (auto& offset : exceptionOffsets.getChildren())
                 force->addExceptionParameterOffset(offset.getStringProperty("parameter"), offset.getIntProperty("exception"), offset.getDoubleProperty("q"), offset.getDoubleProperty("sig"), offset.getDoubleProperty("eps"));
         }
+        if (version >= 4)
+            force->setExceptionsUsePeriodicBoundaryConditions(node.getIntProperty("exceptionsUsePeriodic"));
         const SerializationNode& particles = node.getChildNode("Particles");
         for (auto& particle : particles.getChildren())
             force->addParticle(particle.getDoubleProperty("q"), particle.getDoubleProperty("sig"), particle.getDoubleProperty("eps"));

serialization/src/NoseHooverIntegratorProxy.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2010 Stanford University and the Authors.           *
+ * Authors: Andrew C. Simmonett, Andreas Krämer                               *
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#include "openmm/serialization/NoseHooverIntegratorProxy.h"
+#include <vector>
+#include <OpenMM.h>
+
+using namespace std;
+using namespace OpenMM;
+
+NoseHooverIntegratorProxy::NoseHooverIntegratorProxy() : SerializationProxy("NoseHooverIntegrator") {
+
+}
+
+void NoseHooverIntegratorProxy::serialize(const void* object, SerializationNode& node) const {
+    node.setIntProperty("version", 1);
+    const NoseHooverIntegrator& integrator = *reinterpret_cast<const NoseHooverIntegrator*>(object);
+    node.setDoubleProperty("stepSize", integrator.getStepSize());
+    node.setDoubleProperty("constraintTolerance", integrator.getConstraintTolerance());
+    node.setDoubleProperty("maximumPairDistance", integrator.getMaximumPairDistance());
+    node.setBoolProperty("hasSubsystemThermostats", integrator.hasSubsystemThermostats());
+    if (integrator.hasSubsystemThermostats()) {
+        // Serialize all thermostats separately
+        for (int i = 0; i < integrator.getNumThermostats(); i++){
+            const auto& chain = integrator.getThermostat(i);
+            auto& chainNode = node.createChildNode("Thermostat");
+            chainNode.setDoubleProperty("temperature", chain.getTemperature());
+            chainNode.setDoubleProperty("collisionFrequency", chain.getCollisionFrequency());
+            chainNode.setDoubleProperty("relativeTemperature", chain.getRelativeTemperature());
+            chainNode.setDoubleProperty("relativeCollisionFrequency", chain.getRelativeCollisionFrequency());
+            chainNode.setIntProperty("chainLength", chain.getChainLength());
+            chainNode.setIntProperty("numMTS", chain.getNumMultiTimeSteps());
+            chainNode.setIntProperty("numYS", chain.getNumYoshidaSuzukiTimeSteps());
+            auto& particlesNode = chainNode.createChildNode("ThermostatedAtoms");
+            for (int particle: chain.getThermostatedAtoms()){
+                particlesNode.createChildNode("Particle").setIntProperty("index", particle);
+            }
+            auto& pairsNode = chainNode.createChildNode("ThermostatedPairs");
+            for (auto& pair: chain.getThermostatedPairs()){
+                auto& pairNode = pairsNode.createChildNode("Pair");
+                pairNode.setIntProperty("index1", pair.first);
+                pairNode.setIntProperty("index2", pair.second);
+            }
+        }
+    } else { // Serialize standard thermostat
+        node.setDoubleProperty("temperature", integrator.getTemperature());
+        node.setDoubleProperty("collisionFrequency", integrator.getCollisionFrequency());
+        node.setIntProperty("chainLength", integrator.getThermostat().getChainLength());
+        node.setIntProperty("numMTS", integrator.getThermostat().getNumMultiTimeSteps());
+        node.setIntProperty("numYS", integrator.getThermostat().getNumYoshidaSuzukiTimeSteps());
+    }
+
+}
+
+void* NoseHooverIntegratorProxy::deserialize(const SerializationNode& node) const {
+    if (node.getIntProperty("version") != 1)
+        throw OpenMMException("Unsupported version number");
+    NoseHooverIntegrator* integrator;
+    if (node.getBoolProperty("hasSubsystemThermostats")){
+        // deserialize all chains
+        integrator = new NoseHooverIntegrator(node.getDoubleProperty("stepSize"));
+        for (auto& chainNode : node.getChildren()) {
+            // particles
+            const auto& particlesNode = chainNode.getChildNode("ThermostatedAtoms");
+            vector<int> particles;
+            for (auto& particleNode: particlesNode.getChildren()){
+                particles.push_back(particleNode.getIntProperty("index"));
+            }
+            // pairs
+            const auto& pairsNode = chainNode.getChildNode("ThermostatedPairs");
+            vector<pair<int, int>> pairs;
+            for (auto& pairNode: pairsNode.getChildren()){
+                pairs.emplace_back(pairNode.getIntProperty("index1"), pairNode.getIntProperty("index2"));
+            }
+            integrator->addSubsystemThermostat(
+                particles, pairs, 
+                chainNode.getDoubleProperty("temperature"),
+                chainNode.getDoubleProperty("collisionFrequency"),
+                chainNode.getDoubleProperty("relativeTemperature"),
+                chainNode.getDoubleProperty("relativeCollisionFrequency"),
+                chainNode.getIntProperty("chainLength"),
+                chainNode.getIntProperty("numMTS"),
+                chainNode.getIntProperty("numYS")
+            );
+        }
+    } else {
+        integrator = new NoseHooverIntegrator(
+            node.getDoubleProperty("temperature"),
+            node.getDoubleProperty("collisionFrequency"),
+            node.getDoubleProperty("stepSize"),
+            node.getIntProperty("chainLength"),
+            node.getIntProperty("numMTS"),
+            node.getIntProperty("numYS")
+        );
+    }
+    integrator->setConstraintTolerance(node.getDoubleProperty("constraintTolerance"));
+    integrator->setMaximumPairDistance(node.getDoubleProperty("maximumPairDistance"));
+
+    return integrator;
+}

serialization/src/SerializationProxyRegistration.cpp

@@ -30,7 +30,6 @@
  * -------------------------------------------------------------------------- */
 
 #include "openmm/AndersenThermostat.h"
-#include "openmm/BAOABLangevinIntegrator.h"
 #include "openmm/BrownianIntegrator.h"
 #include "openmm/CMAPTorsionForce.h"
 #include "openmm/CMMotionRemover.h"
@@ -52,10 +51,12 @@
 #include "openmm/HarmonicAngleForce.h"
 #include "openmm/HarmonicBondForce.h"
 #include "openmm/LangevinIntegrator.h"
+#include "openmm/LangevinMiddleIntegrator.h"
 #include "openmm/MonteCarloAnisotropicBarostat.h"
 #include "openmm/MonteCarloBarostat.h"
 #include "openmm/MonteCarloMembraneBarostat.h"
 #include "openmm/NonbondedForce.h"
+#include "openmm/NoseHooverIntegrator.h"
 #include "openmm/PeriodicTorsionForce.h"
 #include "openmm/RBTorsionForce.h"
 #include "openmm/RMSDForce.h"
@@ -66,7 +67,6 @@
 #include "openmm/VerletIntegrator.h"
 
 #include "openmm/serialization/SerializationProxy.h"
-#include "openmm/serialization/BAOABLangevinIntegratorProxy.h"
 #include "openmm/serialization/BrownianIntegratorProxy.h"
 #include "openmm/serialization/AndersenThermostatProxy.h"
 #include "openmm/serialization/CMAPTorsionForceProxy.h"
@@ -89,10 +89,12 @@
 #include "openmm/serialization/HarmonicAngleForceProxy.h"
 #include "openmm/serialization/HarmonicBondForceProxy.h"
 #include "openmm/serialization/LangevinIntegratorProxy.h"
+#include "openmm/serialization/LangevinMiddleIntegratorProxy.h"
 #include "openmm/serialization/MonteCarloAnisotropicBarostatProxy.h"
 #include "openmm/serialization/MonteCarloBarostatProxy.h"
 #include "openmm/serialization/MonteCarloMembraneBarostatProxy.h"
 #include "openmm/serialization/NonbondedForceProxy.h"
+#include "openmm/serialization/NoseHooverIntegratorProxy.h"
 #include "openmm/serialization/PeriodicTorsionForceProxy.h"
 #include "openmm/serialization/RBTorsionForceProxy.h"
 #include "openmm/serialization/RMSDForceProxy.h"
@@ -119,7 +121,6 @@ using namespace OpenMM;
 
 extern "C" void registerSerializationProxies() {
     SerializationProxy::registerProxy(typeid(AndersenThermostat), new AndersenThermostatProxy());
-    SerializationProxy::registerProxy(typeid(BAOABLangevinIntegrator), new BAOABLangevinIntegratorProxy());
     SerializationProxy::registerProxy(typeid(BrownianIntegrator), new BrownianIntegratorProxy());
     SerializationProxy::registerProxy(typeid(CMAPTorsionForce), new CMAPTorsionForceProxy());
     SerializationProxy::registerProxy(typeid(CMMotionRemover), new CMMotionRemoverProxy());
@@ -147,10 +148,12 @@ extern "C" void registerSerializationProxies() {
     SerializationProxy::registerProxy(typeid(HarmonicAngleForce), new HarmonicAngleForceProxy());
     SerializationProxy::registerProxy(typeid(HarmonicBondForce), new HarmonicBondForceProxy());
     SerializationProxy::registerProxy(typeid(LangevinIntegrator), new LangevinIntegratorProxy());
+    SerializationProxy::registerProxy(typeid(LangevinMiddleIntegrator), new LangevinMiddleIntegratorProxy());
     SerializationProxy::registerProxy(typeid(MonteCarloAnisotropicBarostat), new MonteCarloAnisotropicBarostatProxy());
     SerializationProxy::registerProxy(typeid(MonteCarloBarostat), new MonteCarloBarostatProxy());
     SerializationProxy::registerProxy(typeid(MonteCarloMembraneBarostat), new MonteCarloMembraneBarostatProxy());
     SerializationProxy::registerProxy(typeid(NonbondedForce), new NonbondedForceProxy());
+    SerializationProxy::registerProxy(typeid(NoseHooverIntegrator), new NoseHooverIntegratorProxy());
     SerializationProxy::registerProxy(typeid(PeriodicTorsionForce), new PeriodicTorsionForceProxy());
     SerializationProxy::registerProxy(typeid(RBTorsionForce), new RBTorsionForceProxy());
     SerializationProxy::registerProxy(typeid(RMSDForce), new RMSDForceProxy());
@@ -159,4 +162,4 @@ extern "C" void registerSerializationProxies() {
     SerializationProxy::registerProxy(typeid(VariableLangevinIntegrator), new VariableLangevinIntegratorProxy());
     SerializationProxy::registerProxy(typeid(VariableVerletIntegrator), new VariableVerletIntegratorProxy());
     SerializationProxy::registerProxy(typeid(VerletIntegrator), new VerletIntegratorProxy());
-}
+}
\ No newline at end of file

serialization/tests/TestSerializeIntegrator.cpp

@@ -31,11 +31,11 @@
 
 #include "openmm/internal/AssertionUtilities.h"
 
-#include "openmm/BAOABLangevinIntegrator.h"
 #include "openmm/BrownianIntegrator.h"
 #include "openmm/CompoundIntegrator.h"
 #include "openmm/CustomIntegrator.h"
 #include "openmm/LangevinIntegrator.h"
+#include "openmm/LangevinMiddleIntegrator.h"
 #include "openmm/VariableLangevinIntegrator.h"
 #include "openmm/VariableVerletIntegrator.h"
 #include "openmm/VerletIntegrator.h"
@@ -75,11 +75,11 @@ void testSerializeLangevinIntegrator() {
     delete intg2;
 }
 
-void testSerializeBAOABLangevinIntegrator() {
-    BAOABLangevinIntegrator *intg = new BAOABLangevinIntegrator(372.4, 1.234, 0.0018);
+void testSerializeLangevinMiddleIntegrator() {
+    LangevinMiddleIntegrator *intg = new LangevinMiddleIntegrator(372.4, 1.234, 0.0018);
     stringstream ss;
-    XmlSerializer::serialize<Integrator>(intg, "BAOABLangevinIntegrator", ss);
-    BAOABLangevinIntegrator *intg2 = dynamic_cast<BAOABLangevinIntegrator*>(XmlSerializer::deserialize<Integrator>(ss));
+    XmlSerializer::serialize<Integrator>(intg, "LangevinMiddleIntegrator", ss);
+    LangevinMiddleIntegrator *intg2 = dynamic_cast<LangevinMiddleIntegrator*>(XmlSerializer::deserialize<Integrator>(ss));
     ASSERT_EQUAL(intg->getConstraintTolerance(), intg2->getConstraintTolerance());
     ASSERT_EQUAL(intg->getStepSize(), intg2->getStepSize());
     ASSERT_EQUAL(intg->getTemperature(), intg2->getTemperature());
@@ -259,7 +259,7 @@ int main() {
         testSerializeVariableLangevinIntegrator();
         testSerializeVariableVerletIntegrator();
         testSerializeLangevinIntegrator();
-        testSerializeBAOABLangevinIntegrator();
+        testSerializeLangevinMiddleIntegrator();
         testSerializeCompoundIntegrator();
     }
     catch(const exception& e) {

serialization/tests/TestSerializeNonbondedForce.cpp

@@ -6,7 +6,7 @@
  * Biological Structures at Stanford, funded under the NIH Roadmap for        *
  * Medical Research, grant U54 GM072970. See https://simtk.org.               *
  *                                                                            *
- * Portions copyright (c) 2010-2018 Stanford University and the Authors.      *
+ * Portions copyright (c) 2010-2020 Stanford University and the Authors.      *
  * Authors: Peter Eastman                                                     *
  * Contributors:                                                              *
  *                                                                            *
@@ -50,6 +50,7 @@ void testSerialization() {
     force.setEwaldErrorTolerance(1e-3);
     force.setReactionFieldDielectric(50.0);
     force.setUseDispersionCorrection(false);
+    force.setExceptionsUsePeriodicBoundaryConditions(true);
     double alpha = 0.5;
     int nx = 3, ny = 5, nz = 7;
     force.setPMEParameters(alpha, nx, ny, nz);
@@ -83,6 +84,7 @@ void testSerialization() {
     ASSERT_EQUAL(force.getEwaldErrorTolerance(), force2.getEwaldErrorTolerance());
     ASSERT_EQUAL(force.getReactionFieldDielectric(), force2.getReactionFieldDielectric());
     ASSERT_EQUAL(force.getUseDispersionCorrection(), force2.getUseDispersionCorrection());
+    ASSERT_EQUAL(force.getExceptionsUsePeriodicBoundaryConditions(), force2.getExceptionsUsePeriodicBoundaryConditions());
     ASSERT_EQUAL(force.getNumParticles(), force2.getNumParticles());
     ASSERT_EQUAL(force.getNumExceptions(), force2.getNumExceptions());
     ASSERT_EQUAL(force.getNumGlobalParameters(), force2.getNumGlobalParameters());

serialization/tests/TestSerializeNoseHooverIntegrator.cpp

+/* -------------------------------------------------------------------------- *
+ *                                   OpenMM                                   *
+ * -------------------------------------------------------------------------- *
+ * This is part of the OpenMM molecular simulation toolkit originating from   *
+ * Simbios, the NIH National Center for Physics-Based Simulation of           *
+ * Biological Structures at Stanford, funded under the NIH Roadmap for        *
+ * Medical Research, grant U54 GM072970. See https://simtk.org.               *
+ *                                                                            *
+ * Portions copyright (c) 2010-2014 Stanford University and the Authors.      *
+ * Authors: Andrew C. Simmonett and Andreas Kraemer
+ * Contributors:                                                              *
+ *                                                                            *
+ * Permission is hereby granted, free of charge, to any person obtaining a    *
+ * copy of this software and associated documentation files (the "Software"), *
+ * to deal in the Software without restriction, including without limitation  *
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
+ * and/or sell copies of the Software, and to permit persons to whom the      *
+ * Software is furnished to do so, subject to the following conditions:       *
+ *                                                                            *
+ * The above copyright notice and this permission notice shall be included in *
+ * all copies or substantial portions of the Software.                        *
+ *                                                                            *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
+ * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
+ * -------------------------------------------------------------------------- */
+
+#include "openmm/internal/AssertionUtilities.h"
+#include "openmm/NoseHooverIntegrator.h"
+#include "openmm/serialization/XmlSerializer.h"
+#include "openmm/System.h"
+#include "openmm/Context.h"
+#include <iostream>
+#include <sstream>
+
+using namespace OpenMM;
+using namespace std;
+
+void assertIntegratorsEqual(const NoseHooverIntegrator& integrator1, const NoseHooverIntegrator& integrator2){
+    ASSERT_EQUAL(integrator1.getStepSize(), integrator2.getStepSize());
+    ASSERT_EQUAL(integrator1.getConstraintTolerance(), integrator2.getConstraintTolerance());
+    ASSERT_EQUAL(integrator1.getMaximumPairDistance(), integrator2.getMaximumPairDistance());
+    ASSERT_EQUAL(integrator1.getNumThermostats(), integrator2.getNumThermostats());
+    for (int i = 0; i < integrator1.getNumThermostats(); i++) {
+        const auto &thermostat1 = integrator1.getThermostat(i);
+        const auto &thermostat2 = integrator2.getThermostat(i);
+        ASSERT_EQUAL(thermostat1.getTemperature(), thermostat2.getTemperature());
+        ASSERT_EQUAL(thermostat1.getCollisionFrequency(), thermostat2.getCollisionFrequency());
+        ASSERT_EQUAL(thermostat1.getRelativeTemperature(), thermostat2.getRelativeTemperature());
+        ASSERT_EQUAL(thermostat1.getRelativeCollisionFrequency(), thermostat2.getRelativeCollisionFrequency());
+        ASSERT_EQUAL(thermostat1.getChainLength(), thermostat2.getChainLength());
+        ASSERT_EQUAL(thermostat1.getNumMultiTimeSteps(), thermostat2.getNumMultiTimeSteps());
+        ASSERT_EQUAL(thermostat1.getNumYoshidaSuzukiTimeSteps(), thermostat2.getNumYoshidaSuzukiTimeSteps());
+        ASSERT_EQUAL(thermostat1.getChainID(), thermostat2.getChainID());
+        const auto &thermostat1Atoms = thermostat1.getThermostatedAtoms();
+        const auto &thermostat2Atoms = thermostat2.getThermostatedAtoms();
+        ASSERT_EQUAL(thermostat1Atoms.size(), thermostat2Atoms.size());
+        for (int j = 0; j < thermostat1Atoms.size(); ++j) {
+            ASSERT_EQUAL(thermostat1Atoms[j], thermostat2Atoms[j]);
+        }
+        const auto &thermostat1Pairs = thermostat1.getThermostatedPairs();
+        const auto &thermostat2Pairs = thermostat2.getThermostatedPairs();
+        ASSERT_EQUAL(thermostat1Pairs.size(), thermostat2Pairs.size());
+        for (int j = 0; j < thermostat1Pairs.size(); ++j) {
+            ASSERT_EQUAL(thermostat1Pairs[j].first, thermostat2Pairs[j].first);
+            ASSERT_EQUAL(thermostat1Pairs[j].second, thermostat2Pairs[j].second);
+        }
+    }
+}
+
+void testSerialization() {
+
+    // Check with custom subsystem thermostats
+
+    NoseHooverIntegrator integrator_sub (0.0006);
+    integrator_sub.setConstraintTolerance(0.0404);
+    integrator_sub.setMaximumPairDistance(0.0051);
+    integrator_sub.addSubsystemThermostat(
+        {0,1,2,3,4,7}, {{0,7}}, 301.1, 1.1, 1.2, 1.3, 9, 2, 5
+    );
+
+    // Serialize and then deserialize it.
+
+    stringstream buffer;
+    XmlSerializer::serialize<NoseHooverIntegrator>(&integrator_sub, "Integrator", buffer);
+    NoseHooverIntegrator* copy = XmlSerializer::deserialize<NoseHooverIntegrator>(buffer);
+    assertIntegratorsEqual(integrator_sub, *copy);
+
+    // Check with default constructor
+
+    System system;
+    for (int i=0; i<10; i++) system.addParticle(1.0);
+    NoseHooverIntegrator integrator(331, 1.1, 0.004, 5, 5, 5);
+    Context context(system, integrator);
+
+    // Serialize and then deserialize it.
+    stringstream buffer2;
+    XmlSerializer::serialize<NoseHooverIntegrator>(&integrator, "Integrator", buffer2);
+    copy = XmlSerializer::deserialize<NoseHooverIntegrator>(buffer2);
+    // for thermostats that apply to the whole system, the particles are not serialized ...
+    ASSERT_EQUAL(copy->getThermostat(0).getThermostatedAtoms().size(), 0);
+
+    // ... but assigned when creating a context.
+    Context context2(system, *copy);
+    assertIntegratorsEqual(integrator, *copy);
+
+}
+
+int main() {
+    try {
+        testSerialization();
+    }
+    catch(const exception& e) {
+        cout << "exception: " << e.what() << endl;
+        return 1;
+    }
+    cout << "Done" << endl;
+    return 0;
+}
+