Hack particular gccxml location for one particular nightly build machine.

Incorporate Normal Mode Langevin openmm code from Chris Sweet as a plugin.  (compiles on windows, but no actual testing done)

CMakeLists.txt

@@ -268,6 +268,10 @@ set(cmv "${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}")
 # Java and gccxml are required for API wrappers
 FIND_PACKAGE(Java)
 MARK_AS_ADVANCED(CLEAR JAVA_RUNTIME)
+# One particular location to try first for nightly builds
+FIND_PROGRAM(GCCXML_PATH gccxml PATH
+    "C:/Program Files/gccxml_sherm/bin")
+# In case first attempt fails
 FIND_PROGRAM(GCCXML_PATH gccxml PATH
     /usr/local/bin
     "C:/Program Files/gccxml 0.9/bin"
@@ -356,6 +360,12 @@ IF(OPENMM_BUILD_FREE_ENERGY_PLUGIN)
    ADD_SUBDIRECTORY(plugins/freeEnergy)
 ENDIF(OPENMM_BUILD_FREE_ENERGY_PLUGIN)
 
+# Normal mode langevin plugin
+set(OPENMM_BUILD_NML_PLUGIN ON CACHE BOOL "Build normal-mode langevin plugin")
+if(OPENMM_BUILD_NML_PLUGIN)
+    add_subdirectory(plugins/normalModeLangevin)
+endif(OPENMM_BUILD_NML_PLUGIN)
+
 INSTALL_TARGETS(/lib RUNTIME_DIRECTORY /lib ${SHARED_TARGET})
 INSTALL_TARGETS(/lib RUNTIME_DIRECTORY /lib ${STATIC_TARGET})
 FILE(GLOB CORE_HEADERS     include/*.h          */include/*.h)

platforms/reference/src/SimTKReference/ReferenceCCMAAlgorithm.h

@@ -32,7 +32,7 @@
 
 // ---------------------------------------------------------------------------------------
 
-class ReferenceCCMAAlgorithm : public ReferenceConstraintAlgorithm {
+class OPENMM_EXPORT ReferenceCCMAAlgorithm : public ReferenceConstraintAlgorithm {
 
    protected:
 

platforms/reference/src/SimTKReference/ReferenceDynamics.h

@@ -41,7 +41,7 @@ Main method (virtual) is update()
 
 --------------------------------------------------------------------------------------- */
 
-class ReferenceDynamics {
+class OPENMM_EXPORT ReferenceDynamics {
 
    public:
 

platforms/reference/src/SimTKUtilities/SimTKOpenMMLog.h

@@ -28,6 +28,7 @@
 #include <stdio.h>
 #include <sstream>
 #include "SimTKOpenMMCommon.h"
+#include "openmm/internal/windowsExport.h"
 
 /** ---------------------------------------------------------------------------------------
 
@@ -35,7 +36,7 @@
 
    --------------------------------------------------------------------------------------- */
 
-class SimTKOpenMMLog {
+class OPENMM_EXPORT SimTKOpenMMLog {
 
    public:
 

plugins/normalModeLangevin/CMakeLists.txt

+#/* -------------------------------------------------------------------------- *
+# *                                   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) 2009 Stanford University and the Authors.           *
+# * Authors: Chris Sweet, Christopher Bruns                                    *
+# * 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.                                     *
+# * -------------------------------------------------------------------------- */
+
+# Create Normal Mode Langevin (NML) plugin for OpenMM
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
+file(GLOB nml_headers "include/*.h")
+file(GLOB nml_sources "src/*.cpp")
+
+# Reference platform implementation
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/platforms/reference/include)
+include_directories(${CMAKE_SOURCE_DIR}/platforms/reference/src)
+file(GLOB headers "${CMAKE_CURRENT_SOURCE_DIR}/platforms/reference/include/*.h")
+file(GLOB sources "${CMAKE_CURRENT_SOURCE_DIR}/platforms/reference/src/*.cpp")
+set(nml_headers ${nml_headers} ${headers})
+set(nml_sources ${nml_sources} ${sources})
+
+add_library(NormalModeLangevin SHARED ${nml_sources} ${nml_headers})
+set_target_properties(NormalModeLangevin PROPERTIES COMPILE_FLAGS "-DOPENMM_BUILDING_SHARED_LIBRARY")
+# On Unix or Cygwin we have to add the debug suffix manually
+if(UNIX)
+    set_target_properties(NormalModeLangevin PROPERTIES DEBUG_OUTPUT_NAME NormalModeLangevin_d)
+endif(UNIX)
+target_link_libraries( NormalModeLangevin OpenMM )
+
+if(BUILD_TESTING)
+    add_subdirectory(test)
+endif(BUILD_TESTING)
+
+install(TARGETS NormalModeLangevin RUNTIME DESTINATION lib/plugins)
+

plugins/normalModeLangevin/include/EigenvectorInfo.h

+/*  -*- c++ -*-  */
+#ifndef EIGENVECTORINFO_H
+#define EIGENVECTORINFO_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) 2009 Stanford University and the Authors.           *
+ * Authors: Chris Sweet                                                       *
+ * Contributors: Christopher Bruns                                            *
+ *                                                                            *
+ * 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 <string>
+#include <iostream>
+#include <vector>
+
+using std::cout;
+using std::endl;
+namespace ProtoMol
+{
+  //_________________________________________________________________XYZ
+  /**
+   * Container holding coordinates/Vector3D and names
+   */
+  struct EigenvectorInfo {
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // Constructors, destructors, assignment
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    EigenvectorInfo() : myEigenvectorLength ( 0 ), myNumEigenvectors ( 0 ), myNumUsedEigenvectors( 0 ),
+        myEigenvectors ( 0 ), myOrigCEigval( 0.0 ), myNewCEigval( 0.0 ), myOrigTimestep( 0.0 ), 
+        reDiagonalize( false ),
+        mySingleEigs( 0 ), myEigVecChanged( true ), myMinimumLimit( 0.5 ), currentMode( -1 ) {};
+
+    EigenvectorInfo( unsigned int n, unsigned int m ) : myEigenvectorLength( n ), myNumEigenvectors( m ), myNumUsedEigenvectors( m ),
+        myMaxEigenvalue( 0.0 ), myEigenvectors ( new double[n * m * 3] ), 
+        myOrigCEigval( 0.0 ), myNewCEigval( 0.0 ), myOrigTimestep( 0.0 ), reDiagonalize( false ),
+        mySingleEigs( 0 ),
+        myEigVecChanged( true ), myMinimumLimit( 0.5 ), currentMode( -1 ) {}
+
+    ~EigenvectorInfo() {
+      if ( myEigenvectors ) {
+        delete [] myEigenvectors;
+        myEigenvectors = 0;
+      }
+      if ( mySingleEigs ) {
+        delete [] mySingleEigs;
+        mySingleEigs = 0;
+      }
+    };
+
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // New methods of class EigenvectorInfo
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    bool initializeEigenvectors() {
+      try {
+
+        myEigenvectors = new double[myEigenvectorLength * myNumEigenvectors * 3];
+
+      } catch ( std::bad_alloc& ) {
+
+        return false;
+
+      }
+
+      return true;
+
+    }
+
+    float* getFloatEigPointer() {
+
+      //no eigenvectors assigned?
+      if(!myEigenvectors) return (float*)0;
+
+      const unsigned int arrayLen = myEigenvectorLength * myNumEigenvectors * 3;
+
+      //assign storage if required
+      if(!mySingleEigs) {  
+
+        try {
+          mySingleEigs = new float[arrayLen];
+        } catch ( std::bad_alloc& ) {
+          return (float*)0;
+        }
+
+      }
+
+      //update values if double array updated
+      if(myEigVecChanged) {
+
+        for( unsigned int i=0; i<arrayLen; i++)
+          mySingleEigs[i] = (float)myEigenvectors[i];
+
+        myEigVecChanged = false;
+
+      }
+
+      return mySingleEigs;
+
+    }
+
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // My data members
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // Eigenvector information
+    unsigned int myEigenvectorLength;
+    unsigned int myNumEigenvectors;
+    unsigned int myNumUsedEigenvectors;
+    double myMaxEigenvalue;
+    double *myEigenvectors;
+    
+    //Current and original max subspace eigenvalue, 
+    //for adaptive timestep
+    double myOrigCEigval, myNewCEigval;
+    double myOrigTimestep;
+
+    //re-diagonalization flag
+    bool reDiagonalize;
+    
+    //OpenMM single precision interface
+    float *mySingleEigs;
+    bool myEigVecChanged;
+
+    double myMinimumLimit;
+
+    //Analytic integrator
+    std::vector< double > myEigenvalues;
+    int currentMode;
+
+
+  };
+}
+#endif /* EIGENVECTORINFO_H */

plugins/normalModeLangevin/include/IntegrateNMLStepKernel.h

+#ifndef INTEGRATE_NML_STEP_KERNEL_H
+#define INTEGRATE_NML_STEP_KERNEL_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) 2009 Stanford University and the Authors.           *
+ * Authors: Chris Sweet                                                       *
+ * Contributors: Christopher Bruns                                            *
+ *                                                                            *
+ * 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/KernelImpl.h"
+#include "openmm/System.h"
+#include "NMLIntegrator.h"
+
+namespace OpenMM {
+
+/**
+ * This kernel is invoked by NMLIntegrator to take one time step.
+ */
+class IntegrateNMLStepKernel : public KernelImpl {
+    public:
+        static std::string Name() {
+            return "IntegrateNMLStep";
+        }
+        IntegrateNMLStepKernel(std::string name, const Platform& platform) : KernelImpl(name, platform) {
+        }
+        /**
+         * Initialize the kernel.
+         *
+         * @param system     the System this kernel will be applied to
+         * @param integrator the NMLIntegrator this kernel will be used for
+         */
+        virtual void initialize(const System& system, const NMLIntegrator& integrator) = 0;
+        /**
+         * Execute the kernel.
+         *
+         * @param context    the context in which to execute this kernel
+         * @param integrator the NMLIntegrator this kernel is being used for
+         */
+        virtual void execute(ContextImpl& context, const NMLIntegrator& integrator, const double currentPE, const int stepType) = 0;
+};
+
+} /* namespace OpenMM */
+
+#endif /* INTEGRATE_NML_STEP_KERNEL_H */
+

plugins/normalModeLangevin/include/NMLIntegrator.h

+#ifndef OPENMM_NMLIntegrator_H_
+#define OPENMM_NMLIntegrator_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) 2009 Stanford University and the Authors.           *
+ * Authors: Chris Sweet                                                       *
+ * Contributors: Christopher Bruns                                            *
+ *                                                                            *
+ * 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/Integrator.h"
+#include "openmm/Kernel.h"
+#include "openmm/internal/windowsExport.h"
+#include "EigenvectorInfo.h"
+
+namespace OpenMM {
+
+/**
+ * This is an Integrator which simulates a System using Langevin dynamics.
+ */
+
+class OPENMM_EXPORT NMLIntegrator : public Integrator {
+public:
+    /**
+     * Create a NMLIntegrator.
+     *
+     * @param temperature    the temperature of the heat bath (in Kelvin)
+     * @param frictionCoeff  the friction coefficient which couples the system to the heat bath
+     * @param stepSize       the step size with which to integrator the system (in picoseconds)
+     */
+    NMLIntegrator(double temperature, double frictionCoeff, double stepSize, ProtoMol::EigenvectorInfo* projectionVectorInfo );
+    /**
+     * Get the temperature of the heat bath (in Kelvin).
+     */
+    double getTemperature() const {
+        return temperature;
+    }
+    /**
+     * Set the temperature of the heat bath (in Kelvin).
+     */
+    void setTemperature(double temp) {
+        temperature = temp;
+    }
+    /**
+     * Get the friction coefficient which determines how strongly the system is coupled to
+     * the heat bath.
+     */
+    double getFriction() const {
+        return friction;
+    }
+    /**
+     * Set the friction coefficient which determines how strongly the system is coupled to
+     * the heat bath.
+     */
+    void setFriction(double coeff) {
+        friction = coeff;
+    }
+
+
+	  void setProjectionVectorInfo( ProtoMol::EigenvectorInfo* inVectorInfo ){
+		  mProjectionVectorInfo = inVectorInfo;
+	  }
+
+	  ProtoMol::EigenvectorInfo* getProjectionVectorInfo() const{
+		  return mProjectionVectorInfo;
+	  }
+
+    unsigned int getNumProjectionVectors() const{
+      //return mProjectionVectorInfo->myNumEigenvectors;
+      return mProjectionVectorInfo->myNumUsedEigenvectors;
+    }
+
+    double getMinimumLimit() const{
+      return mProjectionVectorInfo->myMinimumLimit *  4.184; //Kcal->KJ
+    }
+
+    bool getProjVecChanged() const{      
+      return mProjectionVectorInfo->myEigVecChanged;
+    }
+
+    double* getProjectionVectors() const{      
+      return mProjectionVectorInfo->myEigenvectors;
+    }
+
+    void setProjVecChanged(bool inChanged){		  
+      mProjectionVectorInfo->myEigVecChanged = inChanged;
+    }
+
+    double getMaxEigenvalue() const{
+        //return max eigenvalue (f^2) in 1/ps from 1/charmm
+      return mProjectionVectorInfo->myMaxEigenvalue * 
+        (1000.0 / 48.88821290839616) * (1000.0 / 48.88821290839616) //(1/charmm to 1/ps)^2
+        * 100.0; //(Angstron to nm [inverse])^2
+    }
+
+    /**
+     * Advance a simulation through time by taking a series of time steps.
+     *
+     * @param steps   the number of time steps to take
+     */
+    void step(int steps);
+    
+    //Minimizer
+    void minimize(int maxsteps);
+    
+protected:
+    /**
+     * This will be called by the OpenMMContext when it is created.  It informs the Integrator
+     * of what context it will be integrating, and gives it a chance to do any necessary initialization.
+     * It will also get called again if the application calls reinitialize() on the OpenMMContext.
+     */
+    void initialize(ContextImpl& context);
+    /**
+     * Get the names of all Kernels used by this Integrator.
+     */
+    std::vector<std::string> getKernelNames();
+private:
+	  ProtoMol::EigenvectorInfo* mProjectionVectorInfo;
+
+    double temperature, friction;
+    ContextImpl* context;
+    Kernel kernel;
+};
+
+} // namespace OpenMM
+
+#endif /*OPENMM_NMLIntegrator_H_*/

plugins/normalModeLangevin/include/NMLKernels.h

+#ifndef NML_KERNELS_H
+#define NML_KERNELS_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) 2009 Stanford University and the Authors.           *
+ * Authors: Christopher Bruns                                                 *
+ * 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 "IntegrateNMLStepKernel.h"
+
+#endif /* NML_KERNELS_H */
+

plugins/normalModeLangevin/include/NormalModeLangevin.h

+#ifndef OPENMM_NORMAL_MODE_LANGEVIN_H_
+#define OPENMM_NORMAL_MODE_LANGEVIN_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) 2009 Stanford University and the Authors.           *
+ * Authors: Christopher Bruns                                                 *
+ * Contributors:                                                              *
+ *                                                                            *
+ * This program is free software: you can redistribute it and/or modify       *
+ * it under the terms of the GNU Lesser General Public License as published   *
+ * by the Free Software Foundation, either version 3 of the License, or       *
+ * (at your option) any later version.                                        *
+ *                                                                            *
+ * This program is distributed in the hope that it will be useful,            *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
+ * GNU Lesser General Public License for more details.                        *
+ *                                                                            *
+ * You should have received a copy of the GNU Lesser General Public License   *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *
+ * -------------------------------------------------------------------------- */
+
+
+namespace OpenMM {
+} // namespace OpenMM
+
+#endif /*OPENMM_NORMAL_MODE_LANGEVIN_H_*/
+

plugins/normalModeLangevin/platforms/reference/CMakeLists.txt

+#/* -------------------------------------------------------------------------- *
+# *                                   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) 2009 Stanford University and the Authors.           *
+# * Authors: Chris Sweet, Christopher Bruns                                    *
+# * 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.                                     *
+# * -------------------------------------------------------------------------- */
+

plugins/normalModeLangevin/platforms/reference/include/ReferenceIntegrateNMLStepKernel.h

+#ifndef REFERENCE_INTEGRATE_NML_STEP_KERNEL_H
+#define REFERENCE_INTEGRATE_NML_STEP_KERNEL_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) 2009 Stanford University and the Authors.           *
+ * Authors: Chris Sweet                                                       *
+ * Contributors: Christopher Bruns                                            *
+ *                                                                            *
+ * 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 "ReferencePlatform.h"
+#include "ReferenceNMLDynamics.h"
+#include "IntegrateNMLStepKernel.h"
+
+namespace OpenMM {
+
+/**
+ * This kernel is invoked by NMLIntegrator to take one time step.
+ */
+class ReferenceIntegrateNMLStepKernel : public IntegrateNMLStepKernel {
+    public:
+        ReferenceIntegrateNMLStepKernel(std::string name, const Platform& platform, ReferencePlatform::PlatformData& data) : IntegrateNMLStepKernel(name, platform),
+        data(data), dynamics(0), constraints(0), masses(0), constraintDistances(0), constraintIndices(0), projectionVectors(0) {
+        }
+        ~ReferenceIntegrateNMLStepKernel();
+        /**
+         * Initialize the kernel, setting up the particle masses.
+         *
+         * @param system     the System this kernel will be applied to
+         * @param integrator the NMLIntegrator this kernel will be used for
+         */
+        void initialize(const System& system, const NMLIntegrator& integrator);
+        /**
+         * Execute the kernel.
+         *
+         * @param context    the context in which to execute this kernel
+         * @param integrator the NMLIntegrator this kernel is being used for
+         */
+        void execute(ContextImpl& context, const NMLIntegrator& integrator, const double currentPE, const int stepType);
+    private:
+        ReferencePlatform::PlatformData& data;
+        ReferenceNMLDynamics* dynamics;
+        ReferenceConstraintAlgorithm* constraints;
+        RealOpenMM* masses;
+        RealOpenMM* constraintDistances;
+        int** constraintIndices;
+        int numConstraints;
+        double prevTemp, prevFriction, prevStepSize;
+        //double prevTemp, prevFriction, prevErrorTol;
+        RealOpenMM* projectionVectors;
+
+};
+
+} /* namespace OpenMM */
+
+#endif /* REFERENCE_INTEGRATE_NML_STEP_KERNEL_H */
+

plugins/normalModeLangevin/platforms/reference/include/ReferenceNMLDynamics.h

+#ifndef __ReferenceNMLDynamics_H__
+#define __ReferenceNMLDynamics_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) 2009 Stanford University and the Authors.           *
+ * Authors: Chris Sweet                                                       *
+ * Contributors: Christopher Bruns, Pande Group                               *
+ *                                                                            *
+ * 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 "SimTKUtilities/SimTKOpenMMRealType.h"
+#include "SimTKReference/ReferenceDynamics.h"
+
+// ---------------------------------------------------------------------------------------
+
+class ReferenceNMLDynamics : public ReferenceDynamics {
+
+   private:
+
+      //dt, myGamma, fdt, vdt, ndt, sqrtFCoverM from Langevin Leapfrog
+      //enum FixedParameters   { GDT, EPH, EMH, EP, EM, B, C, D, V, X, Yv, Yx, MaxFixedParameters };
+      enum FixedParameters   { DT, GAMMA, FDT, VDT, NDT, SQRTFCOVERM, MaxFixedParameters };
+      enum TwoDArrayIndicies { X2D, V2D, OldV, xPrime2D, vPrime2D, Max2DArrays };
+      enum OneDArrayIndicies { InverseMasses, Max1DArrays };
+
+      RealOpenMM _tau;
+      RealOpenMM _fixedParameters[MaxFixedParameters];
+      RealOpenMM* _projectionVectors;
+      unsigned int _numProjectionVectors;
+      RealOpenMM _minimumLimit, _maxEig;
+      RealOpenMM lastPE, lastSlope;
+
+      /**---------------------------------------------------------------------------------------
+      
+         Set fixed values
+      
+         @return ReferenceDynamics::DefaultReturn
+      
+         --------------------------------------------------------------------------------------- */
+      
+      int _setFixedParameters( void );
+      
+   public:
+
+      /**---------------------------------------------------------------------------------------
+      
+         Constructor
+
+         @param numberOfAtoms  number of atoms
+         @param deltaT         delta t for dynamics
+         @param tau            viscosity
+         @param temperature    temperature
+      
+         --------------------------------------------------------------------------------------- */
+
+       ReferenceNMLDynamics( int numberOfAtoms, RealOpenMM deltaT, RealOpenMM tau, RealOpenMM temperature,
+                   RealOpenMM* projectionVectors, unsigned int numProjectionVectors, 
+                   RealOpenMM minimumLimit, RealOpenMM maxEig
+                    );
+
+      /**---------------------------------------------------------------------------------------
+      
+         Destructor
+      
+         --------------------------------------------------------------------------------------- */
+
+       ~ReferenceNMLDynamics( );
+
+      /**---------------------------------------------------------------------------------------
+      
+         Get tau
+      
+         @return tau
+      
+         --------------------------------------------------------------------------------------- */
+      
+      RealOpenMM getTau( void ) const;
+      
+      /**---------------------------------------------------------------------------------------
+      
+         Get array of fixed parameters indexed by 'FixedParameters' enums
+      
+         @return array
+      
+         --------------------------------------------------------------------------------------- */
+      
+      const RealOpenMM* getFixedParameters( void ) const;
+      
+      /**---------------------------------------------------------------------------------------
+      
+         Print parameters
+      
+         @param message message
+
+         @return ReferenceDynamics::DefaultReturn
+      
+         --------------------------------------------------------------------------------------- */
+      
+      int printParameters( std::stringstream& message ) const;
+      
+      /**---------------------------------------------------------------------------------------
+      
+         Update
+      
+         @param numberOfAtoms       number of atoms
+         @param atomCoordinates     atom coordinates
+         @param velocities          velocities
+         @param forces              forces
+         @param masses              atom masses
+      
+         @return ReferenceDynamics::DefaultReturn
+      
+         --------------------------------------------------------------------------------------- */
+     
+      int update( int numberOfAtoms, RealOpenMM** atomCoordinates,
+                  RealOpenMM** velocities, RealOpenMM** forces, RealOpenMM* masses, const RealOpenMM currentPE, const int stepType );
+     
+    /**---------------------------------------------------------------------------------------
+     
+     Velocity update; Langevin Leapfrog
+     
+     @param numberOfAtoms       number of atoms
+     @param atomCoordinates     atom coordinates
+     @param velocities          velocities
+     @param forces              forces
+     @param masses              atom masses
+     @param inverseMasses       inverse atom masses
+     @param xVector             xVector
+     
+     --------------------------------------------------------------------------------------- */
+    void halfKick( int numberOfAtoms, RealOpenMM** atomCoordinates, RealOpenMM** velocities,
+                    RealOpenMM** forces, RealOpenMM* masses, RealOpenMM* inverseMasses, RealOpenMM** xVector );
+    
+    /**---------------------------------------------------------------------------------------
+     
+     Position update; Langevin Leapfrog
+     
+     @param numberOfAtoms       number of atoms
+     @param atomCoordinates     atom coordinates
+     @param velocities          velocities
+     @param forces              forces
+     @param masses              atom masses
+     @param inverseMasses       inverse atom masses
+     @param xPrime              xPrime
+     
+     --------------------------------------------------------------------------------------- */
+    void drift( int numberOfAtoms, RealOpenMM** atomCoordinates, RealOpenMM** velocities,
+                  RealOpenMM** forces, RealOpenMM* masses, RealOpenMM* inverseMasses,
+                  RealOpenMM** xPrime );
+          
+      /**---------------------------------------------------------------------------------------
+      
+         Write state
+      
+         @param numberOfAtoms       number of atoms
+         @param atomCoordinates     atom coordinates
+         @param velocities          velocities
+         @param forces              forces
+         @param masses              atom masses
+         @param state               0 if initial state; otherwise nonzero
+         @param baseFileName        base file name
+      
+         @return ReferenceDynamics::DefaultReturn
+      
+         --------------------------------------------------------------------------------------- */
+      
+      int writeState( int numberOfAtoms, RealOpenMM** atomCoordinates,
+                      RealOpenMM** velocities, RealOpenMM** forces, RealOpenMM* masses,
+                      int state, const std::string& baseFileName ) const;
+
+      /**---------------------------------------------------------------------------------------
+       Find forces OR positions inside subspace (defined as the span of the 'eigenvectors' Q)
+       Take 'array' as input, 'outArray' as output (may be the same vector).
+       'projectionMode' determines:
+       a) if the projection is for force or positions, bit 1 set=force.
+       b) if the projection is for the sub-space or-complement space, bit 2 set=sub-space.
+       ----------------------------------------------------------------------------------------- */
+      void subspaceProjection(  RealOpenMM** arrayParam, 
+                                RealOpenMM** outArrayParam, 
+                                int numberOfAtoms,
+                                RealOpenMM* masses,
+                                RealOpenMM* inverseMasses,
+                                int projectionMode);
+  
+};
+
+// ---------------------------------------------------------------------------------------
+
+#endif // __ReferenceNMLDynamics_H__

plugins/normalModeLangevin/platforms/reference/include/ReferenceNMLKernelFactory.h

+#ifndef OPENMM_REFERENCE_NMLKERNELFACTORY_H_
+#define OPENMM_REFERENCE_NMLKERNELFACTORY_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) 2009 Stanford University and the Authors.           *
+ * Authors: Chris Sweet                                                       *
+ * Contributors: Christopher Bruns                                            *
+ *                                                                            *
+ * 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/KernelFactory.h"
+
+namespace OpenMM {
+
+/**
+ * This KernelFactory creates all kernels for NormalModeLangevin.
+ */
+
+class ReferenceNMLKernelFactory : public KernelFactory {
+public:
+    KernelImpl* createKernelImpl(std::string name, const Platform& platform, ContextImpl& context) const;
+};
+
+} // namespace OpenMM
+
+#endif /*OPENMM_REFERENCE_NMLKERNELFACTORY_H_*/
+

plugins/normalModeLangevin/platforms/reference/src/ReferenceIntegrateNMLStepKernel.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) 2009 Stanford University and the Authors.           *
+ * Authors: Chris Sweet                                                       *
+ * Contributors: Christopher Bruns                                            *
+ *                                                                            *
+ * 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 "ReferenceIntegrateNMLStepKernel.h"
+#include "openmm/HarmonicAngleForce.h"
+#include "openmm/internal/ContextImpl.h"
+#include "SimTKReference/ReferenceCCMAAlgorithm.h"
+#include <vector>
+
+using namespace std;
+
+namespace OpenMM {
+
+// These methods lifted from ReferenceKernels.cpp, so NormalModeLangevin could be a plugin
+//   allocateIntArray
+//   disposeIntArray
+//   extractPositions
+//   extractVelocities
+//   extractForces
+//   findAnglesForCCMA
+
+static int** allocateIntArray(int length, int width) {
+    int** array = new int*[length];
+    for (int i = 0; i < length; ++i)
+        array[i] = new int[width];
+    return array;
+}
+
+static void disposeIntArray(int** array, int size) {
+    if (array) {
+        for (int i = 0; i < size; ++i)
+            delete[] array[i];
+        delete[] array;
+    }
+}
+
+static RealOpenMM** extractPositions(ContextImpl& context) {
+    ReferencePlatform::PlatformData* data = reinterpret_cast<ReferencePlatform::PlatformData*>(context.getPlatformData());
+    return (RealOpenMM**) data->positions;
+}
+
+static RealOpenMM** extractVelocities(ContextImpl& context) {
+    ReferencePlatform::PlatformData* data = reinterpret_cast<ReferencePlatform::PlatformData*>(context.getPlatformData());
+    return (RealOpenMM**) data->velocities;
+}
+
+static RealOpenMM** extractForces(ContextImpl& context) {
+    ReferencePlatform::PlatformData* data = reinterpret_cast<ReferencePlatform::PlatformData*>(context.getPlatformData());
+    return (RealOpenMM**) data->forces;
+}
+
+static void findAnglesForCCMA(const System& system, vector<ReferenceCCMAAlgorithm::AngleInfo>& angles) {
+    for (int i = 0; i < system.getNumForces(); i++) {
+        const HarmonicAngleForce* force = dynamic_cast<const HarmonicAngleForce*>(&system.getForce(i));
+        if (force != NULL) {
+            for (int j = 0; j < force->getNumAngles(); j++) {
+                int atom1, atom2, atom3;
+                double angle, k;
+                force->getAngleParameters(j, atom1, atom2, atom3, angle, k);
+                angles.push_back(ReferenceCCMAAlgorithm::AngleInfo(atom1, atom2, atom3, (RealOpenMM)angle));
+            }
+        }
+    }
+}
+
+
+ReferenceIntegrateNMLStepKernel::~ReferenceIntegrateNMLStepKernel() {
+    if (dynamics)
+        delete dynamics;
+    if (constraints)
+        delete constraints;
+    if (masses)
+        delete[] masses;
+    if (constraintIndices)
+        disposeIntArray(constraintIndices, numConstraints);
+    if (constraintDistances)
+        delete[] constraintDistances;
+    if (projectionVectors)
+        delete projectionVectors;
+}
+
+void ReferenceIntegrateNMLStepKernel::initialize(const System& system, const NMLIntegrator& integrator) {
+    int numParticles = system.getNumParticles();
+    masses = new RealOpenMM[numParticles];
+    for (int i = 0; i < numParticles; ++i)
+        masses[i] = static_cast<RealOpenMM>(system.getParticleMass(i));
+    numConstraints = system.getNumConstraints();
+    constraintIndices = allocateIntArray(numConstraints, 2);
+    constraintDistances = new RealOpenMM[numConstraints];
+    for (int i = 0; i < numConstraints; ++i) {
+        int particle1, particle2;
+        double distance;
+        system.getConstraintParameters(i, particle1, particle2, distance);
+        constraintIndices[i][0] = particle1;
+        constraintIndices[i][1] = particle2;
+        constraintDistances[i] = static_cast<RealOpenMM>(distance);
+    }
+    //SimTKOpenMMUtilities::setRandomNumberSeed((unsigned int) integrator.getRandomNumberSeed());
+}
+
+void ReferenceIntegrateNMLStepKernel::execute(ContextImpl& context, const NMLIntegrator& integrator, const double currentPE, const int stepType) {
+
+    double temperature = integrator.getTemperature();
+    double friction = integrator.getFriction();
+    double stepSize = integrator.getStepSize();
+    double* dProjectionVectors = integrator.getProjectionVectors();
+    unsigned int numProjectionVectors = integrator.getNumProjectionVectors();
+    bool projVecChanged = integrator.getProjVecChanged();
+    double minimumLimit = integrator.getMinimumLimit();
+    double maxEig = integrator.getMaxEigenvalue();
+
+
+    RealOpenMM** posData = extractPositions(context);
+    RealOpenMM** velData = extractVelocities(context);
+    RealOpenMM** forceData = extractForces(context);
+
+    //projection vectors
+    if (projectionVectors == 0 || projVecChanged) {
+        std::cout << "Setting vectors " << projVecChanged << std::endl;
+        unsigned int arraySz = numProjectionVectors * context.getSystem().getNumParticles() * 3;
+        if(projectionVectors == 0) {
+            projectionVectors = new RealOpenMM[arraySz];
+        }
+        for(unsigned int i=0; i<arraySz; i++) {
+            projectionVectors[i] = static_cast<RealOpenMM>(dProjectionVectors[i]);
+        }
+
+    }
+
+
+    if (dynamics == 0 ){ //|| temperature != prevTemp || friction != prevFriction || stepSize != prevStepSize) {
+        // Recreate the computation objects with the new parameters.
+
+        if (dynamics) {
+            delete dynamics;
+            delete constraints;
+        }
+        RealOpenMM tau = static_cast<RealOpenMM>( friction == 0.0 ? 0.0 : 1.0/friction );
+
+        dynamics = new ReferenceNMLDynamics(context.getSystem().getNumParticles(),
+                                            static_cast<RealOpenMM>(stepSize),
+                                            static_cast<RealOpenMM>(tau),
+
+                                            static_cast<RealOpenMM>(temperature),
+                                            projectionVectors,
+                                            numProjectionVectors,
+                                            static_cast<RealOpenMM>(minimumLimit),
+                                            static_cast<RealOpenMM>(maxEig));
+
+        vector<ReferenceCCMAAlgorithm::AngleInfo> angles;
+        findAnglesForCCMA(context.getSystem(), angles);
+        constraints = new ReferenceCCMAAlgorithm(context.getSystem().getNumParticles(), numConstraints, constraintIndices, constraintDistances, masses, angles, (RealOpenMM)integrator.getConstraintTolerance());
+        dynamics->setReferenceConstraintAlgorithm(constraints);
+        prevTemp = temperature;
+        prevFriction = friction;
+        prevStepSize = stepSize;
+    }
+    //for minimization quadratic fit we need the potential energy
+    RealOpenMM currentPE2 = static_cast<RealOpenMM>(currentPE);
+    //
+    dynamics->update(context.getSystem().getNumParticles(), posData, velData, forceData, masses, currentPE2, stepType );
+    //update at dynamic step 2
+    if(stepType == 2){
+        data.time += stepSize;
+        data.stepCount++;
+    }
+
+}
+
+} /* namespace OpenMM */
+

plugins/normalModeLangevin/platforms/reference/src/ReferenceNMLKernelFactory.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) 2009 Stanford University and the Authors.           *
+ * Authors: Chris Sweet                                                       *
+ * Contributors: Christopher Bruns                                            *
+ *                                                                            *
+ * 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/OpenMMException.h"
+#include "openmm/internal/ContextImpl.h"
+#include "ReferenceNMLKernelFactory.h"
+#include "ReferenceIntegrateNMLStepKernel.h"
+
+namespace OpenMM {
+
+KernelImpl* ReferenceNMLKernelFactory::createKernelImpl(std::string name, const Platform& platform, ContextImpl& context) const {
+    ReferencePlatform::PlatformData& data = *static_cast<ReferencePlatform::PlatformData*>(context.getPlatformData());
+    if (name == IntegrateNMLStepKernel::Name())
+        return new ReferenceIntegrateNMLStepKernel(name, platform, data);
+    throw OpenMMException((std::string("Tried to create kernel with illegal kernel name '")+name+"'").c_str());
+}
+
+} /* namespace OpenMM */

plugins/normalModeLangevin/src/NMLIntegrator.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) 2009 Stanford University and the Authors.           *
+ * Authors: Chris Sweet                                                       *
+ * Contributors: Christopher Bruns                                            *
+ *                                                                            *
+ * 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 "NMLIntegrator.h"
+#include "IntegrateNMLStepKernel.h"
+#include "openmm/Context.h"
+#include "openmm/internal/ContextImpl.h"
+#include "openmm/kernels.h"
+#include <string>
+
+using namespace OpenMM;
+using std::string;
+using std::vector;
+
+NMLIntegrator::NMLIntegrator(double temperature, double frictionCoeff, double stepSize, ProtoMol::EigenvectorInfo* projectionVectorInfo ) {
+    setTemperature(temperature);
+    setFriction(frictionCoeff);
+    setStepSize(stepSize);
+    setProjectionVectorInfo(projectionVectorInfo);
+    setConstraintTolerance(1e-4);
+}
+
+void NMLIntegrator::initialize(ContextImpl& contextRef) {
+    context = &contextRef;
+    kernel = context->getPlatform().createKernel(IntegrateNMLStepKernel::Name(), contextRef);
+    dynamic_cast<IntegrateNMLStepKernel&>(kernel.getImpl()).initialize(contextRef.getSystem(), *this);
+}
+
+vector<string> NMLIntegrator::getKernelNames() {
+    std::vector<std::string> names;
+    names.push_back(IntegrateNMLStepKernel::Name());
+    return names;
+}
+
+void NMLIntegrator::step(int steps) {
+    
+
+    std::cout << "One loop " << std::endl;
+    
+    //updates per loop. Need it here? ####Moved within loop. Single v multiple steps error if not!
+    //context->updateContextState();
+    //context->calcForces();
+    
+    //loop
+    for (int i = 0; i < steps; ++i) {
+
+        //updates per loop. Need it here?
+        context->updateContextState();
+        context->calcForces();
+
+        //do half kick and full drift
+        dynamic_cast<IntegrateNMLStepKernel&>(kernel.getImpl()).execute(*context, *this, 0.0, 1 );    //stepType 1 is halfKick/drift LangevinLeapfrog
+        //in case projection vectors changed, clear flag
+        setProjVecChanged(false);
+
+        //updates per loop, ####done in minimizer
+        //context->updateContextState();
+        //context->calcForces();
+        
+        //minimize compliment space
+        minimize(50);
+
+        //do half kick
+        dynamic_cast<IntegrateNMLStepKernel&>(kernel.getImpl()).execute(*context, *this, 0.0, 2 );    //stepType 1 is halfKick LangevinLeapfrog
+              
+    }
+    
+    //update time
+    context->setTime(context->getTime()+getStepSize() * steps);
+    
+}
+
+void NMLIntegrator::minimize(int maxsteps) {
+    
+    //minimum limit
+    const double minlim = getMinimumLimit();
+    
+    //loop
+    for (int i = 0; i < maxsteps; ++i) {
+        
+        //updates per loop
+        context->updateContextState();
+        context->calcForces();
+        
+        //get initial PE
+        const double initialPE = context->calcPotentialEnergy();
+        
+        //minimize
+        dynamic_cast<IntegrateNMLStepKernel&>(kernel.getImpl()).execute(*context, *this, initialPE, 3 );    //stepType 3 is simple minimizer
+        setProjVecChanged(false);
+        
+        //get PE difference
+        const double currentPE = context->calcPotentialEnergy();
+        const double peDifference =  initialPE - currentPE;
+        
+        //std::cout << "Loop " << i << ", Current " << currentPE << ", Old " << initialPE << ", lim " << minlim << std::endl;
+        //end condition met?
+        if(peDifference < minlim && peDifference >= 0.0){
+            //std::cout << "Breaking at " << i << ", diff " << peDifference << std::endl;
+            break;
+        }
+        
+        //Require quadratic solution
+        if(peDifference < 0.0){
+            //std::cout << "Quadratic at " << i << std::endl;
+            
+            //update for new positions
+            context->updateContextState();
+            context->calcForces();
+            
+            //minimize, uses quadratic soultion as 'stepsize' not forced
+            dynamic_cast<IntegrateNMLStepKernel&>(kernel.getImpl()).execute(*context, *this, currentPE, 4 ); //stepType 4 is quadratic minimizer   
+            setProjVecChanged(false);
+            
+            std::cout << "Quadratic " << i << ", Current " << context->calcPotentialEnergy() << ", Old " << initialPE << ", lim " << minlim << std::endl;
+            
+            const double quadraticPE = context->calcPotentialEnergy();
+            
+            if(quadraticPE > initialPE){
+                break;
+            }
+            
+        }
+        
+        
+    }
+    
+}

plugins/normalModeLangevin/src/NormalModeLangevin.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) 2009 Stanford University and the Authors.           *
+ * Authors: Chris Sweet                                                       *
+ * Contributors: Christopher Bruns                                            *
+ *                                                                            *
+ * 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 <iostream>
+#include "OpenMM.h"
+#include "ReferenceNMLKernelFactory.h"
+
+using namespace OpenMM;
+using namespace std;
+
+extern "C" void initOpenMMPlugin() {
+    cout << "Initializing Normal Mode Langevin OpenMM plugin..." << endl;
+    for (int p = 0; p < Platform::getNumPlatforms(); ++p) {
+        Platform& platform = Platform::getPlatform(p);
+        if (platform.getName() == "CudaPlatform")
+            // We don't have a Cuda one yet, but we will soon
+            platform.registerKernelFactory("ReferenceNMLKernelFactory", new ReferenceNMLKernelFactory());
+        else
+            platform.registerKernelFactory("ReferenceNMLKernelFactory", new ReferenceNMLKernelFactory());
+    }
+}

plugins/normalModeLangevin/test/CMakeLists.txt

+
+add_executable(TestNormalModeLangevin TestNormalModeLangevin.cpp)
+target_link_libraries(TestNormalModeLangevin OpenMM)
+add_test(TestNormalModeLangevin ${EXECUTABLE_OUTPUT_PATH}/TestNormalModeLangevin)
+