Changes class name to CompositeRMSDForce (#8)

* Updated README.md

* Changed class name

* Updated docs

Author: Charlles Abreu

README.md

@@ -1,39 +1,62 @@
 OpenMM-CPP-Forces Plugin
 ========================
 
-[![Linux](https://github.com/craabreu/openmm-cpp-forces/actions/workflows/Linux.yml/badge.svg)](https://github.com/craabreu/openmm-cpp-forces/actions/workflows/Linux.yml)
-[![MacOS](https://github.com/craabreu/openmm-cpp-forces/actions/workflows/MacOS.yml/badge.svg)](https://github.com/craabreu/openmm-cpp-forces/actions/workflows/MacOS.yml)
-[![Docs](https://github.com/craabreu/openmm-cpp-forces/actions/workflows/Docs.yml/badge.svg)](https://github.com/craabreu/openmm-cpp-forces/actions/workflows/Docs.yml)
-[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
-
-[![Conda version](https://img.shields.io/conda/v/mdtools/openmm-cpp-forces.svg)](https://anaconda.org/mdtools/openmm-cpp-forces)
-[![Conda platforms](https://img.shields.io/conda/pn/mdtools/openmm-cpp-forces.svg)](https://anaconda.org/mdtools/openmm-cpp-forces)
-[![Conda downloads](https://img.shields.io/conda/dn/mdtools/openmm-cpp-forces.svg)](https://anaconda.org/mdtools/openmm-cpp-forces)
+[![Linux](
+    https://github.com/craabreu/openmm-cpp-forces/actions/workflows/Linux.yml/badge.svg
+)](
+    https://github.com/craabreu/openmm-cpp-forces/actions/workflows/Linux.yml
+)
+[![MacOS](
+    https://github.com/craabreu/openmm-cpp-forces/actions/workflows/MacOS.yml/badge.svg
+)](
+    https://github.com/craabreu/openmm-cpp-forces/actions/workflows/MacOS.yml
+)
+[![Docs](
+    https://github.com/craabreu/openmm-cpp-forces/actions/workflows/Docs.yml/badge.svg
+)](
+    https://github.com/craabreu/openmm-cpp-forces/actions/workflows/Docs.yml
+)
+[![License: MIT](
+    https://img.shields.io/badge/License-MIT-green.svg
+)](
+    https://opensource.org/licenses/MIT
+)
+
+[![Conda version](
+    https://img.shields.io/conda/v/mdtools/openmm-cpp-forces.svg
+)](
+    https://anaconda.org/mdtools/openmm-cpp-forces
+)
+[![Conda platforms](
+    https://img.shields.io/conda/pn/mdtools/openmm-cpp-forces.svg
+)](
+    https://anaconda.org/mdtools/openmm-cpp-forces
+)
+[![Conda downloads](
+    https://img.shields.io/conda/dn/mdtools/openmm-cpp-forces.svg
+)](
+    https://anaconda.org/mdtools/openmm-cpp-forces
+)
 
 This [OpenMM] plugin provides Platform-agnostic Force classes.
 
 
-Available Forces
-================
+### Available Forces
 
 The Force classes implemented in OpenMM-CPP-Forces are listed in the table below.
 
-| Force                   | Description                                                      |
-|-------------------------|------------------------------------------------------------------|
-| [ConcertedRMSDForce]    | RMSD of multiple structures constrained to rotate in tandem      |
-
+| Force / CV             | Description                                                             |
+|------------------------|-------------------------------------------------------------------------|
+| [CompositeRMSDForce]   | Deviation of multiple corotating bodies from their reference structures |
 
-Documentation
-=============
+### Documentation
 
-Documentation for this plugin is available at [Github Pages](https://craabreu.github.io/openmm-cpp-forces/).
+Documentation for this plugin is available at [Github Pages].
 
 
-Installation and Usage
-======================
+### Installation and Usage
 
-OpenMM-CPP-Forces is available as a conda package on the
-[mdtools](https://anaconda.org/mdtools/openmm-cpp-forces) channel. To install it, run:
+OpenMM-CPP-Forces is available as a conda package on the [mdtools] channel. To install it, run:
 
 ```bash
     conda install -c conda-forge -c mdtools openmm-cpp-forces
@@ -51,6 +74,11 @@ To use OpenMM-CPP-Forces in your own Python script or Jupyter notebook, simply i
     import openmmcppforces
 ```
 
-
-[OpenMM]:               https://openmm.org
-[ConcertedRMSDForce]:   https://craabreu.github.io/openmm-cpp-forces/pythonapi/ConcertedRMSDForce.html
+[CompositeRMSDForce]:
+    https://craabreu.github.io/openmm-cpp-forces/pythonapi/CompositeRMSDForce.html
+[Github Pages]:
+    https://craabreu.github.io/openmm-cpp-forces
+[mdtools]:
+    https://anaconda.org/mdtools/openmm-cpp-forces
+[OpenMM]:
+    https://openmm.org

docs/conf.py

@@ -35,7 +35,7 @@ def create_rst_file(cls):
         ])
 
 
-create_rst_file(openmmcppforces.ConcertedRMSDForce)
+create_rst_file(openmmcppforces.CompositeRMSDForce)
 
 extensions = [
     'sphinx.ext.autodoc',

docs/pythonapi/index.rst

@@ -8,14 +8,14 @@ To use the plugin from your Python script, you can do:
     import openmm as mm
     import openmmcppforces
 
-    force = openmmcppforces.ConcertedRMSDForce()
+    force = openmmcppforces.CompositeRMSDForce()
 
 This is the implemented subclass of :OpenMM:`Force`:
 
 .. toctree::
     :titlesonly:
 
-    ConcertedRMSDForce
+    CompositeRMSDForce
 
 
 .. testsetup::

openmmcppforces/include/ConcertedRMSDForce.h renamed to openmmcppforces/include/CompositeRMSDForce.h

@@ -1,5 +1,5 @@
-#ifndef OPENMM_CONCERTEDRMSDFORCE_H_
-#define OPENMM_CONCERTEDRMSDFORCE_H_
+#ifndef OPENMM_COMPOSITERMSDFORCE_H_
+#define OPENMM_COMPOSITERMSDFORCE_H_
 
 /* -------------------------------------------------------------------------- *
  *                              OpenMM CPP Forces                             *
@@ -36,17 +36,17 @@ namespace OpenMMCPPForces {
  * in the system.
  */
 
-class CUSTOM_CPP_FORCES_EXPORT ConcertedRMSDForce : public Force {
+class CUSTOM_CPP_FORCES_EXPORT CompositeRMSDForce : public Force {
 public:
     /**
-     * Create an ConcertedRMSDForce.
+     * Create an CompositeRMSDForce.
      *
      * @param referencePositions  the reference positions to compute the deviation from.
      *                            The length of this vector must equal the number of
      *                            particles in the system, even if not all particles are
      *                            used in computing the Concerted RMSD.
      */
-    explicit ConcertedRMSDForce(const vector<Vec3>& referencePositions);
+    explicit CompositeRMSDForce(const vector<Vec3>& referencePositions);
     /**
      * Get the reference positions to compute the deviation from.
      */
@@ -110,4 +110,4 @@ class CUSTOM_CPP_FORCES_EXPORT ConcertedRMSDForce : public Force {
 
 } // namespace OpenMMCPPForces
 
-#endif /*OPENMM_CONCERTEDRMSDFORCE_H_*/
+#endif /*OPENMM_COMPOSITERMSDFORCE_H_*/

openmmcppforces/include/internal/ConcertedRMSDForceImpl.h renamed to openmmcppforces/include/internal/CompositeRMSDForceImpl.h

@@ -1,5 +1,5 @@
-#ifndef OPENMM_CONCERTEDRMSDFORCEIMPL_H_
-#define OPENMM_CONCERTEDRMSDFORCEIMPL_H_
+#ifndef OPENMM_COMPOSITERMSDFORCEIMPL_H_
+#define OPENMM_COMPOSITERMSDFORCEIMPL_H_
 
 /* -------------------------------------------------------------------------- *
  *                              OpenMM CPP Forces                             *
@@ -11,7 +11,7 @@
  *  https://github.com/craabreu/openmm-cpp-forces                               *
  * -------------------------------------------------------------------------- */
 
-#include "ConcertedRMSDForce.h"
+#include "CompositeRMSDForce.h"
 
 #include "openmm/internal/CustomCPPForceImpl.h"
 #include "openmm/internal/ContextImpl.h"
@@ -23,25 +23,25 @@ using namespace std;
 namespace OpenMMCPPForces {
 
 /**
- * This is the internal implementation of ConcertedRMSDForce.
+ * This is the internal implementation of CompositeRMSDForce.
  */
 
-class ConcertedRMSDForceImpl : public CustomCPPForceImpl {
+class CompositeRMSDForceImpl : public CustomCPPForceImpl {
 public:
-    ConcertedRMSDForceImpl(const ConcertedRMSDForce& owner) : CustomCPPForceImpl(owner), owner(owner) {}
+    CompositeRMSDForceImpl(const CompositeRMSDForce& owner) : CustomCPPForceImpl(owner), owner(owner) {}
     void initialize(ContextImpl& context);
     double computeForce(ContextImpl& context, const vector<Vec3>& positions, vector<Vec3>& forces);
-    const ConcertedRMSDForce& getOwner() const {
+    const CompositeRMSDForce& getOwner() const {
         return owner;
     }
     void updateParametersInContext(ContextImpl& context);
 private:
     void updateParameters(int systemSize);
-    const ConcertedRMSDForce& owner;
+    const CompositeRMSDForce& owner;
     vector<vector<int>> groups;
     vector<Vec3> referencePos;
 };
 
 } // namespace OpenMMCPPForces
 
-#endif /*OPENMM_CONCERTEDRMSDFORCEIMPL_H_*/
+#endif /*OPENMM_COMPOSITERMSDFORCEIMPL_H_*/

openmmcppforces/src/ConcertedRMSDForce.cpp renamed to openmmcppforces/src/CompositeRMSDForce.cpp

@@ -8,46 +8,46 @@
  *  https://github.com/craabreu/openmm-cpp-forces                               *
  * -------------------------------------------------------------------------- */
 
-#include "ConcertedRMSDForce.h"
-#include "internal/ConcertedRMSDForceImpl.h"
+#include "CompositeRMSDForce.h"
+#include "internal/CompositeRMSDForceImpl.h"
 
 #include "openmm/internal/AssertionUtilities.h"
 
 using namespace OpenMMCPPForces;
 using namespace OpenMM;
 using namespace std;
 
-ConcertedRMSDForce::ConcertedRMSDForce(const vector<Vec3>& referencePositions) :
+CompositeRMSDForce::CompositeRMSDForce(const vector<Vec3>& referencePositions) :
         referencePositions(referencePositions) {
 }
 
-void ConcertedRMSDForce::setReferencePositions(const std::vector<Vec3>& positions) {
+void CompositeRMSDForce::setReferencePositions(const std::vector<Vec3>& positions) {
     referencePositions = positions;
 }
 
-int ConcertedRMSDForce::addGroup(const vector<int>& particles) {
+int CompositeRMSDForce::addGroup(const vector<int>& particles) {
     groups.push_back(particles);
     return groups.size()-1;
 }
 
-int ConcertedRMSDForce::getNumGroups() const {
+int CompositeRMSDForce::getNumGroups() const {
     return groups.size();
 }
 
-const vector<int>& ConcertedRMSDForce::getGroup(int index) const {
+const vector<int>& CompositeRMSDForce::getGroup(int index) const {
     ASSERT_VALID_INDEX(index, groups);
     return groups[index];
 }
 
-void ConcertedRMSDForce::setGroup(int index, const std::vector<int>& particles) {
+void CompositeRMSDForce::setGroup(int index, const std::vector<int>& particles) {
     ASSERT_VALID_INDEX(index, groups);
     groups[index] = particles;
 }
 
-void ConcertedRMSDForce::updateParametersInContext(Context& context) {
-    dynamic_cast<ConcertedRMSDForceImpl&>(getImplInContext(context)).updateParametersInContext(getContextImpl(context));
+void CompositeRMSDForce::updateParametersInContext(Context& context) {
+    dynamic_cast<CompositeRMSDForceImpl&>(getImplInContext(context)).updateParametersInContext(getContextImpl(context));
 }
 
-ForceImpl* ConcertedRMSDForce::createImpl() const {
-    return new ConcertedRMSDForceImpl(*this);
+ForceImpl* CompositeRMSDForce::createImpl() const {
+    return new CompositeRMSDForceImpl(*this);
 }

openmmcppforces/src/ConcertedRMSDForceImpl.cpp renamed to openmmcppforces/src/CompositeRMSDForceImpl.cpp

@@ -8,7 +8,7 @@
  *  https://github.com/craabreu/openmm-cpp-forces                               *
  * -------------------------------------------------------------------------- */
 
-#include "internal/ConcertedRMSDForceImpl.h"
+#include "internal/CompositeRMSDForceImpl.h"
 
 #include "openmm/internal/CustomCPPForceImpl.h"
 #include "openmm/internal/ContextImpl.h"
@@ -22,16 +22,16 @@ using namespace OpenMM;
 using namespace std;
 
 
-void ConcertedRMSDForceImpl::updateParameters(int systemSize) {
+void CompositeRMSDForceImpl::updateParameters(int systemSize) {
     // Check for errors in the specification of particles.
     if (owner.getReferencePositions().size() != systemSize)
         throw OpenMMException(
-            "ConcertedRMSDForce: Number of reference positions does not equal number of particles in the System"
+            "CompositeRMSDForce: Number of reference positions does not equal number of particles in the System"
         );
 
     int numGroups = owner.getNumGroups();
     if (numGroups == 0)
-        throw OpenMMException("ConcertedRMSDForce: No particle groups have been specified");
+        throw OpenMMException("CompositeRMSDForce: No particle groups have been specified");
 
     groups.resize(numGroups);
     for (int i = 0; i < numGroups; i++) {
@@ -48,12 +48,12 @@ void ConcertedRMSDForceImpl::updateParameters(int systemSize) {
         for (int i : groups[k]) {
             if (i < 0 || i >= systemSize) {
                 stringstream msg;
-                msg << "ConcertedRMSDForce: Illegal particle index " << i << " in group " << k;
+                msg << "CompositeRMSDForce: Illegal particle index " << i << " in group " << k;
                 throw OpenMMException(msg.str());
             }
             if (distinctParticles.find(i) != distinctParticles.end()) {
                 stringstream msg;
-                msg << "ConcertedRMSDForce: Duplicated particle index " << i << " in group " << k;
+                msg << "CompositeRMSDForce: Duplicated particle index " << i << " in group " << k;
                 throw OpenMMException(msg.str());
             }
             distinctParticles.insert(i);
@@ -71,12 +71,12 @@ void ConcertedRMSDForceImpl::updateParameters(int systemSize) {
     }
 }
 
-void ConcertedRMSDForceImpl::initialize(ContextImpl& context) {
+void CompositeRMSDForceImpl::initialize(ContextImpl& context) {
     CustomCPPForceImpl::initialize(context);
     updateParameters(context.getSystem().getNumParticles());
 }
 
-double ConcertedRMSDForceImpl::computeForce(ContextImpl& context, const vector<Vec3>& positions, vector<Vec3>& forces) {
+double CompositeRMSDForceImpl::computeForce(ContextImpl& context, const vector<Vec3>& positions, vector<Vec3>& forces) {
     // Compute the RMSD and its gradient using the algorithm described in Coutsias et al,
     // "Using quaternions to calculate RMSD" (doi: 10.1002/jcc.20110).  First subtract
     // the centroid from the atom positions.  The reference positions have already been centered.
@@ -173,7 +173,7 @@ double ConcertedRMSDForceImpl::computeForce(ContextImpl& context, const vector<V
     return rmsd;
 }
 
-void ConcertedRMSDForceImpl::updateParametersInContext(ContextImpl& context) {
+void CompositeRMSDForceImpl::updateParametersInContext(ContextImpl& context) {
     updateParameters(context.getSystem().getNumParticles());
     context.systemChanged();
 }