PolynomialPathFitter and other utilities for FunctionBasedPath

.gitignore

@@ -66,6 +66,9 @@ delete_this_to_stop_optimization*.txt
 .idea/deployment.xml
 .idea/other.xml
 
+# Clang-Tidy
+.clang-tidy
+
 # CMake
 cmake-build-*
 

Bindings/OpenSimHeaders_actuators.h

@@ -18,7 +18,8 @@
 #include <OpenSim/Actuators/DeGrooteFregly2016Muscle.h>
 
 #include <OpenSim/Actuators/ModelFactory.h>
-
+#include <OpenSim/Actuators/ModelProcessor.h>
 #include <OpenSim/Actuators/ModelOperators.h>
+#include <OpenSim/Actuators/PolynomialPathFitter.h>
 
 #endif // OPENSIM_OPENSIM_HEADERS_ACTUATORS_H_

Bindings/actuators.i

@@ -27,3 +27,4 @@ namespace OpenSim {
 
 %include <OpenSim/Actuators/ModelProcessor.h>
 %include <OpenSim/Actuators/ModelOperators.h>
+%include <OpenSim/Actuators/PolynomialPathFitter.h>

CHANGELOG.md

@@ -28,6 +28,8 @@ been added to these forces to provide access to concrete path types (e.g., `updP
 - Fixed bindings to expose the method Model::getCoordinatesInMultibodyTreeOrder to scripting users (#3569)
 - Fixed a bug where constructing a `ModelProcessor` from a `Model` object led to an invalid `Model`
 - Added `LatinHypercubeDesign`, a class for generating Latin hypercube designs using random and algorithm methods (#3570)
+- Added `PolynomialPathFitter`, A utility class for fitting a set of `FunctionBasedPath`s to existing geometry-path in 
+  an OpenSim model using `MultivariatePolynomialFunction`s (#3390)
 
 v4.4.1
 ======

OpenSim/Actuators/ModelFactory.cpp

@@ -309,3 +309,26 @@ void ModelFactory::createReserveActuators(Model& model, double optimalForce,
     }
 }
 
+void ModelFactory::replacePathsWithFunctionBasedPaths(Model& model,
+            const Set<FunctionBasedPath>& functionBasedPaths) {
+    for (int i = 0; i < functionBasedPaths.getSize(); ++i) {
+        auto path = functionBasedPaths.get(i);
+
+        // Get the force component associated with this path.
+        OPENSIM_THROW_IF(!model.hasComponent<Force>(path.getName()), 
+                Exception, "Model does not contain a Force at path {}.", 
+                path.getName());
+        auto& force = model.updComponent<Force>(path.getName());
+
+        // Check that the force has a path property.
+        OPENSIM_THROW_IF(
+                !force.hasProperty("path"), Exception,
+                "Force {} does not have a path property.", path.getName());
+
+        // Update the path.
+        path.setName(fmt::format("{}_path", force.getName()));
+        force.updPropertyByName<AbstractPath>("path").setValue(path);
+    }
+    model.finalizeFromProperties();
+    model.finalizeConnections();
+}

OpenSim/Actuators/ModelFactory.h

@@ -19,7 +19,9 @@
  * -------------------------------------------------------------------------- */
 
 #include "osimActuatorsDLL.h"
+#include <OpenSim/Simulation/Model/FunctionBasedPath.h>
 #include <OpenSim/Simulation/Model/Model.h>
+#include <OpenSim/Actuators/ModelProcessor.h>
 
 namespace OpenSim {
 
@@ -89,7 +91,13 @@ class OSIMACTUATORS_API ModelFactory {
     static void createReserveActuators(Model& model, double optimalForce,
             double bound = SimTK::NaN,
             bool skipCoordinatesWithExistingActuators = true);
-
+
+    /// Replace the paths of the forces in the model with the provided Set of
+    /// FunctionBasedPath%s. The name of each FunctionBasedPath should match the
+    /// path of a corresponding Force in the model. The path name is appended
+    /// with "_path" to avoid name ambiguity in the final model.
+    static void replacePathsWithFunctionBasedPaths(Model& model, 
+            const Set<FunctionBasedPath>& functionBasedPaths);
 };
 
 } // namespace OpenSim

OpenSim/Actuators/ModelOperators.h

@@ -182,6 +182,32 @@ class OSIMACTUATORS_API ModOpReplaceMusclesWithPathActuators
     }
 };
 
+/// Invoke ModelFactory::replacePathsWithFunctionBasedPaths() on the model.
+class OSIMACTUATORS_API ModOpReplacePathsWithFunctionBasedPaths 
+        : public ModelOperator {
+    OpenSim_DECLARE_CONCRETE_OBJECT(
+            ModOpReplacePathsWithFunctionBasedPaths, ModelOperator);
+    OpenSim_DECLARE_PROPERTY(paths_file, std::string,
+            "Path to a file containing FunctionBasedPath definitions.");
+
+public:
+    ModOpReplacePathsWithFunctionBasedPaths() {
+        constructProperty_paths_file("");
+    }
+    ModOpReplacePathsWithFunctionBasedPaths(std::string pathsFile) :
+            ModOpReplacePathsWithFunctionBasedPaths() {
+        set_paths_file(std::move(pathsFile));
+    }
+    void operate(Model& model, const std::string&) const override {
+        // Without finalizeFromProperties(), an exception is raised
+        // about the model not having any subcomponents.
+        model.finalizeFromProperties();
+        model.finalizeConnections();
+        ModelFactory::replacePathsWithFunctionBasedPaths(model,
+                Set<FunctionBasedPath>(get_paths_file()));
+    }
+};
+
 } // namespace OpenSim
 
 #endif // OPENSIM_MODELOPERATORS_H