From 5d525c67dc4431bb8058f28e0c6568458c124181 Mon Sep 17 00:00:00 2001
From: aymanhab <ahabib@stanford.edu>
Date: Thu, 26 Sep 2024 13:31:26 -0700
Subject: [PATCH] Bring java source (swig generated) in sync with opensim-core

---
 .../modeling/AbstractGeometryPath.java        |  15 ++
 .../src/org/opensim/modeling/Actuator.java    |   2 +-
 .../opensim/modeling/ActuatorIterator.java    |  55 ++++-
 .../org/opensim/modeling/ActuatorList.java    |   3 +-
 .../modeling/Blankevoort1991Ligament.java     |   6 +-
 .../org/opensim/modeling/BodyIterator.java    |  28 ++-
 .../src/org/opensim/modeling/BodyList.java    |   3 +-
 .../src/org/opensim/modeling/Component.java   |  28 ++-
 .../opensim/modeling/ComponentIterator.java   |  28 ++-
 .../org/opensim/modeling/ComponentPath.java   |   7 +
 .../org/opensim/modeling/ComponentsList.java  |   3 +-
 .../modeling/ConstantDistanceConstraint.java  |   2 +-
 .../modeling/CoordinateLimitForce.java        |   8 +-
 .../modeling/DeGrooteFregly2016Muscle.java    |  23 +-
 .../modeling/ExpressionBasedBushingForce.java |  18 +-
 .../ExpressionBasedCoordinateForce.java       |  24 +-
 .../modeling/ExpressionBasedFunction.java     | 216 +++++++++++++++++
 .../ExpressionBasedPointToPointForce.java     |  18 +-
 .../org/opensim/modeling/ExternalForce.java   |   2 +-
 .../org/opensim/modeling/ForceProducer.java   | 113 +++++++++
 .../org/opensim/modeling/FrameIterator.java   |  28 ++-
 .../src/org/opensim/modeling/FrameList.java   |   3 +-
 .../modeling/FunctionBasedBushingForce.java   |  10 +-
 .../opensim/modeling/FunctionBasedPath.java   |   4 +-
 .../org/opensim/modeling/GeometryPath.java    |  16 +-
 .../org/opensim/modeling/InputController.java | 206 ++++++++++++++++
 .../org/opensim/modeling/InvalidIndices.java  |  55 +++++
 .../org/opensim/modeling/JointIterator.java   |  28 ++-
 .../src/org/opensim/modeling/JointList.java   |   3 +-
 .../src/org/opensim/modeling/Ligament.java    |   6 +-
 .../Millard2012EquilibriumMuscleIterator.java |  43 +++-
 .../Millard2012EquilibriumMuscleList.java     |   3 +-
 .../opensim/modeling/MocoCasADiSolver.java    | 144 ++++++++++--
 .../modeling/MocoDirectCollocationSolver.java |  72 ++++--
 .../MocoExpressionBasedParameterGoal.java     | 142 +++++++++++
 .../MocoGeneralizedForceTrackingGoal.java     |  17 +-
 .../src/org/opensim/modeling/MocoInverse.java |   4 +
 .../modeling/MocoJointReactionGoal.java       |   4 +-
 .../modeling/MocoOrientationTrackingGoal.java |  11 +-
 .../org/opensim/modeling/MocoOutputBase.java  |  59 ++++-
 .../modeling/MocoOutputBoundConstraint.java   | 221 ++++++++++++++++++
 .../modeling/MocoOutputConstraint.java        |  49 ++++
 .../org/opensim/modeling/MocoParameter.java   |   4 +
 .../src/org/opensim/modeling/MocoPhase.java   |  29 +++
 .../src/org/opensim/modeling/MocoProblem.java |  33 +++
 .../org/opensim/modeling/MocoProblemRep.java  |   2 +-
 .../modeling/MocoStateBoundConstraint.java    | 157 +++++++++++++
 .../org/opensim/modeling/MocoTrajectory.java  |  36 +--
 .../ModOpPrescribeCoordinateValues.java       |  91 ++++++++
 .../modeling/ModelComponentIterator.java      |  28 ++-
 .../opensim/modeling/ModelComponentList.java  |   3 +-
 .../org/opensim/modeling/MuscleIterator.java  |  43 +++-
 .../src/org/opensim/modeling/MuscleList.java  |   3 +-
 .../org/opensim/modeling/PathActuator.java    |   4 -
 .../src/org/opensim/modeling/PathSpring.java  |   2 +-
 .../opensim/modeling/PointForceDirection.java |  34 ++-
 .../modeling/PolynomialPathFitter.java        |  33 ++-
 .../org/opensim/modeling/PrescribedForce.java |   2 +-
 .../SWIGTYPE_p_OpenSim__ForceConsumer.java    |  30 +++
 .../modeling/SpringGeneralizedForce.java      |   2 +-
 .../opensim/modeling/SynergyController.java   | 186 +++++++++++++++
 .../org/opensim/modeling/SynergyVector.java   | 123 ++++++++++
 ...endCoordinateValueDerivativesAsSpeeds.java |   2 +-
 .../modeling/Thelen2003MuscleIterator.java    |  43 +++-
 .../modeling/Thelen2003MuscleList.java        |   3 +-
 .../org/opensim/modeling/TimeSeriesTable.java |  16 +-
 .../modeling/TimeSeriesTableMat33.java        |  16 +-
 .../modeling/TimeSeriesTableQuaternion.java   |  16 +-
 .../modeling/TimeSeriesTableRotation.java     |  16 +-
 .../modeling/TimeSeriesTableSpatialVec.java   |  16 +-
 .../modeling/TimeSeriesTableUnitVec3.java     |  16 +-
 .../opensim/modeling/TimeSeriesTableVec3.java |  16 +-
 .../opensim/modeling/TimeSeriesTableVec6.java |  16 +-
 .../modeling/TwoFrameLinkerForceProducer.java | 202 ++++++++++++++++
 .../opensimActuatorsAnalysesToolsJNI.java     |   9 +
 .../org/opensim/modeling/opensimCommon.java   |  60 ++++-
 .../opensim/modeling/opensimCommonJNI.java    |  65 +++++-
 .../org/opensim/modeling/opensimMocoJNI.java  | 149 ++++++++++--
 .../modeling/opensimSimulationJNI.java        | 194 ++++++++++++---
 79 files changed, 3104 insertions(+), 326 deletions(-)
 create mode 100644 Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedFunction.java
 create mode 100644 Gui/opensim/modeling/src/org/opensim/modeling/ForceProducer.java
 create mode 100644 Gui/opensim/modeling/src/org/opensim/modeling/InputController.java
 create mode 100644 Gui/opensim/modeling/src/org/opensim/modeling/InvalidIndices.java
 create mode 100644 Gui/opensim/modeling/src/org/opensim/modeling/MocoExpressionBasedParameterGoal.java
 create mode 100644 Gui/opensim/modeling/src/org/opensim/modeling/MocoOutputBoundConstraint.java
 create mode 100644 Gui/opensim/modeling/src/org/opensim/modeling/MocoStateBoundConstraint.java
 create mode 100644 Gui/opensim/modeling/src/org/opensim/modeling/ModOpPrescribeCoordinateValues.java
 create mode 100644 Gui/opensim/modeling/src/org/opensim/modeling/SWIGTYPE_p_OpenSim__ForceConsumer.java
 create mode 100644 Gui/opensim/modeling/src/org/opensim/modeling/SynergyController.java
 create mode 100644 Gui/opensim/modeling/src/org/opensim/modeling/SynergyVector.java
 create mode 100644 Gui/opensim/modeling/src/org/opensim/modeling/TwoFrameLinkerForceProducer.java

diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/AbstractGeometryPath.java b/Gui/opensim/modeling/src/org/opensim/modeling/AbstractGeometryPath.java
index 002c8a253..646ef08e3 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/AbstractGeometryPath.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/AbstractGeometryPath.java
@@ -162,10 +162,25 @@ public double getLengtheningSpeed(State s) {
     return opensimSimulationJNI.AbstractGeometryPath_getLengtheningSpeed(swigCPtr, this, State.getCPtr(s), s);
   }
 
+  /**
+   * Requests that the concrete implementation produces forces resulting from<br>
+   * applying a tension along its path, emitting them into the supplied<br>
+   * `ForceConsumer`.<br>
+   * <br>
+   * @param state         the state used to evaluate forces<br>
+   * @param tension       scalar of the applied (+ve) tensile force<br>
+   * @param forceConsumer a `ForceConsumer` shall receive each produced force
+   */
+  public void produceForces(State state, double tension, SWIGTYPE_p_OpenSim__ForceConsumer forceConsumer) {
+    opensimSimulationJNI.AbstractGeometryPath_produceForces(swigCPtr, this, State.getCPtr(state), state, tension, SWIGTYPE_p_OpenSim__ForceConsumer.getCPtr(forceConsumer));
+  }
+
   /**
    *  Add in the equivalent body and generalized forces to be applied to the<br>
    *  multibody system resulting from a tension along the AbstractGeometryPath.<br>
    * <br>
+   * Note: this internally uses `produceForces`<br>
+   * <br>
    *  @param state           state used to evaluate forces<br>
    *  @param tension         scalar of the applied (+ve) tensile force<br>
    *  @param bodyForces      Vector of forces (SpatialVec's) on bodies<br>
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/Actuator.java b/Gui/opensim/modeling/src/org/opensim/modeling/Actuator.java
index 072e96df7..dfae09705 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/Actuator.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/Actuator.java
@@ -15,7 +15,7 @@
  * <br>
  * @author Ajay Seth
  */
-public class Actuator extends Force {
+public class Actuator extends ForceProducer {
   private transient long swigCPtr;
 
   public Actuator(long cPtr, boolean cMemoryOwn) {
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/ActuatorIterator.java b/Gui/opensim/modeling/src/org/opensim/modeling/ActuatorIterator.java
index 60b365d42..ae1bcdaf8 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/ActuatorIterator.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/ActuatorIterator.java
@@ -166,6 +166,33 @@ public void computeEquilibrium(State s) {
     opensimSimulationJNI.ActuatorIterator_computeEquilibrium(swigCPtr, this, State.getCPtr(s), s);
   }
 
+  /**
+   * Uses `implProduceForces` to produce (emit) forces evaluated from `state` into the<br>
+   * provided `ForceConsumer`.<br>
+   * <br>
+   * Note: this function only produces the forces and does not apply them to anything. It's<br>
+   *       up to the `ForceConsumer` implementation to handle the forces. Therefore,<br>
+   *       `Force::appliesForces` is ignored by this method.<br>
+   * <br>
+   * @param state       the state used to evaluate forces<br>
+   * 
+   */
+  public void produceForces(State state, SWIGTYPE_p_OpenSim__ForceConsumer forceConsumer) {
+    opensimSimulationJNI.ActuatorIterator_produceForces(swigCPtr, this, State.getCPtr(state), state, SWIGTYPE_p_OpenSim__ForceConsumer.getCPtr(forceConsumer));
+  }
+
+  /**
+   * Inhereted from `OpenSim::Force`.<br>
+   * <br>
+   * `ForceProducer` overrides `OpenSim::Force::computeForce` with a default<br>
+   * implementation that, provided `OpenSim::Force::appliesForces` is `true`,<br>
+   * internally uses `produceForces` to mutate the provided `bodyForces` in a<br>
+   * manner that's compatible with the `OpenSim::Force` API.
+   */
+  public void computeForce(State state, VectorOfSpatialVec bodyForces, Vector generalizedForces) {
+    opensimSimulationJNI.ActuatorIterator_computeForce(swigCPtr, this, State.getCPtr(state), state, VectorOfSpatialVec.getCPtr(bodyForces), bodyForces, Vector.getCPtr(generalizedForces), generalizedForces);
+  }
+
   public boolean get_appliesForce(int i) {
     return opensimSimulationJNI.ActuatorIterator_get_appliesForce__SWIG_0(swigCPtr, this, i);
   }
@@ -707,7 +734,11 @@ public AbstractOutput getOutput(String name) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public int getModelingOption(State state, String path) {
-    return opensimSimulationJNI.ActuatorIterator_getModelingOption(swigCPtr, this, State.getCPtr(state), state, path);
+    return opensimSimulationJNI.ActuatorIterator_getModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path);
+  }
+
+  public int getModelingOption(State state, ComponentPath path) {
+    return opensimSimulationJNI.ActuatorIterator_getModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
@@ -736,7 +767,11 @@ public int getModelingOption(State state, String path) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public void setModelingOption(State state, String path, int flag) {
-    opensimSimulationJNI.ActuatorIterator_setModelingOption(swigCPtr, this, State.getCPtr(state), state, path, flag);
+    opensimSimulationJNI.ActuatorIterator_setModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path, flag);
+  }
+
+  public void setModelingOption(State state, ComponentPath path, int flag) {
+    opensimSimulationJNI.ActuatorIterator_setModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path, flag);
   }
 
   /**
@@ -770,7 +805,7 @@ public double getStateVariableValue(State state, String name) {
    }<br>
    * <br>
    * @param state   the State for which to get the value<br>
-   * <br>
+   * @param path    path to the state variable of interest<br>
    * @throws ComponentHasNoSystem if this Component has not been added to a<br>
    *         System (i.e., if initSystem has not been called)
    */
@@ -835,7 +870,19 @@ public void setStateVariableValues(State state, Vector values) {
    *         System (i.e., if initSystem has not been called)
    */
   public double getStateVariableDerivativeValue(State state, String name) {
-    return opensimSimulationJNI.ActuatorIterator_getStateVariableDerivativeValue(swigCPtr, this, State.getCPtr(state), state, name);
+    return opensimSimulationJNI.ActuatorIterator_getStateVariableDerivativeValue__SWIG_0(swigCPtr, this, State.getCPtr(state), state, name);
+  }
+
+  /**
+   * Get the value of a state variable derivative computed by this Component.<br>
+   * <br>
+   * @param state   the State for which to get the derivative value<br>
+   * @param path    path to the state variable of interest<br>
+   * @throws ComponentHasNoSystem if this Component has not been added to a<br>
+   *         System (i.e., if initSystem has not been called)
+   */
+  public double getStateVariableDerivativeValue(State state, ComponentPath path) {
+    return opensimSimulationJNI.ActuatorIterator_getStateVariableDerivativeValue__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/ActuatorList.java b/Gui/opensim/modeling/src/org/opensim/modeling/ActuatorList.java
index 11ade272c..2859b3d34 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/ActuatorList.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/ActuatorList.java
@@ -60,8 +60,7 @@ public ActuatorList(Component root, ComponentFilter f) {
 
   /**
    *  Constructor that takes only a Component to iterate over (itself and its<br>
-   *     descendants). ComponentFilterMatchAll is used internally. You can<br>
-   *     change the filter using setFilter() method. 
+   *     descendants). You can change the filter using setFilter() method.
    */
   public ActuatorList(Component root) {
     this(opensimSimulationJNI.new_ActuatorList__SWIG_1(Component.getCPtr(root), root), true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/Blankevoort1991Ligament.java b/Gui/opensim/modeling/src/org/opensim/modeling/Blankevoort1991Ligament.java
index 70270d8c5..521d4dfdb 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/Blankevoort1991Ligament.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/Blankevoort1991Ligament.java
@@ -147,7 +147,7 @@ When scaling a model (using the ScaleTool) that contains a
 
 
  */
-public class Blankevoort1991Ligament extends Force {
+public class Blankevoort1991Ligament extends ForceProducer {
   private transient long swigCPtr;
 
   public Blankevoort1991Ligament(long cPtr, boolean cMemoryOwn) {
@@ -579,10 +579,6 @@ public double computeMomentArm(State s, Coordinate aCoord) {
     return opensimSimulationJNI.Blankevoort1991Ligament_computeMomentArm(swigCPtr, this, State.getCPtr(s), s, Coordinate.getCPtr(aCoord), aCoord);
   }
 
-  public void computeForce(State s, VectorOfSpatialVec bodyForces, Vector generalizedForces) {
-    opensimSimulationJNI.Blankevoort1991Ligament_computeForce(swigCPtr, this, State.getCPtr(s), s, VectorOfSpatialVec.getCPtr(bodyForces), bodyForces, Vector.getCPtr(generalizedForces), generalizedForces);
-  }
-
   public double computePotentialEnergy(State state) {
     return opensimSimulationJNI.Blankevoort1991Ligament_computePotentialEnergy(swigCPtr, this, State.getCPtr(state), state);
   }
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/BodyIterator.java b/Gui/opensim/modeling/src/org/opensim/modeling/BodyIterator.java
index bc0d946b1..1451ec84a 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/BodyIterator.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/BodyIterator.java
@@ -984,7 +984,11 @@ public AbstractOutput getOutput(String name) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public int getModelingOption(State state, String path) {
-    return opensimSimulationJNI.BodyIterator_getModelingOption(swigCPtr, this, State.getCPtr(state), state, path);
+    return opensimSimulationJNI.BodyIterator_getModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path);
+  }
+
+  public int getModelingOption(State state, ComponentPath path) {
+    return opensimSimulationJNI.BodyIterator_getModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
@@ -1013,7 +1017,11 @@ public int getModelingOption(State state, String path) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public void setModelingOption(State state, String path, int flag) {
-    opensimSimulationJNI.BodyIterator_setModelingOption(swigCPtr, this, State.getCPtr(state), state, path, flag);
+    opensimSimulationJNI.BodyIterator_setModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path, flag);
+  }
+
+  public void setModelingOption(State state, ComponentPath path, int flag) {
+    opensimSimulationJNI.BodyIterator_setModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path, flag);
   }
 
   /**
@@ -1047,7 +1055,7 @@ public double getStateVariableValue(State state, String name) {
    }<br>
    * <br>
    * @param state   the State for which to get the value<br>
-   * <br>
+   * @param path    path to the state variable of interest<br>
    * @throws ComponentHasNoSystem if this Component has not been added to a<br>
    *         System (i.e., if initSystem has not been called)
    */
@@ -1112,7 +1120,19 @@ public void setStateVariableValues(State state, Vector values) {
    *         System (i.e., if initSystem has not been called)
    */
   public double getStateVariableDerivativeValue(State state, String name) {
-    return opensimSimulationJNI.BodyIterator_getStateVariableDerivativeValue(swigCPtr, this, State.getCPtr(state), state, name);
+    return opensimSimulationJNI.BodyIterator_getStateVariableDerivativeValue__SWIG_0(swigCPtr, this, State.getCPtr(state), state, name);
+  }
+
+  /**
+   * Get the value of a state variable derivative computed by this Component.<br>
+   * <br>
+   * @param state   the State for which to get the derivative value<br>
+   * @param path    path to the state variable of interest<br>
+   * @throws ComponentHasNoSystem if this Component has not been added to a<br>
+   *         System (i.e., if initSystem has not been called)
+   */
+  public double getStateVariableDerivativeValue(State state, ComponentPath path) {
+    return opensimSimulationJNI.BodyIterator_getStateVariableDerivativeValue__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/BodyList.java b/Gui/opensim/modeling/src/org/opensim/modeling/BodyList.java
index a81397be2..7f3f89630 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/BodyList.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/BodyList.java
@@ -60,8 +60,7 @@ public BodyList(Component root, ComponentFilter f) {
 
   /**
    *  Constructor that takes only a Component to iterate over (itself and its<br>
-   *     descendants). ComponentFilterMatchAll is used internally. You can<br>
-   *     change the filter using setFilter() method. 
+   *     descendants). You can change the filter using setFilter() method.
    */
   public BodyList(Component root) {
     this(opensimSimulationJNI.new_BodyList__SWIG_1(Component.getCPtr(root), root), true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/Component.java b/Gui/opensim/modeling/src/org/opensim/modeling/Component.java
index af4b686e6..a5c198b8f 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/Component.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/Component.java
@@ -863,7 +863,11 @@ public AbstractOutput updOutput(String name) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public int getModelingOption(State state, String path) {
-    return opensimCommonJNI.Component_getModelingOption(swigCPtr, this, State.getCPtr(state), state, path);
+    return opensimCommonJNI.Component_getModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path);
+  }
+
+  public int getModelingOption(State state, ComponentPath path) {
+    return opensimCommonJNI.Component_getModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
@@ -892,7 +896,11 @@ public int getModelingOption(State state, String path) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public void setModelingOption(State state, String path, int flag) {
-    opensimCommonJNI.Component_setModelingOption(swigCPtr, this, State.getCPtr(state), state, path, flag);
+    opensimCommonJNI.Component_setModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path, flag);
+  }
+
+  public void setModelingOption(State state, ComponentPath path, int flag) {
+    opensimCommonJNI.Component_setModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path, flag);
   }
 
   /**
@@ -926,7 +934,7 @@ public double getStateVariableValue(State state, String name) {
    }<br>
    * <br>
    * @param state   the State for which to get the value<br>
-   * <br>
+   * @param path    path to the state variable of interest<br>
    * @throws ComponentHasNoSystem if this Component has not been added to a<br>
    *         System (i.e., if initSystem has not been called)
    */
@@ -991,7 +999,19 @@ public void setStateVariableValues(State state, Vector values) {
    *         System (i.e., if initSystem has not been called)
    */
   public double getStateVariableDerivativeValue(State state, String name) {
-    return opensimCommonJNI.Component_getStateVariableDerivativeValue(swigCPtr, this, State.getCPtr(state), state, name);
+    return opensimCommonJNI.Component_getStateVariableDerivativeValue__SWIG_0(swigCPtr, this, State.getCPtr(state), state, name);
+  }
+
+  /**
+   * Get the value of a state variable derivative computed by this Component.<br>
+   * <br>
+   * @param state   the State for which to get the derivative value<br>
+   * @param path    path to the state variable of interest<br>
+   * @throws ComponentHasNoSystem if this Component has not been added to a<br>
+   *         System (i.e., if initSystem has not been called)
+   */
+  public double getStateVariableDerivativeValue(State state, ComponentPath path) {
+    return opensimCommonJNI.Component_getStateVariableDerivativeValue__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/ComponentIterator.java b/Gui/opensim/modeling/src/org/opensim/modeling/ComponentIterator.java
index c18a8e566..442527338 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/ComponentIterator.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/ComponentIterator.java
@@ -587,7 +587,11 @@ public AbstractOutput getOutput(String name) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public int getModelingOption(State state, String path) {
-    return opensimCommonJNI.ComponentIterator_getModelingOption(swigCPtr, this, State.getCPtr(state), state, path);
+    return opensimCommonJNI.ComponentIterator_getModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path);
+  }
+
+  public int getModelingOption(State state, ComponentPath path) {
+    return opensimCommonJNI.ComponentIterator_getModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
@@ -616,7 +620,11 @@ public int getModelingOption(State state, String path) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public void setModelingOption(State state, String path, int flag) {
-    opensimCommonJNI.ComponentIterator_setModelingOption(swigCPtr, this, State.getCPtr(state), state, path, flag);
+    opensimCommonJNI.ComponentIterator_setModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path, flag);
+  }
+
+  public void setModelingOption(State state, ComponentPath path, int flag) {
+    opensimCommonJNI.ComponentIterator_setModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path, flag);
   }
 
   /**
@@ -650,7 +658,7 @@ public double getStateVariableValue(State state, String name) {
    }<br>
    * <br>
    * @param state   the State for which to get the value<br>
-   * <br>
+   * @param path    path to the state variable of interest<br>
    * @throws ComponentHasNoSystem if this Component has not been added to a<br>
    *         System (i.e., if initSystem has not been called)
    */
@@ -715,7 +723,19 @@ public void setStateVariableValues(State state, Vector values) {
    *         System (i.e., if initSystem has not been called)
    */
   public double getStateVariableDerivativeValue(State state, String name) {
-    return opensimCommonJNI.ComponentIterator_getStateVariableDerivativeValue(swigCPtr, this, State.getCPtr(state), state, name);
+    return opensimCommonJNI.ComponentIterator_getStateVariableDerivativeValue__SWIG_0(swigCPtr, this, State.getCPtr(state), state, name);
+  }
+
+  /**
+   * Get the value of a state variable derivative computed by this Component.<br>
+   * <br>
+   * @param state   the State for which to get the derivative value<br>
+   * @param path    path to the state variable of interest<br>
+   * @throws ComponentHasNoSystem if this Component has not been added to a<br>
+   *         System (i.e., if initSystem has not been called)
+   */
+  public double getStateVariableDerivativeValue(State state, ComponentPath path) {
+    return opensimCommonJNI.ComponentIterator_getStateVariableDerivativeValue__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/ComponentPath.java b/Gui/opensim/modeling/src/org/opensim/modeling/ComponentPath.java
index a1d6b6983..235d1febd 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/ComponentPath.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/ComponentPath.java
@@ -65,6 +65,13 @@ public synchronized void delete() {
     }
   }
 
+  /**
+   * Returns the separator used to delimit path elements in the path
+   */
+  public static char separator() {
+    return opensimCommonJNI.ComponentPath_separator();
+  }
+
   /**
    * Returns the root component path (i.e. "/")
    */
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/ComponentsList.java b/Gui/opensim/modeling/src/org/opensim/modeling/ComponentsList.java
index 3fd871684..dac1785f3 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/ComponentsList.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/ComponentsList.java
@@ -60,8 +60,7 @@ public ComponentsList(Component root, ComponentFilter f) {
 
   /**
    *  Constructor that takes only a Component to iterate over (itself and its<br>
-   *     descendants). ComponentFilterMatchAll is used internally. You can<br>
-   *     change the filter using setFilter() method. 
+   *     descendants). You can change the filter using setFilter() method.
    */
   public ComponentsList(Component root) {
     this(opensimCommonJNI.new_ComponentsList__SWIG_1(Component.getCPtr(root), root), true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/ConstantDistanceConstraint.java b/Gui/opensim/modeling/src/org/opensim/modeling/ConstantDistanceConstraint.java
index 6ed30b8a8..e72cfbbcc 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/ConstantDistanceConstraint.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/ConstantDistanceConstraint.java
@@ -10,7 +10,7 @@
 
 /**
  * A class implementing a constraint that maintains a constant distance between<br>
- * between two points on separate PhysicalFrames. <br>
+ * two points on separate PhysicalFrames. <br>
  * The underlying SimTK::Constraint in Simbody is a SimTK::Constraint::Rod.<br>
  * <br>
  * @author Matt DeMers
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/CoordinateLimitForce.java b/Gui/opensim/modeling/src/org/opensim/modeling/CoordinateLimitForce.java
index b8ead6dca..5c9eea622 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/CoordinateLimitForce.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/CoordinateLimitForce.java
@@ -11,10 +11,10 @@
 /**
  * Generate a force that acts to limit the range of motion of a coordinate.<br>
  * Force is experienced at upper and lower limits of the coordinate value<br>
- * according to a constant stiffnesses K_upper and K_lower, with a C2 continuous<br>
+ * according to constant stiffnesses K_upper and K_lower, with a C2-continuous<br>
  * transition from 0 to K. The transition parameter defines how far beyond the<br>
  * limit the stiffness becomes constant. The integrator will like smoother<br>
- * (i.e. larger transition regions).<br>
+ * (i.e. larger) transition regions.<br>
  * <br>
  * Damping factor is also phased in through the transition region from 0 to the<br>
  * value provided.<br>
@@ -22,14 +22,14 @@
  * Limiting force is guaranteed to be zero within the upper and lower limits.<br>
  * <br>
  * The potential energy stored in the spring component of the force is<br>
- * accessible as well as the power (nd optionally energy) dissipated.<br>
+ * accessible as well as the power (and, optionally, energy) dissipated.<br>
  * The function has the following shape:<br>
  * <br>
  * <img src="coordinate_limit_force.png"/><br>
  * <br>
  * @author Ajay Seth
  */
-public class CoordinateLimitForce extends Force {
+public class CoordinateLimitForce extends ForceProducer {
   private transient long swigCPtr;
 
   public CoordinateLimitForce(long cPtr, boolean cMemoryOwn) {
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/DeGrooteFregly2016Muscle.java b/Gui/opensim/modeling/src/org/opensim/modeling/DeGrooteFregly2016Muscle.java
index de352bfa4..bb861a630 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/DeGrooteFregly2016Muscle.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/DeGrooteFregly2016Muscle.java
@@ -54,10 +54,29 @@
  * time-stepping forward simulation with Manager; use explicit mode for <br>
  * time-stepping.<br>
  * <br>
- * Note: Normalized tendon force is bounded in the range [0, 5] in this class.<br>
- *    The methods getMinNormalizedTendonForce() and <br>
+ * <br>
+ * The acceptable bounds for each property are enforced at model initialization.<br>
+ * These bounds are:<br>
+ *  - activation_time_constant: (0, inf]<br>
+ *  - deactivation_time_constant: (0, inf]<br>
+ *  - active_force_width_scale: [1, inf]<br>
+ *  - fiber_damping: [0, inf]<br>
+ *  - passive_fiber_strain_at_one_norm_force: (0, inf]<br>
+ *  - tendon_strain_at_one_norm_force: (0, inf]<br>
+ *  - pennation_angle_at_optimal: [0, Pi/2)<br>
+ *  - default_activation: (0, inf]<br>
+ *  - default_normalized_tendon_force: [0, 5]<br>
+ * <br>
+ * Note: The methods getMinNormalizedTendonForce() and<br>
  *    getMaxNormalizedTendonForce() provide these bounds for use in custom solvers.<br>
  * <br>
+ * Note: Muscle properties can be optimized using MocoParameter. The acceptable<br>
+ * bounds for each property are **not** enforced during parameter optimization, so<br>
+ * the user must supply these bounds to MocoParameter.<br>
+ * <br>
+ * Note: The properties `default_activation` and `default_normalized_tendon_force`<br>
+ * cannot be optimized because they are applied during model initialization only.<br>
+ * <br>
  * <br>
  * <br>
  * The documentation for Muscle::MuscleLengthInfo states that the<br>
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedBushingForce.java b/Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedBushingForce.java
index 6352f7cca..dd3d1b2f3 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedBushingForce.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedBushingForce.java
@@ -24,7 +24,7 @@
  * <br>
  * @author Matt DeMers
  */
-public class ExpressionBasedBushingForce extends TwoFrameLinkerForce {
+public class ExpressionBasedBushingForce extends TwoFrameLinkerForceProducer {
   private transient long swigCPtr;
 
   public ExpressionBasedBushingForce(long cPtr, boolean cMemoryOwn) {
@@ -494,6 +494,14 @@ public void set_translational_damping(Vec3 value) {
     opensimSimulationJNI.ExpressionBasedBushingForce_set_translational_damping__SWIG_1(swigCPtr, this, Vec3.getCPtr(value), value);
   }
 
+  public void set_has_output_bushing_force(boolean value) {
+    opensimSimulationJNI.ExpressionBasedBushingForce__has_output_bushing_force_set(swigCPtr, this, value);
+  }
+
+  public boolean get_has_output_bushing_force() {
+    return opensimSimulationJNI.ExpressionBasedBushingForce__has_output_bushing_force_get(swigCPtr, this);
+  }
+
   /**
    *  Default constructor leaves bodies unspecified, sets the bushing frames<br>
    * to be at their body origins, and sets all bushing parameters to zero. *
@@ -692,6 +700,14 @@ public Vec6 calcDampingForce(State state) {
     return new Vec6(opensimSimulationJNI.ExpressionBasedBushingForce_calcDampingForce(swigCPtr, this, State.getCPtr(state), state), true);
   }
 
+  /**
+   *  Calculate the total bushing force. This is the sum of the stiffness and<br>
+   *         damping force contributions. 
+   */
+  public Vec6 calcBushingForce(State state) {
+    return new Vec6(opensimSimulationJNI.ExpressionBasedBushingForce_calcBushingForce(swigCPtr, this, State.getCPtr(state), state), true);
+  }
+
   /**
    * Provide name(s) of the quantities (column labels) of the force value(s) <br>
    * to be reported.
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedCoordinateForce.java b/Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedCoordinateForce.java
index 2d61df3e7..5cd66a21f 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedCoordinateForce.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedCoordinateForce.java
@@ -8,7 +8,7 @@
 
 package org.opensim.modeling;
 
-public class ExpressionBasedCoordinateForce extends Force {
+public class ExpressionBasedCoordinateForce extends ForceProducer {
   private transient long swigCPtr;
 
   public ExpressionBasedCoordinateForce(long cPtr, boolean cMemoryOwn) {
@@ -142,6 +142,14 @@ public void set_expression(String value) {
     opensimSimulationJNI.ExpressionBasedCoordinateForce_set_expression__SWIG_1(swigCPtr, this, value);
   }
 
+  public void set_has_output_force_magnitude(boolean value) {
+    opensimSimulationJNI.ExpressionBasedCoordinateForce__has_output_force_magnitude_set(swigCPtr, this, value);
+  }
+
+  public boolean get_has_output_force_magnitude() {
+    return opensimSimulationJNI.ExpressionBasedCoordinateForce__has_output_force_magnitude_get(swigCPtr, this);
+  }
+
   /**
    *  Default constructor. *
    */
@@ -173,18 +181,18 @@ public String getCoordinateName() {
    * %Set the mathematical expression that defines the force magnitude of this<br>
    * coordinate force in terms of the coordinate value (q) and its<br>
    * time derivative (qdot). Expressions with C-mathematical operations<br>
-   * such as +,-,*,/ and common functions: exp, pow, sqrt, sin, cos, tan, <br>
+   * such as +,-,*,/ and common functions: exp, pow, sqrt, sin, cos, tan,<br>
    * and so on are acceptable.<br>
    * NOTE: a limitation is that the expression may not contain whitespace<br>
    * @param expression    string containing the mathematical expression that<br>
-   *                      defines the coordinate force 
+   *                      defines the coordinate force
    */
   public void setExpression(String expression) {
     opensimSimulationJNI.ExpressionBasedCoordinateForce_setExpression(swigCPtr, this, expression);
   }
 
   /**
-   * Get the computed Force magnitude determined by evaluating the <br>
+   * Get the computed Force magnitude determined by evaluating the<br>
    * expression above. Note, computeForce must be evaluated first,<br>
    * and this is done automatically if the system is realized to Dynamics<br>
    * @param state    const state (reference) for the model<br>
@@ -194,14 +202,6 @@ public double getForceMagnitude(State state) {
     return opensimSimulationJNI.ExpressionBasedCoordinateForce_getForceMagnitude(swigCPtr, this, State.getCPtr(state), state);
   }
 
-  /**
-   *  Compute the coordinate force based on the user-defined expression <br>
-   *         and apply it to the model 
-   */
-  public void computeForce(State state, VectorOfSpatialVec bodyForces, Vector generalizedForces) {
-    opensimSimulationJNI.ExpressionBasedCoordinateForce_computeForce(swigCPtr, this, State.getCPtr(state), state, VectorOfSpatialVec.getCPtr(bodyForces), bodyForces, Vector.getCPtr(generalizedForces), generalizedForces);
-  }
-
   /**
    *  Force calculation operator. *
    */
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedFunction.java b/Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedFunction.java
new file mode 100644
index 000000000..9f3448a07
--- /dev/null
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedFunction.java
@@ -0,0 +1,216 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (https://www.swig.org).
+ * Version 4.1.1
+ *
+ * Do not make changes to this file unless you know what you are doing - modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+package org.opensim.modeling;
+
+/**
+ * A function based on a user-defined mathematical expression.<br>
+ * <br>
+ * This class allows users to define a function based on a mathematical<br>
+ * expression (e.g., "x*sqrt(y-8)"). The expression can be a function of any <br>
+ * number of independent variables. The expression is parsed and evaluated using <br>
+ * the Lepton library.<br>
+ * <br>
+ * Set the expression using setExpression(). Any variables used in the <br>
+ * expression must be explicitly defined using setVariables(). This <br>
+ * implementation allows computation of first-order derivatives only.<br>
+ * <br>
+ * # Creating Expressions<br>
+ * <br>
+ * Expressions can contain variables, constants, operations, parentheses, commas, <br>
+ * spaces, and scientific "e" notation. The full list of supported operations is: <br>
+ * sqrt, exp, log, sin, cos, sec, csc, tan, cot, asin, acos, atan, sinh, cosh, <br>
+ * tanh, erf, erfc, step, delta, square, cube, recip, min, max, abs, +, -, *, /, <br>
+ * and ^. 
+ */
+public class ExpressionBasedFunction extends Function {
+  private transient long swigCPtr;
+
+  public ExpressionBasedFunction(long cPtr, boolean cMemoryOwn) {
+    super(opensimCommonJNI.ExpressionBasedFunction_SWIGUpcast(cPtr), cMemoryOwn);
+    swigCPtr = cPtr;
+  }
+
+  public static long getCPtr(ExpressionBasedFunction obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+
+  public static long swigRelease(ExpressionBasedFunction obj) {
+    long ptr = 0;
+    if (obj != null) {
+      if (!obj.swigCMemOwn)
+        throw new RuntimeException("Cannot release ownership as memory is not owned");
+      ptr = obj.swigCPtr;
+      obj.swigCMemOwn = false;
+      obj.delete();
+    }
+    return ptr;
+  }
+
+  @SuppressWarnings("deprecation")
+  protected void finalize() {
+    delete();
+  }
+
+  public synchronized void delete() {
+    if (swigCPtr != 0) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        opensimCommonJNI.delete_ExpressionBasedFunction(swigCPtr);
+      }
+      swigCPtr = 0;
+    }
+    super.delete();
+  }
+
+  public static ExpressionBasedFunction safeDownCast(OpenSimObject obj) {
+    long cPtr = opensimCommonJNI.ExpressionBasedFunction_safeDownCast(OpenSimObject.getCPtr(obj), obj);
+    return (cPtr == 0) ? null : new ExpressionBasedFunction(cPtr, false);
+  }
+
+  public void assign(OpenSimObject aObject) {
+    opensimCommonJNI.ExpressionBasedFunction_assign(swigCPtr, this, OpenSimObject.getCPtr(aObject), aObject);
+  }
+
+  public static String getClassName() {
+    return opensimCommonJNI.ExpressionBasedFunction_getClassName();
+  }
+
+  public OpenSimObject clone() {
+    long cPtr = opensimCommonJNI.ExpressionBasedFunction_clone(swigCPtr, this);
+    return (cPtr == 0) ? null : new ExpressionBasedFunction(cPtr, true);
+  }
+
+  public String getConcreteClassName() {
+    return opensimCommonJNI.ExpressionBasedFunction_getConcreteClassName(swigCPtr, this);
+  }
+
+  public void copyProperty_expression(ExpressionBasedFunction source) {
+    opensimCommonJNI.ExpressionBasedFunction_copyProperty_expression(swigCPtr, this, ExpressionBasedFunction.getCPtr(source), source);
+  }
+
+  public String get_expression(int i) {
+    return opensimCommonJNI.ExpressionBasedFunction_get_expression__SWIG_0(swigCPtr, this, i);
+  }
+
+  public SWIGTYPE_p_std__string upd_expression(int i) {
+    return new SWIGTYPE_p_std__string(opensimCommonJNI.ExpressionBasedFunction_upd_expression__SWIG_0(swigCPtr, this, i), false);
+  }
+
+  public void set_expression(int i, String value) {
+    opensimCommonJNI.ExpressionBasedFunction_set_expression__SWIG_0(swigCPtr, this, i, value);
+  }
+
+  public int append_expression(String value) {
+    return opensimCommonJNI.ExpressionBasedFunction_append_expression(swigCPtr, this, value);
+  }
+
+  public void constructProperty_expression(String initValue) {
+    opensimCommonJNI.ExpressionBasedFunction_constructProperty_expression(swigCPtr, this, initValue);
+  }
+
+  public String get_expression() {
+    return opensimCommonJNI.ExpressionBasedFunction_get_expression__SWIG_1(swigCPtr, this);
+  }
+
+  public SWIGTYPE_p_std__string upd_expression() {
+    return new SWIGTYPE_p_std__string(opensimCommonJNI.ExpressionBasedFunction_upd_expression__SWIG_1(swigCPtr, this), false);
+  }
+
+  public void set_expression(String value) {
+    opensimCommonJNI.ExpressionBasedFunction_set_expression__SWIG_1(swigCPtr, this, value);
+  }
+
+  public void copyProperty_variables(ExpressionBasedFunction source) {
+    opensimCommonJNI.ExpressionBasedFunction_copyProperty_variables(swigCPtr, this, ExpressionBasedFunction.getCPtr(source), source);
+  }
+
+  public String get_variables(int i) {
+    return opensimCommonJNI.ExpressionBasedFunction_get_variables(swigCPtr, this, i);
+  }
+
+  public SWIGTYPE_p_std__string upd_variables(int i) {
+    return new SWIGTYPE_p_std__string(opensimCommonJNI.ExpressionBasedFunction_upd_variables(swigCPtr, this, i), false);
+  }
+
+  public void set_variables(int i, String value) {
+    opensimCommonJNI.ExpressionBasedFunction_set_variables(swigCPtr, this, i, value);
+  }
+
+  public int append_variables(String value) {
+    return opensimCommonJNI.ExpressionBasedFunction_append_variables(swigCPtr, this, value);
+  }
+
+  public void constructProperty_variables() {
+    opensimCommonJNI.ExpressionBasedFunction_constructProperty_variables(swigCPtr, this);
+  }
+
+  /**
+   *  Default constructor. 
+   */
+  public ExpressionBasedFunction() {
+    this(opensimCommonJNI.new_ExpressionBasedFunction__SWIG_0(), true);
+  }
+
+  /**
+   *  Convenience constructor.<br>
+   * <br>
+   * @param expression The expression that defines this Function.<br>
+   * @param variables The independent variable names of this expression.
+   */
+  public ExpressionBasedFunction(String expression, StdVectorString variables) {
+    this(opensimCommonJNI.new_ExpressionBasedFunction__SWIG_1(expression, StdVectorString.getCPtr(variables), variables), true);
+  }
+
+  /**
+   * The mathematical expression that defines this Function. The expression <br>
+   * should be a function of the variables defined via setVariables().<br>
+   * <br>
+   * Note: The expression cannot contain any whitespace characters.
+   */
+  public void setExpression(String expression) {
+    opensimCommonJNI.ExpressionBasedFunction_setExpression(swigCPtr, this, expression);
+  }
+
+  /**
+   *  
+   */
+  public String getExpression() {
+    return opensimCommonJNI.ExpressionBasedFunction_getExpression(swigCPtr, this);
+  }
+
+  /**
+   * The independent variable names of this expression. The variables names <br>
+   * should be unique and should be comprised of alphabetic characters or any <br>
+   * characters not reserved by Lepton (i.e., +, -, *, /, and ^). Variable<br>
+   * names can contain numbers as long they do not come first in the name<br>
+   * (e.g., "var0"). The input vector passed to calcValue() and <br>
+   * calcDerivative() should be in the same order as the variables defined<br>
+   * here.
+   */
+  public void setVariables(StdVectorString variables) {
+    opensimCommonJNI.ExpressionBasedFunction_setVariables(swigCPtr, this, StdVectorString.getCPtr(variables), variables);
+  }
+
+  /**
+   *  
+   */
+  public StdVectorString getVariables() {
+    return new StdVectorString(opensimCommonJNI.ExpressionBasedFunction_getVariables(swigCPtr, this), true);
+  }
+
+  /**
+   * Return a pointer to a SimTK::Function object that implements this<br>
+   * function.
+   */
+  public SWIGTYPE_p_SimTK__Function createSimTKFunction() {
+    long cPtr = opensimCommonJNI.ExpressionBasedFunction_createSimTKFunction(swigCPtr, this);
+    return (cPtr == 0) ? null : new SWIGTYPE_p_SimTK__Function(cPtr, false);
+  }
+
+}
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedPointToPointForce.java b/Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedPointToPointForce.java
index b8689239f..05a1f5ab5 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedPointToPointForce.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/ExpressionBasedPointToPointForce.java
@@ -26,7 +26,7 @@
  * <br>
  * @author Ajay Seth
  */
-public class ExpressionBasedPointToPointForce extends Force {
+public class ExpressionBasedPointToPointForce extends ForceProducer {
   private transient long swigCPtr;
 
   public ExpressionBasedPointToPointForce(long cPtr, boolean cMemoryOwn) {
@@ -276,6 +276,14 @@ public void set_expression(String value) {
     opensimSimulationJNI.ExpressionBasedPointToPointForce_set_expression__SWIG_1(swigCPtr, this, value);
   }
 
+  public void set_has_output_force_magnitude(boolean value) {
+    opensimSimulationJNI.ExpressionBasedPointToPointForce__has_output_force_magnitude_set(swigCPtr, this, value);
+  }
+
+  public boolean get_has_output_force_magnitude() {
+    return opensimSimulationJNI.ExpressionBasedPointToPointForce__has_output_force_magnitude_get(swigCPtr, this);
+  }
+
   /**
    *  Default constructor. *
    */
@@ -358,14 +366,6 @@ public double getForceMagnitude(State state) {
     return opensimSimulationJNI.ExpressionBasedPointToPointForce_getForceMagnitude(swigCPtr, this, State.getCPtr(state), state);
   }
 
-  /**
-   *  Compute the point-to-point force based on the user-defined expression <br>
-   *         and apply it to the model 
-   */
-  public void computeForce(State state, VectorOfSpatialVec bodyForces, Vector generalizedForces) {
-    opensimSimulationJNI.ExpressionBasedPointToPointForce_computeForce(swigCPtr, this, State.getCPtr(state), state, VectorOfSpatialVec.getCPtr(bodyForces), bodyForces, Vector.getCPtr(generalizedForces), generalizedForces);
-  }
-
   /**
    * Provide name(s) of the quantities (column labels) of the force value(s) to be reported
    */
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/ExternalForce.java b/Gui/opensim/modeling/src/org/opensim/modeling/ExternalForce.java
index 3ecb4dbc1..44047c73f 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/ExternalForce.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/ExternalForce.java
@@ -29,7 +29,7 @@
  * <br>
  * @author Ajay Seth
  */
-public class ExternalForce extends Force {
+public class ExternalForce extends ForceProducer {
   private transient long swigCPtr;
 
   public ExternalForce(long cPtr, boolean cMemoryOwn) {
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/ForceProducer.java b/Gui/opensim/modeling/src/org/opensim/modeling/ForceProducer.java
new file mode 100644
index 000000000..522bf2dda
--- /dev/null
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/ForceProducer.java
@@ -0,0 +1,113 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (https://www.swig.org).
+ * Version 4.1.1
+ *
+ * Do not make changes to this file unless you know what you are doing - modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+package org.opensim.modeling;
+
+/**
+ * A `ForceProducer` is an abstract `OpenSim::Force` that can emit (produce)<br>
+ * its forces one-by-one into a virtual `OpenSim::ForceConsumer`.<br>
+ * <br>
+ * The benefit of this is that it enables arbitrary external code to directly<br>
+ * introspect each force before it gets resolved to the underlying body-/generalized-force<br>
+ * vector that `OpenSim::Force::computeForce` manipulates. This can be useful for<br>
+ * visualizing/dumping user data (e.g. because user-written `OpenSim::ExternalForce`s<br>
+ * produce point-forces) or debugging (because it's easier to debug forces if they<br>
+ * come one-at-a-time rather than trying to figure out which parts of downstream code<br>
+ * touched which parts of a `SimTK::Vector_&lt;SimTK::SpatialVec&gt;` during<br>
+ * `OpenSim::Force::computeForce`).
+ */
+public class ForceProducer extends Force {
+  private transient long swigCPtr;
+
+  public ForceProducer(long cPtr, boolean cMemoryOwn) {
+    super(opensimSimulationJNI.ForceProducer_SWIGUpcast(cPtr), cMemoryOwn);
+    swigCPtr = cPtr;
+  }
+
+  public static long getCPtr(ForceProducer obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+
+  public static long swigRelease(ForceProducer obj) {
+    long ptr = 0;
+    if (obj != null) {
+      if (!obj.swigCMemOwn)
+        throw new RuntimeException("Cannot release ownership as memory is not owned");
+      ptr = obj.swigCPtr;
+      obj.swigCMemOwn = false;
+      obj.delete();
+    }
+    return ptr;
+  }
+
+  @SuppressWarnings("deprecation")
+  protected void finalize() {
+    delete();
+  }
+
+  public synchronized void delete() {
+    if (swigCPtr != 0) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        opensimSimulationJNI.delete_ForceProducer(swigCPtr);
+      }
+      swigCPtr = 0;
+    }
+    super.delete();
+  }
+
+  public static ForceProducer safeDownCast(OpenSimObject obj) {
+    long cPtr = opensimSimulationJNI.ForceProducer_safeDownCast(OpenSimObject.getCPtr(obj), obj);
+    return (cPtr == 0) ? null : new ForceProducer(cPtr, false);
+  }
+
+  public void assign(OpenSimObject aObject) {
+    opensimSimulationJNI.ForceProducer_assign(swigCPtr, this, OpenSimObject.getCPtr(aObject), aObject);
+  }
+
+  public static String getClassName() {
+    return opensimSimulationJNI.ForceProducer_getClassName();
+  }
+
+  public OpenSimObject clone() {
+    long cPtr = opensimSimulationJNI.ForceProducer_clone(swigCPtr, this);
+    return (cPtr == 0) ? null : new ForceProducer(cPtr, true);
+  }
+
+  public String getConcreteClassName() {
+    return opensimSimulationJNI.ForceProducer_getConcreteClassName(swigCPtr, this);
+  }
+
+  /**
+   * Uses `implProduceForces` to produce (emit) forces evaluated from `state` into the<br>
+   * provided `ForceConsumer`.<br>
+   * <br>
+   * Note: this function only produces the forces and does not apply them to anything. It's<br>
+   *       up to the `ForceConsumer` implementation to handle the forces. Therefore,<br>
+   *       `Force::appliesForces` is ignored by this method.<br>
+   * <br>
+   * @param state       the state used to evaluate forces<br>
+   * 
+   */
+  public void produceForces(State state, SWIGTYPE_p_OpenSim__ForceConsumer forceConsumer) {
+    opensimSimulationJNI.ForceProducer_produceForces(swigCPtr, this, State.getCPtr(state), state, SWIGTYPE_p_OpenSim__ForceConsumer.getCPtr(forceConsumer));
+  }
+
+  /**
+   * Inhereted from `OpenSim::Force`.<br>
+   * <br>
+   * `ForceProducer` overrides `OpenSim::Force::computeForce` with a default<br>
+   * implementation that, provided `OpenSim::Force::appliesForces` is `true`,<br>
+   * internally uses `produceForces` to mutate the provided `bodyForces` in a<br>
+   * manner that's compatible with the `OpenSim::Force` API.
+   */
+  public void computeForce(State state, VectorOfSpatialVec bodyForces, Vector generalizedForces) {
+    opensimSimulationJNI.ForceProducer_computeForce(swigCPtr, this, State.getCPtr(state), state, VectorOfSpatialVec.getCPtr(bodyForces), bodyForces, Vector.getCPtr(generalizedForces), generalizedForces);
+  }
+
+}
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/FrameIterator.java b/Gui/opensim/modeling/src/org/opensim/modeling/FrameIterator.java
index 51833bf17..a0d2f1e11 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/FrameIterator.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/FrameIterator.java
@@ -874,7 +874,11 @@ public AbstractOutput getOutput(String name) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public int getModelingOption(State state, String path) {
-    return opensimSimulationJNI.FrameIterator_getModelingOption(swigCPtr, this, State.getCPtr(state), state, path);
+    return opensimSimulationJNI.FrameIterator_getModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path);
+  }
+
+  public int getModelingOption(State state, ComponentPath path) {
+    return opensimSimulationJNI.FrameIterator_getModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
@@ -903,7 +907,11 @@ public int getModelingOption(State state, String path) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public void setModelingOption(State state, String path, int flag) {
-    opensimSimulationJNI.FrameIterator_setModelingOption(swigCPtr, this, State.getCPtr(state), state, path, flag);
+    opensimSimulationJNI.FrameIterator_setModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path, flag);
+  }
+
+  public void setModelingOption(State state, ComponentPath path, int flag) {
+    opensimSimulationJNI.FrameIterator_setModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path, flag);
   }
 
   /**
@@ -937,7 +945,7 @@ public double getStateVariableValue(State state, String name) {
    }<br>
    * <br>
    * @param state   the State for which to get the value<br>
-   * <br>
+   * @param path    path to the state variable of interest<br>
    * @throws ComponentHasNoSystem if this Component has not been added to a<br>
    *         System (i.e., if initSystem has not been called)
    */
@@ -1002,7 +1010,19 @@ public void setStateVariableValues(State state, Vector values) {
    *         System (i.e., if initSystem has not been called)
    */
   public double getStateVariableDerivativeValue(State state, String name) {
-    return opensimSimulationJNI.FrameIterator_getStateVariableDerivativeValue(swigCPtr, this, State.getCPtr(state), state, name);
+    return opensimSimulationJNI.FrameIterator_getStateVariableDerivativeValue__SWIG_0(swigCPtr, this, State.getCPtr(state), state, name);
+  }
+
+  /**
+   * Get the value of a state variable derivative computed by this Component.<br>
+   * <br>
+   * @param state   the State for which to get the derivative value<br>
+   * @param path    path to the state variable of interest<br>
+   * @throws ComponentHasNoSystem if this Component has not been added to a<br>
+   *         System (i.e., if initSystem has not been called)
+   */
+  public double getStateVariableDerivativeValue(State state, ComponentPath path) {
+    return opensimSimulationJNI.FrameIterator_getStateVariableDerivativeValue__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/FrameList.java b/Gui/opensim/modeling/src/org/opensim/modeling/FrameList.java
index 94d4f9c56..70b13ceb3 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/FrameList.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/FrameList.java
@@ -60,8 +60,7 @@ public FrameList(Component root, ComponentFilter f) {
 
   /**
    *  Constructor that takes only a Component to iterate over (itself and its<br>
-   *     descendants). ComponentFilterMatchAll is used internally. You can<br>
-   *     change the filter using setFilter() method. 
+   *     descendants). You can change the filter using setFilter() method.
    */
   public FrameList(Component root) {
     this(opensimSimulationJNI.new_FrameList__SWIG_1(Component.getCPtr(root), root), true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/FunctionBasedBushingForce.java b/Gui/opensim/modeling/src/org/opensim/modeling/FunctionBasedBushingForce.java
index 7743ccedb..f40e04d45 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/FunctionBasedBushingForce.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/FunctionBasedBushingForce.java
@@ -22,7 +22,7 @@
  * <br>
  * @author Matt DeMers
  */
-public class FunctionBasedBushingForce extends TwoFrameLinkerForce {
+public class FunctionBasedBushingForce extends TwoFrameLinkerForceProducer {
   private transient long swigCPtr;
 
   public FunctionBasedBushingForce(long cPtr, boolean cMemoryOwn) {
@@ -608,14 +608,6 @@ public Vec6 calcDampingForce(State state) {
     return new Vec6(opensimSimulationJNI.FunctionBasedBushingForce_calcDampingForce(swigCPtr, this, State.getCPtr(state), state), true);
   }
 
-  /**
-   *  Compute the bushing force contribution to the system and add in to appropriate<br>
-   * bodyForce and/or system generalizedForce. 
-   */
-  public void computeForce(State s, VectorOfSpatialVec bodyForces, Vector generalizedForces) {
-    opensimSimulationJNI.FunctionBasedBushingForce_computeForce(swigCPtr, this, State.getCPtr(s), s, VectorOfSpatialVec.getCPtr(bodyForces), bodyForces, Vector.getCPtr(generalizedForces), generalizedForces);
-  }
-
   /**
    * Provide name(s) of the quantities (column labels) of the force value(s) <br>
    * to be reported.
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/FunctionBasedPath.java b/Gui/opensim/modeling/src/org/opensim/modeling/FunctionBasedPath.java
index 3f57ca7e3..f86ba1c07 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/FunctionBasedPath.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/FunctionBasedPath.java
@@ -365,8 +365,8 @@ public double computeMomentArm(State s, Coordinate coord) {
     return opensimSimulationJNI.FunctionBasedPath_computeMomentArm(swigCPtr, this, State.getCPtr(s), s, Coordinate.getCPtr(coord), coord);
   }
 
-  public void addInEquivalentForces(State state, double tension, VectorOfSpatialVec bodyForces, Vector mobilityForces) {
-    opensimSimulationJNI.FunctionBasedPath_addInEquivalentForces(swigCPtr, this, State.getCPtr(state), state, tension, VectorOfSpatialVec.getCPtr(bodyForces), bodyForces, Vector.getCPtr(mobilityForces), mobilityForces);
+  public void produceForces(State arg0, double tension, SWIGTYPE_p_OpenSim__ForceConsumer arg2) {
+    opensimSimulationJNI.FunctionBasedPath_produceForces(swigCPtr, this, State.getCPtr(arg0), arg0, tension, SWIGTYPE_p_OpenSim__ForceConsumer.getCPtr(arg2));
   }
 
   public boolean isVisualPath() {
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/GeometryPath.java b/Gui/opensim/modeling/src/org/opensim/modeling/GeometryPath.java
index 73251372f..23ae26adc 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/GeometryPath.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/GeometryPath.java
@@ -186,15 +186,15 @@ public void getPointForceDirections(State s, ArrayPointForceDirection rPFDs) {
   }
 
   /**
-   *  add in the equivalent body and generalized forces to be applied to the <br>
-   *         multibody system resulting from a tension along the GeometryPath <br>
-   *     @param state    state used to evaluate forces<br>
-   *     @param tension      scalar (double) of the applied (+ve) tensile force <br>
-   *     @param bodyForces   Vector of SpatialVec's (torque, force) on bodies<br>
-   *     @param mobilityForces  Vector of generalized forces, one per mobility   
+   * Requests forces resulting from applying a tension along its path and<br>
+   * emits them into the supplied `ForceConsumer`.<br>
+   * <br>
+   * @param state         the state used to evaluate forces<br>
+   * @param tension       scalar of the applied (+ve) tensile force<br>
+   * @param forceConsumer a `ForceConsumer` shall receive each produced force
    */
-  public void addInEquivalentForces(State state, double tension, VectorOfSpatialVec bodyForces, Vector mobilityForces) {
-    opensimSimulationJNI.GeometryPath_addInEquivalentForces(swigCPtr, this, State.getCPtr(state), state, tension, VectorOfSpatialVec.getCPtr(bodyForces), bodyForces, Vector.getCPtr(mobilityForces), mobilityForces);
+  public void produceForces(State state, double tension, SWIGTYPE_p_OpenSim__ForceConsumer forceConsumer) {
+    opensimSimulationJNI.GeometryPath_produceForces(swigCPtr, this, State.getCPtr(state), state, tension, SWIGTYPE_p_OpenSim__ForceConsumer.getCPtr(forceConsumer));
   }
 
   public boolean isVisualPath() {
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/InputController.java b/Gui/opensim/modeling/src/org/opensim/modeling/InputController.java
new file mode 100644
index 000000000..0556f4c8a
--- /dev/null
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/InputController.java
@@ -0,0 +1,206 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (https://www.swig.org).
+ * Version 4.1.1
+ *
+ * Do not make changes to this file unless you know what you are doing - modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+package org.opensim.modeling;
+
+/**
+ * InputController is a simple intermediate abstract class for a Controller that<br>
+ * computes controls based on scalar values defined via a list Input.<br>
+ * <br>
+ * Concrete implementations of InputController must provide a relevant <br>
+ * implementation for the computeControlsImpl() method. This method is called by<br>
+ * computeControls() only if the InputController has the correct number of <br>
+ * connected Input controls. Otherwise, computeControls() does modify the<br>
+ * model controls vector. It is up to each concrete implementation class to <br>
+ * define how the scalar values from the list Input are mapped to the controls <br>
+ * for the actuators in the controller's ActuatorSet. Additionally, concrete <br>
+ * implementations must implement getInputControlLabels() to provide a vector of<br>
+ * labels denoting the order and length of the scalar Input values expected by <br>
+ * the controller. These labels may be useful in simulation tools (e.g., Moco)<br>
+ * to make connections between control signals from other sources <br>
+ * (e.g., ControlDistributor) and the Input controls of the controller.<br>
+ * <br>
+ * InputController provides convenience methods for getting the names and<br>
+ * indexes of the controls for the actuators in the controller's ActuatorSet.<br>
+ * Non-scalar actuators will have multiple controls, and therefore have multiple<br>
+ * control names and indexes. Control information is only available after <br>
+ * calling Model::finalizeConnections().<br>
+ * <br>
+ * Actuator control names and indexes are based on the convention used by the<br>
+ * utility function SimulationUtilities::createControlNamesFromModel(), which<br>
+ * returns control names and indexes based on the order of the actuators stored<br>
+ * in the model. However, we do not check if the order of the actuators stored<br>
+ * in the model matches the order of the controls in the underlying system. Use<br>
+ * the utility function SimulationUtilities::checkOrderSystemControls() to<br>
+ * perform this check when using this controller.
+ */
+public class InputController extends Controller {
+  private transient long swigCPtr;
+
+  public InputController(long cPtr, boolean cMemoryOwn) {
+    super(opensimSimulationJNI.InputController_SWIGUpcast(cPtr), cMemoryOwn);
+    swigCPtr = cPtr;
+  }
+
+  public static long getCPtr(InputController obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+
+  public static long swigRelease(InputController obj) {
+    long ptr = 0;
+    if (obj != null) {
+      if (!obj.swigCMemOwn)
+        throw new RuntimeException("Cannot release ownership as memory is not owned");
+      ptr = obj.swigCPtr;
+      obj.swigCMemOwn = false;
+      obj.delete();
+    }
+    return ptr;
+  }
+
+  @SuppressWarnings("deprecation")
+  protected void finalize() {
+    delete();
+  }
+
+  public synchronized void delete() {
+    if (swigCPtr != 0) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        opensimSimulationJNI.delete_InputController(swigCPtr);
+      }
+      swigCPtr = 0;
+    }
+    super.delete();
+  }
+
+  public static InputController safeDownCast(OpenSimObject obj) {
+    long cPtr = opensimSimulationJNI.InputController_safeDownCast(OpenSimObject.getCPtr(obj), obj);
+    return (cPtr == 0) ? null : new InputController(cPtr, false);
+  }
+
+  public void assign(OpenSimObject aObject) {
+    opensimSimulationJNI.InputController_assign(swigCPtr, this, OpenSimObject.getCPtr(aObject), aObject);
+  }
+
+  public static String getClassName() {
+    return opensimSimulationJNI.InputController_getClassName();
+  }
+
+  public OpenSimObject clone() {
+    long cPtr = opensimSimulationJNI.InputController_clone(swigCPtr, this);
+    return (cPtr == 0) ? null : new InputController(cPtr, true);
+  }
+
+  public String getConcreteClassName() {
+    return opensimSimulationJNI.InputController_getConcreteClassName(swigCPtr, this);
+  }
+
+  public void setPropertyIndex_input_controls(SWIGTYPE_p_OpenSim__PropertyIndex value) {
+    opensimSimulationJNI.InputController_PropertyIndex_input_controls_set(swigCPtr, this, SWIGTYPE_p_OpenSim__PropertyIndex.getCPtr(value));
+  }
+
+  public SWIGTYPE_p_OpenSim__PropertyIndex getPropertyIndex_input_controls() {
+    return new SWIGTYPE_p_OpenSim__PropertyIndex(opensimSimulationJNI.InputController_PropertyIndex_input_controls_get(swigCPtr, this), true);
+  }
+
+  public void connectInput_controls(AbstractOutput output, String alias) {
+    opensimSimulationJNI.InputController_connectInput_controls__SWIG_0(swigCPtr, this, AbstractOutput.getCPtr(output), output, alias);
+  }
+
+  public void connectInput_controls(AbstractOutput output) {
+    opensimSimulationJNI.InputController_connectInput_controls__SWIG_1(swigCPtr, this, AbstractOutput.getCPtr(output), output);
+  }
+
+  public void connectInput_controls(AbstractChannel channel, String alias) {
+    opensimSimulationJNI.InputController_connectInput_controls__SWIG_2(swigCPtr, this, AbstractChannel.getCPtr(channel), channel, alias);
+  }
+
+  public void connectInput_controls(AbstractChannel channel) {
+    opensimSimulationJNI.InputController_connectInput_controls__SWIG_3(swigCPtr, this, AbstractChannel.getCPtr(channel), channel);
+  }
+
+  /**
+   * Get the vector of labels for the Input controls expected by the<br>
+   * controller.<br>
+   * <br>
+   * The connected Input controls must match the length and order of the <br>
+   * labels returned by this method. These labels may be useful in simulation<br>
+   * tools (e.g., Moco) for mapping control signals from another source to <br>
+   * the Input controls of the controller.
+   */
+  public StdVectorString getInputControlLabels() {
+    return new StdVectorString(opensimSimulationJNI.InputController_getInputControlLabels(swigCPtr, this), true);
+  }
+
+  /**
+   * Compute the controls for the actuators in the controller's ActuatorSet<br>
+   * based on the scalar values provided by the Input controls.<br>
+   * <br>
+   * This method is only called by computeControls() if the InputController<br>
+   * has the correct number of connected Input controls. Concrete <br>
+   * implementations of this class must provide a relevant implementation.
+   */
+  public void computeControlsImpl(State state, Vector controls) {
+    opensimSimulationJNI.InputController_computeControlsImpl(swigCPtr, this, State.getCPtr(state), state, Vector.getCPtr(controls), controls);
+  }
+
+  public void computeControls(State state, Vector controls) {
+    opensimSimulationJNI.InputController_computeControls(swigCPtr, this, State.getCPtr(state), state, Vector.getCPtr(controls), controls);
+  }
+
+  /**
+   * Get the number of Input controls expected by the controller.
+   */
+  public int getNumInputControls() {
+    return opensimSimulationJNI.InputController_getNumInputControls(swigCPtr, this);
+  }
+
+  /**
+   * Get the names of the controls for the actuators in the controller's<br>
+   * ActuatorSet.<br>
+   * <br>
+   * For scalar actuators, these names are simply the paths of<br>
+   * the actuators in the model. For non-scalar actuators, these names are<br>
+   * actuator path plus an additional suffix representing the index of the<br>
+   * control in the actuator's control vector (e.g., "/actuator_0").<br>
+   * <br>
+   * Note: Only valid after actuators are connected and<br>
+   *       Model::finalizeConnections() has been called.<br>
+   * <br>
+   * Note: This does *not* check if the order of the actuators stored in the<br>
+   *       model matches the order of the controls in the underlying system.<br>
+   *       Use SimulationUtilities::checkOrderSystemControls() to perform<br>
+   *       this check.
+   */
+  public StdVectorString getControlNames() {
+    return new StdVectorString(opensimSimulationJNI.InputController_getControlNames(swigCPtr, this), false);
+  }
+
+  /**
+   * Get the model control indexes for the controls associated with the<br>
+   * actuators in the controller's ActuatorSet.<br>
+   * <br>
+   * The control indexes are based on the order of the actuators stored in the<br>
+   * model. Non-scalar actuators will have multiple controls, and therefore<br>
+   * have multiple control indexes. The order of the returned indexes matches<br>
+   * the order of the control names returned by getControlNames().<br>
+   * <br>
+   * Note: Only valid after actuators are connected and<br>
+   *       Model::finalizeConnections() has been called.<br>
+   * <br>
+   * Note: This does *not* check if the order of the actuators stored in the<br>
+   *       model matches the order of the controls in the underlying system.<br>
+   *       Use SimulationUtilities::checkOrderSystemControls() to perform<br>
+   *       this check.
+   */
+  public StdVectorInt getControlIndexes() {
+    return new StdVectorInt(opensimSimulationJNI.InputController_getControlIndexes(swigCPtr, this), false);
+  }
+
+}
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/InvalidIndices.java b/Gui/opensim/modeling/src/org/opensim/modeling/InvalidIndices.java
new file mode 100644
index 000000000..6bc16e949
--- /dev/null
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/InvalidIndices.java
@@ -0,0 +1,55 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (https://www.swig.org).
+ * Version 4.1.1
+ *
+ * Do not make changes to this file unless you know what you are doing - modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+package org.opensim.modeling;
+
+public class InvalidIndices extends OpenSimException {
+  private transient long swigCPtr;
+
+  public InvalidIndices(long cPtr, boolean cMemoryOwn) {
+    super(opensimCommonJNI.InvalidIndices_SWIGUpcast(cPtr), cMemoryOwn);
+    swigCPtr = cPtr;
+  }
+
+  public static long getCPtr(InvalidIndices obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+
+  public static long swigRelease(InvalidIndices obj) {
+    long ptr = 0;
+    if (obj != null) {
+      if (!obj.swigCMemOwn)
+        throw new RuntimeException("Cannot release ownership as memory is not owned");
+      ptr = obj.swigCPtr;
+      obj.swigCMemOwn = false;
+      obj.delete();
+    }
+    return ptr;
+  }
+
+  @SuppressWarnings("deprecation")
+  protected void finalize() {
+    delete();
+  }
+
+  public synchronized void delete() {
+    if (swigCPtr != 0) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        opensimCommonJNI.delete_InvalidIndices(swigCPtr);
+      }
+      swigCPtr = 0;
+    }
+    super.delete();
+  }
+
+  public InvalidIndices(String file, long line, String func, long index, long min, long max) {
+    this(opensimCommonJNI.new_InvalidIndices(file, line, func, index, min, max), true);
+  }
+
+}
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/JointIterator.java b/Gui/opensim/modeling/src/org/opensim/modeling/JointIterator.java
index 6f7260825..ff9dd7978 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/JointIterator.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/JointIterator.java
@@ -722,7 +722,11 @@ public AbstractOutput getOutput(String name) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public int getModelingOption(State state, String path) {
-    return opensimSimulationJNI.JointIterator_getModelingOption(swigCPtr, this, State.getCPtr(state), state, path);
+    return opensimSimulationJNI.JointIterator_getModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path);
+  }
+
+  public int getModelingOption(State state, ComponentPath path) {
+    return opensimSimulationJNI.JointIterator_getModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
@@ -751,7 +755,11 @@ public int getModelingOption(State state, String path) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public void setModelingOption(State state, String path, int flag) {
-    opensimSimulationJNI.JointIterator_setModelingOption(swigCPtr, this, State.getCPtr(state), state, path, flag);
+    opensimSimulationJNI.JointIterator_setModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path, flag);
+  }
+
+  public void setModelingOption(State state, ComponentPath path, int flag) {
+    opensimSimulationJNI.JointIterator_setModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path, flag);
   }
 
   /**
@@ -785,7 +793,7 @@ public double getStateVariableValue(State state, String name) {
    }<br>
    * <br>
    * @param state   the State for which to get the value<br>
-   * <br>
+   * @param path    path to the state variable of interest<br>
    * @throws ComponentHasNoSystem if this Component has not been added to a<br>
    *         System (i.e., if initSystem has not been called)
    */
@@ -850,7 +858,19 @@ public void setStateVariableValues(State state, Vector values) {
    *         System (i.e., if initSystem has not been called)
    */
   public double getStateVariableDerivativeValue(State state, String name) {
-    return opensimSimulationJNI.JointIterator_getStateVariableDerivativeValue(swigCPtr, this, State.getCPtr(state), state, name);
+    return opensimSimulationJNI.JointIterator_getStateVariableDerivativeValue__SWIG_0(swigCPtr, this, State.getCPtr(state), state, name);
+  }
+
+  /**
+   * Get the value of a state variable derivative computed by this Component.<br>
+   * <br>
+   * @param state   the State for which to get the derivative value<br>
+   * @param path    path to the state variable of interest<br>
+   * @throws ComponentHasNoSystem if this Component has not been added to a<br>
+   *         System (i.e., if initSystem has not been called)
+   */
+  public double getStateVariableDerivativeValue(State state, ComponentPath path) {
+    return opensimSimulationJNI.JointIterator_getStateVariableDerivativeValue__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/JointList.java b/Gui/opensim/modeling/src/org/opensim/modeling/JointList.java
index 9c2289dad..465e9d280 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/JointList.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/JointList.java
@@ -60,8 +60,7 @@ public JointList(Component root, ComponentFilter f) {
 
   /**
    *  Constructor that takes only a Component to iterate over (itself and its<br>
-   *     descendants). ComponentFilterMatchAll is used internally. You can<br>
-   *     change the filter using setFilter() method. 
+   *     descendants). You can change the filter using setFilter() method.
    */
   public JointList(Component root) {
     this(opensimSimulationJNI.new_JointList__SWIG_1(Component.getCPtr(root), root), true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/Ligament.java b/Gui/opensim/modeling/src/org/opensim/modeling/Ligament.java
index c38be35d1..18840e96e 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/Ligament.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/Ligament.java
@@ -12,7 +12,7 @@
  * A class implementing a ligament. The path of the ligament is<br>
  * stored in an object derived from AbstractGeometryPath.
  */
-public class Ligament extends Force {
+public class Ligament extends ForceProducer {
   private transient long swigCPtr;
 
   public Ligament(long cPtr, boolean cMemoryOwn) {
@@ -278,10 +278,6 @@ public double computeMomentArm(State s, Coordinate aCoord) {
     return opensimSimulationJNI.Ligament_computeMomentArm(swigCPtr, this, State.getCPtr(s), s, Coordinate.getCPtr(aCoord), aCoord);
   }
 
-  public void computeForce(State s, VectorOfSpatialVec bodyForces, Vector generalizedForces) {
-    opensimSimulationJNI.Ligament_computeForce(swigCPtr, this, State.getCPtr(s), s, VectorOfSpatialVec.getCPtr(bodyForces), bodyForces, Vector.getCPtr(generalizedForces), generalizedForces);
-  }
-
   /**
    *  Adjust the resting length of the ligament after the model has been<br>
    *         scaled. The `resting_length` property is multiplied by the quotient of<br>
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/Millard2012EquilibriumMuscleIterator.java b/Gui/opensim/modeling/src/org/opensim/modeling/Millard2012EquilibriumMuscleIterator.java
index 19913aaa8..29208dd51 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/Millard2012EquilibriumMuscleIterator.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/Millard2012EquilibriumMuscleIterator.java
@@ -1169,6 +1169,21 @@ public void addInControls(Vector actuatorControls, Vector modelControls) {
     opensimSimulationJNI.Millard2012EquilibriumMuscleIterator_addInControls(swigCPtr, this, Vector.getCPtr(actuatorControls), actuatorControls, Vector.getCPtr(modelControls), modelControls);
   }
 
+  /**
+   * Uses `implProduceForces` to produce (emit) forces evaluated from `state` into the<br>
+   * provided `ForceConsumer`.<br>
+   * <br>
+   * Note: this function only produces the forces and does not apply them to anything. It's<br>
+   *       up to the `ForceConsumer` implementation to handle the forces. Therefore,<br>
+   *       `Force::appliesForces` is ignored by this method.<br>
+   * <br>
+   * @param state       the state used to evaluate forces<br>
+   * 
+   */
+  public void produceForces(State state, SWIGTYPE_p_OpenSim__ForceConsumer forceConsumer) {
+    opensimSimulationJNI.Millard2012EquilibriumMuscleIterator_produceForces(swigCPtr, this, State.getCPtr(state), state, SWIGTYPE_p_OpenSim__ForceConsumer.getCPtr(forceConsumer));
+  }
+
   public boolean get_appliesForce(int i) {
     return opensimSimulationJNI.Millard2012EquilibriumMuscleIterator_get_appliesForce__SWIG_0(swigCPtr, this, i);
   }
@@ -1683,7 +1698,11 @@ public AbstractOutput getOutput(String name) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public int getModelingOption(State state, String path) {
-    return opensimSimulationJNI.Millard2012EquilibriumMuscleIterator_getModelingOption(swigCPtr, this, State.getCPtr(state), state, path);
+    return opensimSimulationJNI.Millard2012EquilibriumMuscleIterator_getModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path);
+  }
+
+  public int getModelingOption(State state, ComponentPath path) {
+    return opensimSimulationJNI.Millard2012EquilibriumMuscleIterator_getModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
@@ -1712,7 +1731,11 @@ public int getModelingOption(State state, String path) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public void setModelingOption(State state, String path, int flag) {
-    opensimSimulationJNI.Millard2012EquilibriumMuscleIterator_setModelingOption(swigCPtr, this, State.getCPtr(state), state, path, flag);
+    opensimSimulationJNI.Millard2012EquilibriumMuscleIterator_setModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path, flag);
+  }
+
+  public void setModelingOption(State state, ComponentPath path, int flag) {
+    opensimSimulationJNI.Millard2012EquilibriumMuscleIterator_setModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path, flag);
   }
 
   /**
@@ -1746,7 +1769,7 @@ public double getStateVariableValue(State state, String name) {
    }<br>
    * <br>
    * @param state   the State for which to get the value<br>
-   * <br>
+   * @param path    path to the state variable of interest<br>
    * @throws ComponentHasNoSystem if this Component has not been added to a<br>
    *         System (i.e., if initSystem has not been called)
    */
@@ -1811,7 +1834,19 @@ public void setStateVariableValues(State state, Vector values) {
    *         System (i.e., if initSystem has not been called)
    */
   public double getStateVariableDerivativeValue(State state, String name) {
-    return opensimSimulationJNI.Millard2012EquilibriumMuscleIterator_getStateVariableDerivativeValue(swigCPtr, this, State.getCPtr(state), state, name);
+    return opensimSimulationJNI.Millard2012EquilibriumMuscleIterator_getStateVariableDerivativeValue__SWIG_0(swigCPtr, this, State.getCPtr(state), state, name);
+  }
+
+  /**
+   * Get the value of a state variable derivative computed by this Component.<br>
+   * <br>
+   * @param state   the State for which to get the derivative value<br>
+   * @param path    path to the state variable of interest<br>
+   * @throws ComponentHasNoSystem if this Component has not been added to a<br>
+   *         System (i.e., if initSystem has not been called)
+   */
+  public double getStateVariableDerivativeValue(State state, ComponentPath path) {
+    return opensimSimulationJNI.Millard2012EquilibriumMuscleIterator_getStateVariableDerivativeValue__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/Millard2012EquilibriumMuscleList.java b/Gui/opensim/modeling/src/org/opensim/modeling/Millard2012EquilibriumMuscleList.java
index 02d39b904..84588c8b6 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/Millard2012EquilibriumMuscleList.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/Millard2012EquilibriumMuscleList.java
@@ -60,8 +60,7 @@ public Millard2012EquilibriumMuscleList(Component root, ComponentFilter f) {
 
   /**
    *  Constructor that takes only a Component to iterate over (itself and its<br>
-   *     descendants). ComponentFilterMatchAll is used internally. You can<br>
-   *     change the filter using setFilter() method. 
+   *     descendants). You can change the filter using setFilter() method.
    */
   public Millard2012EquilibriumMuscleList(Component root) {
     this(opensimSimulationJNI.new_Millard2012EquilibriumMuscleList__SWIG_1(Component.getCPtr(root), root), true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoCasADiSolver.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoCasADiSolver.java
index 94c185c83..370c2df96 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/MocoCasADiSolver.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoCasADiSolver.java
@@ -551,40 +551,148 @@ public void set_implicit_auxiliary_derivatives_weight(double value) {
     opensimMocoJNI.MocoCasADiSolver_set_implicit_auxiliary_derivatives_weight__SWIG_1(swigCPtr, this, value);
   }
 
-  public void copyProperty_enforce_path_constraint_midpoints(MocoCasADiSolver source) {
-    opensimMocoJNI.MocoCasADiSolver_copyProperty_enforce_path_constraint_midpoints(swigCPtr, this, MocoCasADiSolver.getCPtr(source), source);
+  public void copyProperty_enforce_path_constraint_mesh_interior_points(MocoCasADiSolver source) {
+    opensimMocoJNI.MocoCasADiSolver_copyProperty_enforce_path_constraint_mesh_interior_points(swigCPtr, this, MocoCasADiSolver.getCPtr(source), source);
   }
 
-  public boolean get_enforce_path_constraint_midpoints(int i) {
-    return opensimMocoJNI.MocoCasADiSolver_get_enforce_path_constraint_midpoints__SWIG_0(swigCPtr, this, i);
+  public boolean get_enforce_path_constraint_mesh_interior_points(int i) {
+    return opensimMocoJNI.MocoCasADiSolver_get_enforce_path_constraint_mesh_interior_points__SWIG_0(swigCPtr, this, i);
   }
 
-  public SWIGTYPE_p_bool upd_enforce_path_constraint_midpoints(int i) {
-    return new SWIGTYPE_p_bool(opensimMocoJNI.MocoCasADiSolver_upd_enforce_path_constraint_midpoints__SWIG_0(swigCPtr, this, i), false);
+  public SWIGTYPE_p_bool upd_enforce_path_constraint_mesh_interior_points(int i) {
+    return new SWIGTYPE_p_bool(opensimMocoJNI.MocoCasADiSolver_upd_enforce_path_constraint_mesh_interior_points__SWIG_0(swigCPtr, this, i), false);
   }
 
-  public void set_enforce_path_constraint_midpoints(int i, boolean value) {
-    opensimMocoJNI.MocoCasADiSolver_set_enforce_path_constraint_midpoints__SWIG_0(swigCPtr, this, i, value);
+  public void set_enforce_path_constraint_mesh_interior_points(int i, boolean value) {
+    opensimMocoJNI.MocoCasADiSolver_set_enforce_path_constraint_mesh_interior_points__SWIG_0(swigCPtr, this, i, value);
   }
 
-  public int append_enforce_path_constraint_midpoints(boolean value) {
-    return opensimMocoJNI.MocoCasADiSolver_append_enforce_path_constraint_midpoints(swigCPtr, this, value);
+  public int append_enforce_path_constraint_mesh_interior_points(boolean value) {
+    return opensimMocoJNI.MocoCasADiSolver_append_enforce_path_constraint_mesh_interior_points(swigCPtr, this, value);
   }
 
-  public void constructProperty_enforce_path_constraint_midpoints(boolean initValue) {
-    opensimMocoJNI.MocoCasADiSolver_constructProperty_enforce_path_constraint_midpoints(swigCPtr, this, initValue);
+  public void constructProperty_enforce_path_constraint_mesh_interior_points(boolean initValue) {
+    opensimMocoJNI.MocoCasADiSolver_constructProperty_enforce_path_constraint_mesh_interior_points(swigCPtr, this, initValue);
   }
 
-  public boolean get_enforce_path_constraint_midpoints() {
-    return opensimMocoJNI.MocoCasADiSolver_get_enforce_path_constraint_midpoints__SWIG_1(swigCPtr, this);
+  public boolean get_enforce_path_constraint_mesh_interior_points() {
+    return opensimMocoJNI.MocoCasADiSolver_get_enforce_path_constraint_mesh_interior_points__SWIG_1(swigCPtr, this);
   }
 
-  public SWIGTYPE_p_bool upd_enforce_path_constraint_midpoints() {
-    return new SWIGTYPE_p_bool(opensimMocoJNI.MocoCasADiSolver_upd_enforce_path_constraint_midpoints__SWIG_1(swigCPtr, this), false);
+  public SWIGTYPE_p_bool upd_enforce_path_constraint_mesh_interior_points() {
+    return new SWIGTYPE_p_bool(opensimMocoJNI.MocoCasADiSolver_upd_enforce_path_constraint_mesh_interior_points__SWIG_1(swigCPtr, this), false);
   }
 
-  public void set_enforce_path_constraint_midpoints(boolean value) {
-    opensimMocoJNI.MocoCasADiSolver_set_enforce_path_constraint_midpoints__SWIG_1(swigCPtr, this, value);
+  public void set_enforce_path_constraint_mesh_interior_points(boolean value) {
+    opensimMocoJNI.MocoCasADiSolver_set_enforce_path_constraint_mesh_interior_points__SWIG_1(swigCPtr, this, value);
+  }
+
+  public void copyProperty_minimize_state_projection_distance(MocoCasADiSolver source) {
+    opensimMocoJNI.MocoCasADiSolver_copyProperty_minimize_state_projection_distance(swigCPtr, this, MocoCasADiSolver.getCPtr(source), source);
+  }
+
+  public boolean get_minimize_state_projection_distance(int i) {
+    return opensimMocoJNI.MocoCasADiSolver_get_minimize_state_projection_distance__SWIG_0(swigCPtr, this, i);
+  }
+
+  public SWIGTYPE_p_bool upd_minimize_state_projection_distance(int i) {
+    return new SWIGTYPE_p_bool(opensimMocoJNI.MocoCasADiSolver_upd_minimize_state_projection_distance__SWIG_0(swigCPtr, this, i), false);
+  }
+
+  public void set_minimize_state_projection_distance(int i, boolean value) {
+    opensimMocoJNI.MocoCasADiSolver_set_minimize_state_projection_distance__SWIG_0(swigCPtr, this, i, value);
+  }
+
+  public int append_minimize_state_projection_distance(boolean value) {
+    return opensimMocoJNI.MocoCasADiSolver_append_minimize_state_projection_distance(swigCPtr, this, value);
+  }
+
+  public void constructProperty_minimize_state_projection_distance(boolean initValue) {
+    opensimMocoJNI.MocoCasADiSolver_constructProperty_minimize_state_projection_distance(swigCPtr, this, initValue);
+  }
+
+  public boolean get_minimize_state_projection_distance() {
+    return opensimMocoJNI.MocoCasADiSolver_get_minimize_state_projection_distance__SWIG_1(swigCPtr, this);
+  }
+
+  public SWIGTYPE_p_bool upd_minimize_state_projection_distance() {
+    return new SWIGTYPE_p_bool(opensimMocoJNI.MocoCasADiSolver_upd_minimize_state_projection_distance__SWIG_1(swigCPtr, this), false);
+  }
+
+  public void set_minimize_state_projection_distance(boolean value) {
+    opensimMocoJNI.MocoCasADiSolver_set_minimize_state_projection_distance__SWIG_1(swigCPtr, this, value);
+  }
+
+  public void copyProperty_state_projection_distance_weight(MocoCasADiSolver source) {
+    opensimMocoJNI.MocoCasADiSolver_copyProperty_state_projection_distance_weight(swigCPtr, this, MocoCasADiSolver.getCPtr(source), source);
+  }
+
+  public double get_state_projection_distance_weight(int i) {
+    return opensimMocoJNI.MocoCasADiSolver_get_state_projection_distance_weight__SWIG_0(swigCPtr, this, i);
+  }
+
+  public SWIGTYPE_p_double upd_state_projection_distance_weight(int i) {
+    return new SWIGTYPE_p_double(opensimMocoJNI.MocoCasADiSolver_upd_state_projection_distance_weight__SWIG_0(swigCPtr, this, i), false);
+  }
+
+  public void set_state_projection_distance_weight(int i, double value) {
+    opensimMocoJNI.MocoCasADiSolver_set_state_projection_distance_weight__SWIG_0(swigCPtr, this, i, value);
+  }
+
+  public int append_state_projection_distance_weight(double value) {
+    return opensimMocoJNI.MocoCasADiSolver_append_state_projection_distance_weight(swigCPtr, this, value);
+  }
+
+  public void constructProperty_state_projection_distance_weight(double initValue) {
+    opensimMocoJNI.MocoCasADiSolver_constructProperty_state_projection_distance_weight(swigCPtr, this, initValue);
+  }
+
+  public double get_state_projection_distance_weight() {
+    return opensimMocoJNI.MocoCasADiSolver_get_state_projection_distance_weight__SWIG_1(swigCPtr, this);
+  }
+
+  public SWIGTYPE_p_double upd_state_projection_distance_weight() {
+    return new SWIGTYPE_p_double(opensimMocoJNI.MocoCasADiSolver_upd_state_projection_distance_weight__SWIG_1(swigCPtr, this), false);
+  }
+
+  public void set_state_projection_distance_weight(double value) {
+    opensimMocoJNI.MocoCasADiSolver_set_state_projection_distance_weight__SWIG_1(swigCPtr, this, value);
+  }
+
+  public void copyProperty_projection_slack_variable_bounds(MocoCasADiSolver source) {
+    opensimMocoJNI.MocoCasADiSolver_copyProperty_projection_slack_variable_bounds(swigCPtr, this, MocoCasADiSolver.getCPtr(source), source);
+  }
+
+  public MocoBounds get_projection_slack_variable_bounds(int i) {
+    return new MocoBounds(opensimMocoJNI.MocoCasADiSolver_get_projection_slack_variable_bounds__SWIG_0(swigCPtr, this, i), false);
+  }
+
+  public MocoBounds upd_projection_slack_variable_bounds(int i) {
+    return new MocoBounds(opensimMocoJNI.MocoCasADiSolver_upd_projection_slack_variable_bounds__SWIG_0(swigCPtr, this, i), false);
+  }
+
+  public void set_projection_slack_variable_bounds(int i, MocoBounds value) {
+    opensimMocoJNI.MocoCasADiSolver_set_projection_slack_variable_bounds__SWIG_0(swigCPtr, this, i, MocoBounds.getCPtr(value), value);
+  }
+
+  public int append_projection_slack_variable_bounds(MocoBounds value) {
+    return opensimMocoJNI.MocoCasADiSolver_append_projection_slack_variable_bounds(swigCPtr, this, MocoBounds.getCPtr(value), value);
+  }
+
+  public void constructProperty_projection_slack_variable_bounds(MocoBounds initValue) {
+    opensimMocoJNI.MocoCasADiSolver_constructProperty_projection_slack_variable_bounds(swigCPtr, this, MocoBounds.getCPtr(initValue), initValue);
+  }
+
+  public MocoBounds get_projection_slack_variable_bounds() {
+    return new MocoBounds(opensimMocoJNI.MocoCasADiSolver_get_projection_slack_variable_bounds__SWIG_1(swigCPtr, this), false);
+  }
+
+  public MocoBounds upd_projection_slack_variable_bounds() {
+    return new MocoBounds(opensimMocoJNI.MocoCasADiSolver_upd_projection_slack_variable_bounds__SWIG_1(swigCPtr, this), false);
+  }
+
+  public void set_projection_slack_variable_bounds(MocoBounds value) {
+    opensimMocoJNI.MocoCasADiSolver_set_projection_slack_variable_bounds__SWIG_1(swigCPtr, this, MocoBounds.getCPtr(value), value);
   }
 
   public MocoCasADiSolver() {
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoDirectCollocationSolver.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoDirectCollocationSolver.java
index 6560f36f4..1eb70bd87 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/MocoDirectCollocationSolver.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoDirectCollocationSolver.java
@@ -242,40 +242,40 @@ public void set_transcription_scheme(String value) {
     opensimMocoJNI.MocoDirectCollocationSolver_set_transcription_scheme__SWIG_1(swigCPtr, this, value);
   }
 
-  public void copyProperty_interpolate_control_midpoints(MocoDirectCollocationSolver source) {
-    opensimMocoJNI.MocoDirectCollocationSolver_copyProperty_interpolate_control_midpoints(swigCPtr, this, MocoDirectCollocationSolver.getCPtr(source), source);
+  public void copyProperty_interpolate_control_mesh_interior_points(MocoDirectCollocationSolver source) {
+    opensimMocoJNI.MocoDirectCollocationSolver_copyProperty_interpolate_control_mesh_interior_points(swigCPtr, this, MocoDirectCollocationSolver.getCPtr(source), source);
   }
 
-  public boolean get_interpolate_control_midpoints(int i) {
-    return opensimMocoJNI.MocoDirectCollocationSolver_get_interpolate_control_midpoints__SWIG_0(swigCPtr, this, i);
+  public boolean get_interpolate_control_mesh_interior_points(int i) {
+    return opensimMocoJNI.MocoDirectCollocationSolver_get_interpolate_control_mesh_interior_points__SWIG_0(swigCPtr, this, i);
   }
 
-  public SWIGTYPE_p_bool upd_interpolate_control_midpoints(int i) {
-    return new SWIGTYPE_p_bool(opensimMocoJNI.MocoDirectCollocationSolver_upd_interpolate_control_midpoints__SWIG_0(swigCPtr, this, i), false);
+  public SWIGTYPE_p_bool upd_interpolate_control_mesh_interior_points(int i) {
+    return new SWIGTYPE_p_bool(opensimMocoJNI.MocoDirectCollocationSolver_upd_interpolate_control_mesh_interior_points__SWIG_0(swigCPtr, this, i), false);
   }
 
-  public void set_interpolate_control_midpoints(int i, boolean value) {
-    opensimMocoJNI.MocoDirectCollocationSolver_set_interpolate_control_midpoints__SWIG_0(swigCPtr, this, i, value);
+  public void set_interpolate_control_mesh_interior_points(int i, boolean value) {
+    opensimMocoJNI.MocoDirectCollocationSolver_set_interpolate_control_mesh_interior_points__SWIG_0(swigCPtr, this, i, value);
   }
 
-  public int append_interpolate_control_midpoints(boolean value) {
-    return opensimMocoJNI.MocoDirectCollocationSolver_append_interpolate_control_midpoints(swigCPtr, this, value);
+  public int append_interpolate_control_mesh_interior_points(boolean value) {
+    return opensimMocoJNI.MocoDirectCollocationSolver_append_interpolate_control_mesh_interior_points(swigCPtr, this, value);
   }
 
-  public void constructProperty_interpolate_control_midpoints(boolean initValue) {
-    opensimMocoJNI.MocoDirectCollocationSolver_constructProperty_interpolate_control_midpoints(swigCPtr, this, initValue);
+  public void constructProperty_interpolate_control_mesh_interior_points(boolean initValue) {
+    opensimMocoJNI.MocoDirectCollocationSolver_constructProperty_interpolate_control_mesh_interior_points(swigCPtr, this, initValue);
   }
 
-  public boolean get_interpolate_control_midpoints() {
-    return opensimMocoJNI.MocoDirectCollocationSolver_get_interpolate_control_midpoints__SWIG_1(swigCPtr, this);
+  public boolean get_interpolate_control_mesh_interior_points() {
+    return opensimMocoJNI.MocoDirectCollocationSolver_get_interpolate_control_mesh_interior_points__SWIG_1(swigCPtr, this);
   }
 
-  public SWIGTYPE_p_bool upd_interpolate_control_midpoints() {
-    return new SWIGTYPE_p_bool(opensimMocoJNI.MocoDirectCollocationSolver_upd_interpolate_control_midpoints__SWIG_1(swigCPtr, this), false);
+  public SWIGTYPE_p_bool upd_interpolate_control_mesh_interior_points() {
+    return new SWIGTYPE_p_bool(opensimMocoJNI.MocoDirectCollocationSolver_upd_interpolate_control_mesh_interior_points__SWIG_1(swigCPtr, this), false);
   }
 
-  public void set_interpolate_control_midpoints(boolean value) {
-    opensimMocoJNI.MocoDirectCollocationSolver_set_interpolate_control_midpoints__SWIG_1(swigCPtr, this, value);
+  public void set_interpolate_control_mesh_interior_points(boolean value) {
+    opensimMocoJNI.MocoDirectCollocationSolver_set_interpolate_control_mesh_interior_points__SWIG_1(swigCPtr, this, value);
   }
 
   public void copyProperty_multibody_dynamics_mode(MocoDirectCollocationSolver source) {
@@ -750,6 +750,42 @@ public void set_implicit_auxiliary_derivative_bounds(MocoBounds value) {
     opensimMocoJNI.MocoDirectCollocationSolver_set_implicit_auxiliary_derivative_bounds__SWIG_1(swigCPtr, this, MocoBounds.getCPtr(value), value);
   }
 
+  public void copyProperty_kinematic_constraint_method(MocoDirectCollocationSolver source) {
+    opensimMocoJNI.MocoDirectCollocationSolver_copyProperty_kinematic_constraint_method(swigCPtr, this, MocoDirectCollocationSolver.getCPtr(source), source);
+  }
+
+  public String get_kinematic_constraint_method(int i) {
+    return opensimMocoJNI.MocoDirectCollocationSolver_get_kinematic_constraint_method__SWIG_0(swigCPtr, this, i);
+  }
+
+  public SWIGTYPE_p_std__string upd_kinematic_constraint_method(int i) {
+    return new SWIGTYPE_p_std__string(opensimMocoJNI.MocoDirectCollocationSolver_upd_kinematic_constraint_method__SWIG_0(swigCPtr, this, i), false);
+  }
+
+  public void set_kinematic_constraint_method(int i, String value) {
+    opensimMocoJNI.MocoDirectCollocationSolver_set_kinematic_constraint_method__SWIG_0(swigCPtr, this, i, value);
+  }
+
+  public int append_kinematic_constraint_method(String value) {
+    return opensimMocoJNI.MocoDirectCollocationSolver_append_kinematic_constraint_method(swigCPtr, this, value);
+  }
+
+  public void constructProperty_kinematic_constraint_method(String initValue) {
+    opensimMocoJNI.MocoDirectCollocationSolver_constructProperty_kinematic_constraint_method(swigCPtr, this, initValue);
+  }
+
+  public String get_kinematic_constraint_method() {
+    return opensimMocoJNI.MocoDirectCollocationSolver_get_kinematic_constraint_method__SWIG_1(swigCPtr, this);
+  }
+
+  public SWIGTYPE_p_std__string upd_kinematic_constraint_method() {
+    return new SWIGTYPE_p_std__string(opensimMocoJNI.MocoDirectCollocationSolver_upd_kinematic_constraint_method__SWIG_1(swigCPtr, this), false);
+  }
+
+  public void set_kinematic_constraint_method(String value) {
+    opensimMocoJNI.MocoDirectCollocationSolver_set_kinematic_constraint_method__SWIG_1(swigCPtr, this, value);
+  }
+
   /**
    *  %Set the mesh to a user-defined list of mesh points to sample. This<br>
    * takes precedence over the uniform mesh that would be specified with<br>
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoExpressionBasedParameterGoal.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoExpressionBasedParameterGoal.java
new file mode 100644
index 000000000..978ab9083
--- /dev/null
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoExpressionBasedParameterGoal.java
@@ -0,0 +1,142 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (https://www.swig.org).
+ * Version 4.1.1
+ *
+ * Do not make changes to this file unless you know what you are doing - modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+package org.opensim.modeling;
+
+/**
+ *  Minimize or constrain an arithmetic expression of parameters. <br>
+ * <br>
+ * This goal supports both "cost" and "endpoint constraint" modes and can be <br>
+ * defined using any number of MocoParameters. The expression string should match <br>
+ * the Lepton (lightweight expression parser) format.<br>
+ * <br>
+ * # Creating Expressions<br>
+ * <br>
+ * Expressions can be any string that represents a mathematical expression, e.g.,<br>
+ * "x*sqrt(y-8)". Expressions can contain variables, constants, operations,<br>
+ * parentheses, commas, spaces, and scientific "e" notation. The full list of<br>
+ * operations is: sqrt, exp, log, sin, cos, sec, csc, tan, cot, asin, acos, atan, <br>
+ * sinh, cosh, tanh, erf, erfc, step, delta, square, cube, recip, min, max, abs, <br>
+ * +, -, *, /, and ^.<br>
+ * <br>
+ * # Examples<br>
+ * <br>
+ * {@code 
+auto* spring1_parameter = mp.addParameter("spring_stiffness", "spring1",
+                                       "stiffness", MocoBounds(0, 100));
+auto* spring2_parameter = mp.addParameter("spring2_stiffness", "spring2",
+                                       "stiffness", MocoBounds(0, 100));
+auto* spring_goal = mp.addGoal<MocoExpressionBasedParameterGoal>();
+double STIFFNESS = 100.0;
+minimum is when p + q = STIFFNESS
+spring_goal->setExpression(fmt::format("square(p+q-{})", STIFFNESS));
+spring_goal->addParameter(*spring1_parameter, "p");
+spring_goal->addParameter(*spring2_parameter, "q");
+}<br>
+ * <br>
+ * 
+ */
+public class MocoExpressionBasedParameterGoal extends MocoGoal {
+  private transient long swigCPtr;
+
+  public MocoExpressionBasedParameterGoal(long cPtr, boolean cMemoryOwn) {
+    super(opensimMocoJNI.MocoExpressionBasedParameterGoal_SWIGUpcast(cPtr), cMemoryOwn);
+    swigCPtr = cPtr;
+  }
+
+  public static long getCPtr(MocoExpressionBasedParameterGoal obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+
+  public static long swigRelease(MocoExpressionBasedParameterGoal obj) {
+    long ptr = 0;
+    if (obj != null) {
+      if (!obj.swigCMemOwn)
+        throw new RuntimeException("Cannot release ownership as memory is not owned");
+      ptr = obj.swigCPtr;
+      obj.swigCMemOwn = false;
+      obj.delete();
+    }
+    return ptr;
+  }
+
+  @SuppressWarnings("deprecation")
+  protected void finalize() {
+    delete();
+  }
+
+  public synchronized void delete() {
+    if (swigCPtr != 0) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        opensimMocoJNI.delete_MocoExpressionBasedParameterGoal(swigCPtr);
+      }
+      swigCPtr = 0;
+    }
+    super.delete();
+  }
+
+  public static MocoExpressionBasedParameterGoal safeDownCast(OpenSimObject obj) {
+    long cPtr = opensimMocoJNI.MocoExpressionBasedParameterGoal_safeDownCast(OpenSimObject.getCPtr(obj), obj);
+    return (cPtr == 0) ? null : new MocoExpressionBasedParameterGoal(cPtr, false);
+  }
+
+  public void assign(OpenSimObject aObject) {
+    opensimMocoJNI.MocoExpressionBasedParameterGoal_assign(swigCPtr, this, OpenSimObject.getCPtr(aObject), aObject);
+  }
+
+  public static String getClassName() {
+    return opensimMocoJNI.MocoExpressionBasedParameterGoal_getClassName();
+  }
+
+  public OpenSimObject clone() {
+    long cPtr = opensimMocoJNI.MocoExpressionBasedParameterGoal_clone(swigCPtr, this);
+    return (cPtr == 0) ? null : new MocoExpressionBasedParameterGoal(cPtr, true);
+  }
+
+  public String getConcreteClassName() {
+    return opensimMocoJNI.MocoExpressionBasedParameterGoal_getConcreteClassName(swigCPtr, this);
+  }
+
+  public MocoExpressionBasedParameterGoal() {
+    this(opensimMocoJNI.new_MocoExpressionBasedParameterGoal__SWIG_0(), true);
+  }
+
+  public MocoExpressionBasedParameterGoal(String name) {
+    this(opensimMocoJNI.new_MocoExpressionBasedParameterGoal__SWIG_1(name), true);
+  }
+
+  public MocoExpressionBasedParameterGoal(String name, double weight) {
+    this(opensimMocoJNI.new_MocoExpressionBasedParameterGoal__SWIG_2(name, weight), true);
+  }
+
+  public MocoExpressionBasedParameterGoal(String name, double weight, String expression) {
+    this(opensimMocoJNI.new_MocoExpressionBasedParameterGoal__SWIG_3(name, weight, expression), true);
+  }
+
+  /**
+   *  Set the arithmetic expression to minimize or constrain. Variable <br>
+   *     names should match the names set with addParameter(). See "Creating <br>
+   *     Expressions" in the class documentation above for an explanation of how to <br>
+   *     create expressions. 
+   */
+  public void setExpression(String expression) {
+    opensimMocoJNI.MocoExpressionBasedParameterGoal_setExpression(swigCPtr, this, expression);
+  }
+
+  /**
+   *  Add parameters with variable names that match the variables in the<br>
+   *     expression string. All variables in the expression must have a corresponding<br>
+   *     parameter, but parameters with variables that are not in the expression are<br>
+   *     ignored. 
+   */
+  public void addParameter(MocoParameter parameter, String variable) {
+    opensimMocoJNI.MocoExpressionBasedParameterGoal_addParameter(swigCPtr, this, MocoParameter.getCPtr(parameter), parameter, variable);
+  }
+
+}
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoGeneralizedForceTrackingGoal.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoGeneralizedForceTrackingGoal.java
index 10a87109d..9d49c4f08 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/MocoGeneralizedForceTrackingGoal.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoGeneralizedForceTrackingGoal.java
@@ -149,6 +149,17 @@ public void setWeightForGeneralizedForce(String name, double weight) {
     opensimMocoJNI.MocoGeneralizedForceTrackingGoal_setWeightForGeneralizedForce(swigCPtr, this, name, weight);
   }
 
+  /**
+   *  Set the tracking weight for all generalized forces whose names match the<br>
+   *  regular expression pattern. Multiple pairs of patterns and weights can <br>
+   *  be provided by calling this function multiple times. If a generalized<br>
+   *  force matches multiple patterns, the weight associated with the last<br>
+   *  pattern is used.
+   */
+  public void setWeightForGeneralizedForcePattern(String pattern, double weight) {
+    opensimMocoJNI.MocoGeneralizedForceTrackingGoal_setWeightForGeneralizedForcePattern(swigCPtr, this, pattern, weight);
+  }
+
   /**
    *  Set the MocoWeightSet to weight the generalized coordinate forces in<br>
    *  the cost. Replaces the weight set if it already exists.
@@ -184,9 +195,9 @@ public boolean getNormalizeTrackingError() {
   }
 
   /**
-   *  Whether or not to ignore coordinates that are locked, prescribed, or<br>
-   *  coupled to other coordinates. This is based on the value returned from <br>
-   *  `Coordinate::isConstrained()` (default: true).
+   *  Whether or not to ignore generalized forces for coordinates that are <br>
+   *  locked, prescribed, or coupled to other coordinates. This is based on <br>
+   *  the value returned from `Coordinate::isConstrained()` (default: true).
    */
   public void setIgnoreConstrainedCoordinates(boolean tf) {
     opensimMocoJNI.MocoGeneralizedForceTrackingGoal_setIgnoreConstrainedCoordinates(swigCPtr, this, tf);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoInverse.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoInverse.java
index 8790835a2..8207cd3f2 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/MocoInverse.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoInverse.java
@@ -472,6 +472,10 @@ public MocoStudy initialize() {
     return new MocoStudy(opensimMocoJNI.MocoInverse_initialize(swigCPtr, this), true);
   }
 
+  public TimeSeriesTable initializeKinematics() {
+    return new TimeSeriesTable(opensimMocoJNI.MocoInverse_initializeKinematics(swigCPtr, this), true);
+  }
+
   /**
    *  Solve the problem returned by initialize() and compute the outputs<br>
    *  listed in output_paths.
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoJointReactionGoal.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoJointReactionGoal.java
index 21c48a801..5eb6f7e9f 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/MocoJointReactionGoal.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoJointReactionGoal.java
@@ -149,8 +149,8 @@ public void setReactionMeasures(StdVectorString measures) {
    *     replaces the previous weight. An exception is thrown during<br>
    *     initialization if a weight for an unknown measure is provided. 
    */
-  public void setWeight(String stateName, double weight) {
-    opensimMocoJNI.MocoJointReactionGoal_setWeight(swigCPtr, this, stateName, weight);
+  public void setWeight(String measure, double weight) {
+    opensimMocoJNI.MocoJointReactionGoal_setWeight(swigCPtr, this, measure, weight);
   }
 
   /**
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoOrientationTrackingGoal.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoOrientationTrackingGoal.java
index e781c3b23..49050ad64 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/MocoOrientationTrackingGoal.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoOrientationTrackingGoal.java
@@ -141,11 +141,12 @@ public void setRotationReference(TimeSeriesTableQuaternion ref) {
    *  Provide a table containing values of model state variables. These data<br>
    *     are used to create a StatesTrajectory internally, from which the<br>
    *     rotation data for the frames specified in setFramePaths() are computed.<br>
-   *     Each column label in the reference must be the path of a state variable,<br>
-   *     e.g., `/jointset/ankle_angle_r/value`. Calling this function clears the<br>
-   *     table provided via setRotationReference(), or the<br>
-   *     `rotation_reference_file` property, if any. The table is not loaded<br>
-   *     until the MocoProblem is initialized. 
+   *     Each column label in the reference should be the path of a coordinate value,<br>
+   *     e.g., `/jointset/ankle_r/ankle_angle_r/value`. Columns for states that body<br>
+   *     orientations do not depend on (e.g., `/forceset/soleus_r/activation`) are<br>
+   *     not needed. Calling this function clears the table provided via<br>
+   *     setRotationReference(), or the `rotation_reference_file` property, if any.<br>
+   *     The table is not loaded until the MocoProblem is initialized. 
    */
   public void setStatesReference(TableProcessor ref) {
     opensimMocoJNI.MocoOrientationTrackingGoal_setStatesReference(swigCPtr, this, TableProcessor.getCPtr(ref), ref);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoOutputBase.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoOutputBase.java
index cb0973f65..ffdb7a675 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/MocoOutputBase.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoOutputBase.java
@@ -11,25 +11,38 @@
 /**
  *  This abstract base class provides convenience methods and common interfaces<br>
  * for all Output-related MocoGoal's. All MocoGoal's deriving from this class<br>
- * include the 'setOutputPath()', 'setOutputIndex()', and 'setExponent()' methods<br>
- * and their corresponding Object properties. The convenience method<br>
- * 'initializeOnModelBase()' should be called at the top of<br>
- * 'initializeOnModelImpl()' within each derived class. Similarly,<br>
+ * include the 'setOutputPath()', 'setSecondOutputPath()', 'setOperation()',<br>
+ * 'setOutputIndex()', and 'setExponent()' methods and their corresponding Object<br>
+ * properties. The convenience method 'initializeOnModelBase()' should be called at<br>
+ * the top of 'initializeOnModelImpl()' within each derived class. Similarly,<br>
  * 'calcOutputValue()' can be used to retrieve the Output value with<br>
  * 'calcGoalImpl()' and/or 'calcIntegrandImpl()', as needed for each derived class.<br>
  * The method 'getDependsOnStage()' returns the SimTK::Stage that should be realized<br>
  * to to calculate Output values. The method 'setValueToExponent()' can be used to<br>
  * raise a value to the exponent provided via 'setExponent()'.<br>
  * <br>
+ * Goals can be composed of one or two Outputs. The optional second Output can be<br>
+ * included by using the methods 'setSecondOutputPath()' and 'setOperation()'. The<br>
+ * Output values can be combined by addition, subtraction, multiplication, or<br>
+ * division. The first Output is always on the left hand side of the operation and<br>
+ * the second Output on the right hand side. The two Outputs can be different<br>
+ * quantities, but they must be the same type.<br>
+ * <br>
  * We support the following Output types:<br>
  * - double<br>
  * - SimTK::Vec3<br>
  * - SimTK::SpatialVec<br>
  * <br>
- * When using vector types, 'setOutputIndex()' may be used to select a specific<br>
- * element of the Output vector. If not specified, the norm of the vector is<br>
- * returned when calling 'calcOutputValue()'.<br>
+ * When using SimTK::Vec3 or SimTK::SpatialVec types, 'setOutputIndex()' may be<br>
+ * used to select a specific element of the Output vector. If no index is<br>
+ * specified, the norm of the vector will be used when calling 'calcOutputValue()'.<br>
  * <br>
+ * If using two Outputs, the Output index will be used to select the same element<br>
+ * from both Outputs before the operation. If two Outputs of type SimTK::Vec3 or<br>
+ * SimTK::SpatialVec are provided and no index is specified, the operation will be<br>
+ * applied elementwise before computing the norm. Elementwise<br>
+ * multiplication and division operations are not supported when using two<br>
+ * SimTK::SpatialVec Outputs (i.e., an index must be provided).<br>
  * 
  */
 public class MocoOutputBase extends MocoGoal {
@@ -95,8 +108,8 @@ public String getConcreteClassName() {
   }
 
   /**
-   *  Set the absolute path to the output in the model to use as the integrand<br>
-   *     for this goal. The format is "/path/to/component|output_name". 
+   *  Set the absolute path to the Output in the model. The format is<br>
+   *     "/path/to/component|output_name". 
    */
   public void setOutputPath(String path) {
     opensimMocoJNI.MocoOutputBase_setOutputPath(swigCPtr, this, path);
@@ -106,6 +119,34 @@ public String getOutputPath() {
     return opensimMocoJNI.MocoOutputBase_getOutputPath(swigCPtr, this);
   }
 
+  /**
+   *  Set the absolute path to the optional second Output in the model. The<br>
+   *     format is "/path/to/component|output_name". This Output should have the same<br>
+   *     type as the first Output. If providing a second Output, the user must also<br>
+   *     provide an operation via `setOperation()`. 
+   */
+  public void setSecondOutputPath(String path) {
+    opensimMocoJNI.MocoOutputBase_setSecondOutputPath(swigCPtr, this, path);
+  }
+
+  public String getSecondOutputPath() {
+    return opensimMocoJNI.MocoOutputBase_getSecondOutputPath(swigCPtr, this);
+  }
+
+  /**
+   *  Set the operation that combines Output values where two Outputs are<br>
+   *     provided. The supported operations include "addition", "subtraction",<br>
+   *     "multiplication", or "division". If providing an operation, the user<br>
+   *     must also provide a second Output path. 
+   */
+  public void setOperation(String operation) {
+    opensimMocoJNI.MocoOutputBase_setOperation(swigCPtr, this, operation);
+  }
+
+  public String getOperation() {
+    return opensimMocoJNI.MocoOutputBase_getOperation(swigCPtr, this);
+  }
+
   /**
    *  Set the exponent applied to the output value in the integrand. This<br>
    *     exponent is applied when minimizing the norm of a vector type output. The<br>
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoOutputBoundConstraint.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoOutputBoundConstraint.java
new file mode 100644
index 000000000..636216510
--- /dev/null
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoOutputBoundConstraint.java
@@ -0,0 +1,221 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (https://www.swig.org).
+ * Version 4.1.1
+ *
+ * Do not make changes to this file unless you know what you are doing - modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+package org.opensim.modeling;
+
+/**
+ *  This path constraint allows you to constrain a Model Output value to be<br>
+ * between two time-based functions throughout the trajectory. It is<br>
+ * possible to constrain the Output to match the value from a provided function;<br>
+ * see the 'equality_with_lower' property. You can also combine two Outputs<br>
+ * in a constraint by supplying a second output path and an operation to combine<br>
+ * them. The operations are addition, subtraction, multiplication, and division.<br>
+ * The first Output is always on the left hand side of the operation and the second<br>
+ * Output on the right hand side. The two Outputs can be different quantities, but<br>
+ * they must have the same type.<br>
+ * <br>
+ * Outputs of type double, SimTK::Vec3, and SimTK::SpatialVec are supported.<br>
+ * When using SimTK::Vec3 or SimTK::SpatialVec types, 'setOutputIndex()'<br>
+ * may be used to select a specific element of the Output vector. If no index is<br>
+ * specified, the norm of the vector will be used when calling 'calcOutputValue()'.<br>
+ * <br>
+ * If using two Outputs, the Output index will be used to select the same element<br>
+ * from both Outputs before the operation. If two Outputs of type SimTK::Vec3 or<br>
+ * SimTK::SpatialVec are provided and no index is specified, the operation will be<br>
+ * applied elementwise before computing the norm. Elementwise<br>
+ * multiplication and division operations are not supported when using two<br>
+ * SimTK::SpatialVec Outputs (i.e., an index must be provided).<br>
+ * <br>
+ * If a bound function is a GCVSpline, we ensure that the spline covers the entire<br>
+ * possible time range in the problem (using the problem's time bounds). We do<br>
+ * not perform such a check for other types of functions.<br>
+ * <br>
+ * Note: If you omit the lower and upper bounds, then this class will not<br>
+ * constrain any Outputs, even if you have provided output paths.<br>
+ * 
+ */
+public class MocoOutputBoundConstraint extends MocoPathConstraint {
+  private transient long swigCPtr;
+
+  public MocoOutputBoundConstraint(long cPtr, boolean cMemoryOwn) {
+    super(opensimMocoJNI.MocoOutputBoundConstraint_SWIGUpcast(cPtr), cMemoryOwn);
+    swigCPtr = cPtr;
+  }
+
+  public static long getCPtr(MocoOutputBoundConstraint obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+
+  public static long swigRelease(MocoOutputBoundConstraint obj) {
+    long ptr = 0;
+    if (obj != null) {
+      if (!obj.swigCMemOwn)
+        throw new RuntimeException("Cannot release ownership as memory is not owned");
+      ptr = obj.swigCPtr;
+      obj.swigCMemOwn = false;
+      obj.delete();
+    }
+    return ptr;
+  }
+
+  @SuppressWarnings("deprecation")
+  protected void finalize() {
+    delete();
+  }
+
+  public synchronized void delete() {
+    if (swigCPtr != 0) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        opensimMocoJNI.delete_MocoOutputBoundConstraint(swigCPtr);
+      }
+      swigCPtr = 0;
+    }
+    super.delete();
+  }
+
+  public static MocoOutputBoundConstraint safeDownCast(OpenSimObject obj) {
+    long cPtr = opensimMocoJNI.MocoOutputBoundConstraint_safeDownCast(OpenSimObject.getCPtr(obj), obj);
+    return (cPtr == 0) ? null : new MocoOutputBoundConstraint(cPtr, false);
+  }
+
+  public void assign(OpenSimObject aObject) {
+    opensimMocoJNI.MocoOutputBoundConstraint_assign(swigCPtr, this, OpenSimObject.getCPtr(aObject), aObject);
+  }
+
+  public static String getClassName() {
+    return opensimMocoJNI.MocoOutputBoundConstraint_getClassName();
+  }
+
+  public OpenSimObject clone() {
+    long cPtr = opensimMocoJNI.MocoOutputBoundConstraint_clone(swigCPtr, this);
+    return (cPtr == 0) ? null : new MocoOutputBoundConstraint(cPtr, true);
+  }
+
+  public String getConcreteClassName() {
+    return opensimMocoJNI.MocoOutputBoundConstraint_getConcreteClassName(swigCPtr, this);
+  }
+
+  public MocoOutputBoundConstraint() {
+    this(opensimMocoJNI.new_MocoOutputBoundConstraint(), true);
+  }
+
+  /**
+   *  Set the absolute path to the Output in the model to be used in this path<br>
+   *     constraint. The format is "/path/to/component|output_name". 
+   */
+  public void setOutputPath(String path) {
+    opensimMocoJNI.MocoOutputBoundConstraint_setOutputPath(swigCPtr, this, path);
+  }
+
+  public String getOutputPath() {
+    return opensimMocoJNI.MocoOutputBoundConstraint_getOutputPath(swigCPtr, this);
+  }
+
+  /**
+   *  Set the absolute path to the optional second Output in the model to be<br>
+   *     used in this path constraint. The format is "/path/to/component|output_name".<br>
+   *     This Output should have the same type as the first Output. If providing a<br>
+   *     second Output, the user must also provide an operation via `setOperation()`.
+   */
+  public void setSecondOutputPath(String path) {
+    opensimMocoJNI.MocoOutputBoundConstraint_setSecondOutputPath(swigCPtr, this, path);
+  }
+
+  public String getSecondOutputPath() {
+    return opensimMocoJNI.MocoOutputBoundConstraint_getSecondOutputPath(swigCPtr, this);
+  }
+
+  /**
+   *  Set the operation that combines Output values where two Outputs are<br>
+   *     provided. The supported operations include "addition", "subtraction",<br>
+   *     "multiplication", or "division". If providing an operation, the user<br>
+   *     must also provide a second Output path. 
+   */
+  public void setOperation(String operation) {
+    opensimMocoJNI.MocoOutputBoundConstraint_setOperation(swigCPtr, this, operation);
+  }
+
+  public String getOperation() {
+    return opensimMocoJNI.MocoOutputBoundConstraint_getOperation(swigCPtr, this);
+  }
+
+  /**
+   *  Set the exponent applied to the output value in the constraint. This<br>
+   *     exponent is applied when minimizing the norm of a vector type output. 
+   */
+  public void setExponent(int exponent) {
+    opensimMocoJNI.MocoOutputBoundConstraint_setExponent(swigCPtr, this, exponent);
+  }
+
+  public int getExponent() {
+    return opensimMocoJNI.MocoOutputBoundConstraint_getExponent(swigCPtr, this);
+  }
+
+  /**
+   *  Set the index to the value to be constrained when a vector type Output<br>
+   *     is specified. For SpatialVec Outputs, indices 0, 1, and 2 refer to the<br>
+   *     rotational components and indices 3, 4, and 5 refer to the translational<br>
+   *     components. A value of -1 indicates to constrain the vector norm (which is<br>
+   *     the default setting). If an index for a type double Output is provided, an<br>
+   *     exception is thrown. 
+   */
+  public void setOutputIndex(int index) {
+    opensimMocoJNI.MocoOutputBoundConstraint_setOutputIndex(swigCPtr, this, index);
+  }
+
+  public int getOutputIndex() {
+    return opensimMocoJNI.MocoOutputBoundConstraint_getOutputIndex(swigCPtr, this);
+  }
+
+  public void setLowerBound(Function f) {
+    opensimMocoJNI.MocoOutputBoundConstraint_setLowerBound(swigCPtr, this, Function.getCPtr(f), f);
+  }
+
+  public void clearLowerBound() {
+    opensimMocoJNI.MocoOutputBoundConstraint_clearLowerBound(swigCPtr, this);
+  }
+
+  public boolean hasLowerBound() {
+    return opensimMocoJNI.MocoOutputBoundConstraint_hasLowerBound(swigCPtr, this);
+  }
+
+  public Function getLowerBound() {
+    return new Function(opensimMocoJNI.MocoOutputBoundConstraint_getLowerBound(swigCPtr, this), false);
+  }
+
+  public void setUpperBound(Function f) {
+    opensimMocoJNI.MocoOutputBoundConstraint_setUpperBound(swigCPtr, this, Function.getCPtr(f), f);
+  }
+
+  public void clearUpperBound() {
+    opensimMocoJNI.MocoOutputBoundConstraint_clearUpperBound(swigCPtr, this);
+  }
+
+  public boolean hasUpperBound() {
+    return opensimMocoJNI.MocoOutputBoundConstraint_hasUpperBound(swigCPtr, this);
+  }
+
+  public Function getUpperBound() {
+    return new Function(opensimMocoJNI.MocoOutputBoundConstraint_getUpperBound(swigCPtr, this), false);
+  }
+
+  /**
+   *  Should the Output be constrained to be equal to the lower bound (rather<br>
+   *  than an inequality constraint)? In this case, the upper bound must be<br>
+   *  unspecified.
+   */
+  public void setEqualityWithLower(boolean v) {
+    opensimMocoJNI.MocoOutputBoundConstraint_setEqualityWithLower(swigCPtr, this, v);
+  }
+
+  public boolean getEqualityWithLower() {
+    return opensimMocoJNI.MocoOutputBoundConstraint_getEqualityWithLower(swigCPtr, this);
+  }
+
+}
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoOutputConstraint.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoOutputConstraint.java
index 69668a0e2..fbbb93c0e 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/MocoOutputConstraint.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoOutputConstraint.java
@@ -8,6 +8,27 @@
 
 package org.opensim.modeling;
 
+/**
+ *  This path constraint allows you to constrain a Model Output value throughout the<br>
+ * trajectory. You can also combine two Outputs in a constraint by supplying a<br>
+ * second output path and an operation to combine them. The operations are addition,<br>
+ * subtraction, multiplication, and division. The first Output is always on the<br>
+ * left hand side of the operation and the second Output on the right hand side.<br>
+ * The two Outputs can be different quantities, but they must be the same type.<br>
+ * <br>
+ * Outputs of type double, SimTK::Vec3, and SimTK::SpatialVec are supported.<br>
+ * When using SimTK::Vec3 or SimTK::SpatialVec types, 'setOutputIndex()'<br>
+ * may be used to select a specific element of the Output vector. If no index is<br>
+ * specified, the norm of the vector will be used when calling 'calcOutputValue()'.<br>
+ * <br>
+ * If using two Outputs, the Output index will be used to select the same element<br>
+ * from both Outputs before the operation. If two Outputs of type SimTK::Vec3 or<br>
+ * SimTK::SpatialVec are provided and no index is specified, the operation will be<br>
+ * applied elementwise before computing the norm. Elementwise<br>
+ * multiplication and division operations are not supported when using two<br>
+ * SimTK::SpatialVec Outputs (i.e., an index must be provided).<br>
+ * 
+ */
 public class MocoOutputConstraint extends MocoPathConstraint {
   private transient long swigCPtr;
 
@@ -86,6 +107,34 @@ public String getOutputPath() {
     return opensimMocoJNI.MocoOutputConstraint_getOutputPath(swigCPtr, this);
   }
 
+  /**
+   *  Set the absolute path to the optional second Output in the model to be<br>
+   *     used in this path constraint. The format is "/path/to/component|output_name".<br>
+   *     This Output should have the same  type as the first Output. If providing a<br>
+   *     second Output, the user must also provide an operation via `setOperation()`.
+   */
+  public void setSecondOutputPath(String path) {
+    opensimMocoJNI.MocoOutputConstraint_setSecondOutputPath(swigCPtr, this, path);
+  }
+
+  public String getSecondOutputPath() {
+    return opensimMocoJNI.MocoOutputConstraint_getSecondOutputPath(swigCPtr, this);
+  }
+
+  /**
+   *  Set the operation that combines Output values where two Outputs are<br>
+   *     provided. The supported operations include "addition", "subtraction",<br>
+   *     "multiplication", or "division". If providing an operation, the user<br>
+   *     must also provide a second Output path. 
+   */
+  public void setOperation(String operation) {
+    opensimMocoJNI.MocoOutputConstraint_setOperation(swigCPtr, this, operation);
+  }
+
+  public String getOperation() {
+    return opensimMocoJNI.MocoOutputConstraint_getOperation(swigCPtr, this);
+  }
+
   /**
    *  Set the exponent applied to the output value in the constraint. This<br>
    *     exponent is applied when minimizing the norm of a vector type output. 
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoParameter.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoParameter.java
index 058a8aec9..ecc6a432a 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/MocoParameter.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoParameter.java
@@ -190,6 +190,10 @@ public void appendComponentPath(String componentPath) {
     opensimMocoJNI.MocoParameter_appendComponentPath(swigCPtr, this, componentPath);
   }
 
+  public int getPropertyElement() {
+    return opensimMocoJNI.MocoParameter_getPropertyElement(swigCPtr, this);
+  }
+
   /**
    *  For use by solvers. This performs error checks and caches information<br>
    *     about the model that is useful during the optimization.<br>
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoPhase.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoPhase.java
index 926e2c349..b978cfa04 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/MocoPhase.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoPhase.java
@@ -179,6 +179,35 @@ public void setControlInfoPattern(String pattern, double[] b, double[] ib)
         setControlInfoPattern(pattern, this.convertArrayToMB(b),
                 this.convertArrayToMIB(ib), this.convertArrayToMFB(fb));
     }
+    
+    public void setInputControlInfo(String name, double[] b) throws Exception {
+        setInputControlInfo(name, this.convertArrayToMB(b));
+    }
+    public void setInputControlInfo(String name, double[] b, double[] ib)
+        throws Exception {
+        setInputControlInfo(name, this.convertArrayToMB(b),
+                this.convertArrayToMIB(ib));
+    }
+    public void setInputControlInfo(String name, double[] b, double[] ib, double[] fb)
+        throws Exception {
+        setInputControlInfo(name, this.convertArrayToMB(b),
+                this.convertArrayToMIB(ib), this.convertArrayToMFB(fb));
+    }
+    public void setInputControlInfoPattern(String pattern, double[] b) 
+        throws Exception {
+        setInputControlInfoPattern(pattern, this.convertArrayToMB(b));
+    }
+    public void setInputControlInfoPattern(String pattern, double[] b, double[] ib)
+        throws Exception {
+        setInputControlInfoPattern(pattern, this.convertArrayToMB(b),
+                this.convertArrayToMIB(ib));
+    }
+    public void 
+    setInputControlInfoPattern(String pattern, double[] b, double[] ib, double[] fb) 
+        throws Exception {
+        setInputControlInfoPattern(pattern, this.convertArrayToMB(b),
+                this.convertArrayToMIB(ib), this.convertArrayToMFB(fb));
+    }
 
   public static MocoPhase safeDownCast(OpenSimObject obj) {
     long cPtr = opensimMocoJNI.MocoPhase_safeDownCast(OpenSimObject.getCPtr(obj), obj);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoProblem.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoProblem.java
index 631b5d859..cce63bfe5 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/MocoProblem.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoProblem.java
@@ -150,6 +150,39 @@ public void setControlInfoPattern(String pattern, double[] b, double[] ib)
                 MocoPhase.convertArrayToMFB(fb));
     }
 
+    public void setInputControlInfo(String name, double[] b)
+        throws Exception {
+        setInputControlInfo(name, MocoPhase.convertArrayToMB(b));
+    }
+    public void setInputControlInfo(String name, double[] b, double[] ib)
+        throws Exception {
+        setInputControlInfo(name, MocoPhase.convertArrayToMB(b),
+                MocoPhase.convertArrayToMIB(ib));
+    }
+    public void setInputControlInfo(String name, double[] b, double[] ib,
+            double[] fb)
+        throws Exception {
+        setInputControlInfo(name, MocoPhase.convertArrayToMB(b),
+                MocoPhase.convertArrayToMIB(ib), 
+                MocoPhase.convertArrayToMFB(fb));
+    }
+    public void setInputControlInfoPattern(String pattern, double[] b)
+        throws Exception {
+        setInputControlInfoPattern(pattern, MocoPhase.convertArrayToMB(b));
+    }
+    public void setInputControlInfoPattern(String pattern, double[] b, double[] ib)
+        throws Exception {
+        setInputControlInfoPattern(pattern, MocoPhase.convertArrayToMB(b),
+                MocoPhase.convertArrayToMIB(ib));
+    }
+    public void 
+    setInputControlInfoPattern(String pattern, double[] b, double[] ib, double[] fb)
+        throws Exception {
+        setInputControlInfoPattern(pattern, MocoPhase.convertArrayToMB(b),
+                MocoPhase.convertArrayToMIB(ib), 
+                MocoPhase.convertArrayToMFB(fb));
+    }
+
   public static MocoProblem safeDownCast(OpenSimObject obj) {
     long cPtr = opensimMocoJNI.MocoProblem_safeDownCast(OpenSimObject.getCPtr(obj), obj);
     return (cPtr == 0) ? null : new MocoProblem(cPtr, false);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoProblemRep.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoProblemRep.java
index 1c06219a4..0c6e38c85 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/MocoProblemRep.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoProblemRep.java
@@ -457,7 +457,7 @@ public int getNumKinematicConstraintEquations() {
 
   /**
    *  Print a description of this problem, including costs and variable<br>
-   *  bounds. Printing is done using OpenSim::log_cout().
+   *  bounds. Printing is done using OpenSim::log_info().
    */
   public void printDescription() {
     opensimMocoJNI.MocoProblemRep_printDescription(swigCPtr, this);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoStateBoundConstraint.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoStateBoundConstraint.java
new file mode 100644
index 000000000..dfad3a885
--- /dev/null
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoStateBoundConstraint.java
@@ -0,0 +1,157 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (https://www.swig.org).
+ * Version 4.1.1
+ *
+ * Do not make changes to this file unless you know what you are doing - modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+package org.opensim.modeling;
+
+/**
+ *  This path contraint allows you to bound any number of state variables<br>
+ * between two time-based functions. It is possible to constrain the state variable<br>
+ * to match the value from a provided function; see the equality_with_lower<br>
+ * property.<br>
+ * <br>
+ * If a function is a GCVSpline, we ensure that the spline covers the entire<br>
+ * possible time range in the problem (using the problem's time bounds). We do<br>
+ * not perform such a check for other types of functions.<br>
+ * <br>
+ * Note: If you omit the lower and upper bounds, then this class will not<br>
+ * constrain any state variable, even if you have provided state paths.<br>
+ * <br>
+ * 
+ */
+public class MocoStateBoundConstraint extends MocoPathConstraint {
+  private transient long swigCPtr;
+
+  public MocoStateBoundConstraint(long cPtr, boolean cMemoryOwn) {
+    super(opensimMocoJNI.MocoStateBoundConstraint_SWIGUpcast(cPtr), cMemoryOwn);
+    swigCPtr = cPtr;
+  }
+
+  public static long getCPtr(MocoStateBoundConstraint obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+
+  public static long swigRelease(MocoStateBoundConstraint obj) {
+    long ptr = 0;
+    if (obj != null) {
+      if (!obj.swigCMemOwn)
+        throw new RuntimeException("Cannot release ownership as memory is not owned");
+      ptr = obj.swigCPtr;
+      obj.swigCMemOwn = false;
+      obj.delete();
+    }
+    return ptr;
+  }
+
+  @SuppressWarnings("deprecation")
+  protected void finalize() {
+    delete();
+  }
+
+  public synchronized void delete() {
+    if (swigCPtr != 0) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        opensimMocoJNI.delete_MocoStateBoundConstraint(swigCPtr);
+      }
+      swigCPtr = 0;
+    }
+    super.delete();
+  }
+
+  public static MocoStateBoundConstraint safeDownCast(OpenSimObject obj) {
+    long cPtr = opensimMocoJNI.MocoStateBoundConstraint_safeDownCast(OpenSimObject.getCPtr(obj), obj);
+    return (cPtr == 0) ? null : new MocoStateBoundConstraint(cPtr, false);
+  }
+
+  public void assign(OpenSimObject aObject) {
+    opensimMocoJNI.MocoStateBoundConstraint_assign(swigCPtr, this, OpenSimObject.getCPtr(aObject), aObject);
+  }
+
+  public static String getClassName() {
+    return opensimMocoJNI.MocoStateBoundConstraint_getClassName();
+  }
+
+  public OpenSimObject clone() {
+    long cPtr = opensimMocoJNI.MocoStateBoundConstraint_clone(swigCPtr, this);
+    return (cPtr == 0) ? null : new MocoStateBoundConstraint(cPtr, true);
+  }
+
+  public String getConcreteClassName() {
+    return opensimMocoJNI.MocoStateBoundConstraint_getConcreteClassName(swigCPtr, this);
+  }
+
+  public MocoStateBoundConstraint() {
+    this(opensimMocoJNI.new_MocoStateBoundConstraint(), true);
+  }
+
+  /**
+   *  Add a state path (absolute path to state varaibles in the model)<br>
+   *     to be constrained by this class  (e.g., "/slider/position/speed"). 
+   */
+  public void addStatePath(String statePath) {
+    opensimMocoJNI.MocoStateBoundConstraint_addStatePath(swigCPtr, this, statePath);
+  }
+
+  public void setStatePaths(StdVectorString statePaths) {
+    opensimMocoJNI.MocoStateBoundConstraint_setStatePaths(swigCPtr, this, StdVectorString.getCPtr(statePaths), statePaths);
+  }
+
+  public void clearStatePaths() {
+    opensimMocoJNI.MocoStateBoundConstraint_clearStatePaths(swigCPtr, this);
+  }
+
+  public StdVectorString getStatePaths() {
+    return new StdVectorString(opensimMocoJNI.MocoStateBoundConstraint_getStatePaths(swigCPtr, this), true);
+  }
+
+  public void setLowerBound(Function f) {
+    opensimMocoJNI.MocoStateBoundConstraint_setLowerBound(swigCPtr, this, Function.getCPtr(f), f);
+  }
+
+  public void clearLowerBound() {
+    opensimMocoJNI.MocoStateBoundConstraint_clearLowerBound(swigCPtr, this);
+  }
+
+  public boolean hasLowerBound() {
+    return opensimMocoJNI.MocoStateBoundConstraint_hasLowerBound(swigCPtr, this);
+  }
+
+  public Function getLowerBound() {
+    return new Function(opensimMocoJNI.MocoStateBoundConstraint_getLowerBound(swigCPtr, this), false);
+  }
+
+  public void setUpperBound(Function f) {
+    opensimMocoJNI.MocoStateBoundConstraint_setUpperBound(swigCPtr, this, Function.getCPtr(f), f);
+  }
+
+  public void clearUpperBound() {
+    opensimMocoJNI.MocoStateBoundConstraint_clearUpperBound(swigCPtr, this);
+  }
+
+  public boolean hasUpperBound() {
+    return opensimMocoJNI.MocoStateBoundConstraint_hasUpperBound(swigCPtr, this);
+  }
+
+  public Function getUpperBound() {
+    return new Function(opensimMocoJNI.MocoStateBoundConstraint_getUpperBound(swigCPtr, this), false);
+  }
+
+  /**
+   *  Set whether the state should be constrained to be equal to the lower<br>
+   *     bound (rather than an inequality constraint). In this case, the upper bound<br>
+   *     must be unspecified. 
+   */
+  public void setEqualityWithLower(boolean v) {
+    opensimMocoJNI.MocoStateBoundConstraint_setEqualityWithLower(swigCPtr, this, v);
+  }
+
+  public boolean getEqualityWithLower() {
+    return opensimMocoJNI.MocoStateBoundConstraint_getEqualityWithLower(swigCPtr, this);
+  }
+
+}
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MocoTrajectory.java b/Gui/opensim/modeling/src/org/opensim/modeling/MocoTrajectory.java
index f3a01e7f1..6865626cc 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/MocoTrajectory.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MocoTrajectory.java
@@ -140,6 +140,12 @@ public void setControl(String name, double[] traj) {
         for (int i = 0; i < traj.length; ++i) { v.set(i, traj[i]); }
         setControl(name, v);
     }
+    public void setInputControl(String name, double[] traj) {
+        Vector v = new Vector();
+        v.resize(traj.length);
+        for (int i = 0; i < traj.length; ++i) { v.set(i, traj[i]); }
+        setInputControl(name, v);
+    }
     public void setMultiplier(String name, double[] traj) {
         Vector v = new Vector();
         v.resize(traj.length);
@@ -170,6 +176,12 @@ public double[] getControlMat(String name) {
         for (int i = 0; i < control.size(); ++i) { ret[i] = control.get(i); };
         return ret;
     }
+    public double[] getInputControlMat(String name) {
+        VectorView input_control = getInputControl(name);
+        double[] ret = new double[input_control.size()];
+        for (int i = 0; i < input_control.size(); ++i) { ret[i] = input_control.get(i); };
+        return ret;
+    }
     public double[] getMultiplierMat(String name) {
         VectorView mult = getMultiplier(name);
         double[] ret = new double[mult.size()];
@@ -208,6 +220,16 @@ public double[][] getControlsTrajectoryMat() {
         }
         return ret;
     }
+    public double[][] getInputControlsTrajectoryMat() {
+        Matrix matrix = getInputControlsTrajectory();
+        double[][] ret = new double[matrix.nrow()][matrix.ncol()];
+        for (int i = 0; i < matrix.nrow(); ++i) {
+            for (int j = 0; j < matrix.ncol(); ++j) {
+                ret[i][j] = matrix.getElt(i, j);
+            }
+        }
+        return ret;
+    }
     public double[][] getMultipliersTrajectoryMat() {
         Matrix matrix = getMultipliersTrajectory();
         double[][] ret = new double[matrix.nrow()][matrix.ncol()];
@@ -404,7 +426,7 @@ public void setControl(String name, Vector trajectory) {
    *  value 10.
    */
   public void setInputControl(String name, Vector trajectory) {
-    opensimMocoJNI.MocoTrajectory_setInputControl__SWIG_0(swigCPtr, this, name, Vector.getCPtr(trajectory), trajectory);
+    opensimMocoJNI.MocoTrajectory_setInputControl(swigCPtr, this, name, Vector.getCPtr(trajectory), trajectory);
   }
 
   /**
@@ -437,18 +459,6 @@ public void setParameter(String name, double value) {
     opensimMocoJNI.MocoTrajectory_setParameter(swigCPtr, this, name, value);
   }
 
-  /**
-   *  Set the value of a single Input control variable across time. The <br>
-   *  provided vector must have length getNumTimes().<br>
-   *  This variant supports use of an initializer list:<br>
-   *  {@code 
-   trajectory.setInputControl("/my_controller/input", {0, 0.5, 1.0});
-   }
-   */
-  public void setInputControl(String name, SWIGTYPE_p_std__initializer_listT_double_t trajectory) {
-    opensimMocoJNI.MocoTrajectory_setInputControl__SWIG_1(swigCPtr, this, name, SWIGTYPE_p_std__initializer_listT_double_t.getCPtr(trajectory));
-  }
-
   /**
    *  Set the states trajectory. The provided data is interpolated at the<br>
    *  times contained within this trajectory. The controls trajectory is not<br>
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/ModOpPrescribeCoordinateValues.java b/Gui/opensim/modeling/src/org/opensim/modeling/ModOpPrescribeCoordinateValues.java
new file mode 100644
index 000000000..d1eb6bcc2
--- /dev/null
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/ModOpPrescribeCoordinateValues.java
@@ -0,0 +1,91 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (https://www.swig.org).
+ * Version 4.1.1
+ *
+ * Do not make changes to this file unless you know what you are doing - modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+package org.opensim.modeling;
+
+/**
+ *  Prescribe motion to Coordinate%s in a model by providing a table containing<br>
+ *  time series data of Coordinate values. Any columns in the provided table<br>
+ *  (e.g., "/jointset/ankle_r/ankle_angle_r/value") that do not match a valid<br>
+ *  path to a Joint Coordinate value in the model will be ignored. A GCVSpline<br>
+ *  function is created for each column of Coordinate values and this function<br>
+ *  is assigned to the `prescribed_function` property for the matching Coordinate.<br>
+ *  In addition, the `prescribed` property for each matching Coordinate is set<br>
+ *  to "true".
+ */
+public class ModOpPrescribeCoordinateValues extends ModelOperator {
+  private transient long swigCPtr;
+
+  public ModOpPrescribeCoordinateValues(long cPtr, boolean cMemoryOwn) {
+    super(opensimActuatorsAnalysesToolsJNI.ModOpPrescribeCoordinateValues_SWIGUpcast(cPtr), cMemoryOwn);
+    swigCPtr = cPtr;
+  }
+
+  public static long getCPtr(ModOpPrescribeCoordinateValues obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+
+  public static long swigRelease(ModOpPrescribeCoordinateValues obj) {
+    long ptr = 0;
+    if (obj != null) {
+      if (!obj.swigCMemOwn)
+        throw new RuntimeException("Cannot release ownership as memory is not owned");
+      ptr = obj.swigCPtr;
+      obj.swigCMemOwn = false;
+      obj.delete();
+    }
+    return ptr;
+  }
+
+  @SuppressWarnings("deprecation")
+  protected void finalize() {
+    delete();
+  }
+
+  public synchronized void delete() {
+    if (swigCPtr != 0) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        opensimActuatorsAnalysesToolsJNI.delete_ModOpPrescribeCoordinateValues(swigCPtr);
+      }
+      swigCPtr = 0;
+    }
+    super.delete();
+  }
+
+  public static ModOpPrescribeCoordinateValues safeDownCast(OpenSimObject obj) {
+    long cPtr = opensimActuatorsAnalysesToolsJNI.ModOpPrescribeCoordinateValues_safeDownCast(OpenSimObject.getCPtr(obj), obj);
+    return (cPtr == 0) ? null : new ModOpPrescribeCoordinateValues(cPtr, false);
+  }
+
+  public void assign(OpenSimObject aObject) {
+    opensimActuatorsAnalysesToolsJNI.ModOpPrescribeCoordinateValues_assign(swigCPtr, this, OpenSimObject.getCPtr(aObject), aObject);
+  }
+
+  public static String getClassName() {
+    return opensimActuatorsAnalysesToolsJNI.ModOpPrescribeCoordinateValues_getClassName();
+  }
+
+  public OpenSimObject clone() {
+    long cPtr = opensimActuatorsAnalysesToolsJNI.ModOpPrescribeCoordinateValues_clone(swigCPtr, this);
+    return (cPtr == 0) ? null : new ModOpPrescribeCoordinateValues(cPtr, true);
+  }
+
+  public String getConcreteClassName() {
+    return opensimActuatorsAnalysesToolsJNI.ModOpPrescribeCoordinateValues_getConcreteClassName(swigCPtr, this);
+  }
+
+  public ModOpPrescribeCoordinateValues(TableProcessor table) {
+    this(opensimActuatorsAnalysesToolsJNI.new_ModOpPrescribeCoordinateValues(TableProcessor.getCPtr(table), table), true);
+  }
+
+  public void operate(Model model, String arg1) {
+    opensimActuatorsAnalysesToolsJNI.ModOpPrescribeCoordinateValues_operate(swigCPtr, this, Model.getCPtr(model), model, arg1);
+  }
+
+}
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/ModelComponentIterator.java b/Gui/opensim/modeling/src/org/opensim/modeling/ModelComponentIterator.java
index 5a8e56367..cfe4b326f 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/ModelComponentIterator.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/ModelComponentIterator.java
@@ -601,7 +601,11 @@ public AbstractOutput getOutput(String name) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public int getModelingOption(State state, String path) {
-    return opensimSimulationJNI.ModelComponentIterator_getModelingOption(swigCPtr, this, State.getCPtr(state), state, path);
+    return opensimSimulationJNI.ModelComponentIterator_getModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path);
+  }
+
+  public int getModelingOption(State state, ComponentPath path) {
+    return opensimSimulationJNI.ModelComponentIterator_getModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
@@ -630,7 +634,11 @@ public int getModelingOption(State state, String path) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public void setModelingOption(State state, String path, int flag) {
-    opensimSimulationJNI.ModelComponentIterator_setModelingOption(swigCPtr, this, State.getCPtr(state), state, path, flag);
+    opensimSimulationJNI.ModelComponentIterator_setModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path, flag);
+  }
+
+  public void setModelingOption(State state, ComponentPath path, int flag) {
+    opensimSimulationJNI.ModelComponentIterator_setModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path, flag);
   }
 
   /**
@@ -664,7 +672,7 @@ public double getStateVariableValue(State state, String name) {
    }<br>
    * <br>
    * @param state   the State for which to get the value<br>
-   * <br>
+   * @param path    path to the state variable of interest<br>
    * @throws ComponentHasNoSystem if this Component has not been added to a<br>
    *         System (i.e., if initSystem has not been called)
    */
@@ -729,7 +737,19 @@ public void setStateVariableValues(State state, Vector values) {
    *         System (i.e., if initSystem has not been called)
    */
   public double getStateVariableDerivativeValue(State state, String name) {
-    return opensimSimulationJNI.ModelComponentIterator_getStateVariableDerivativeValue(swigCPtr, this, State.getCPtr(state), state, name);
+    return opensimSimulationJNI.ModelComponentIterator_getStateVariableDerivativeValue__SWIG_0(swigCPtr, this, State.getCPtr(state), state, name);
+  }
+
+  /**
+   * Get the value of a state variable derivative computed by this Component.<br>
+   * <br>
+   * @param state   the State for which to get the derivative value<br>
+   * @param path    path to the state variable of interest<br>
+   * @throws ComponentHasNoSystem if this Component has not been added to a<br>
+   *         System (i.e., if initSystem has not been called)
+   */
+  public double getStateVariableDerivativeValue(State state, ComponentPath path) {
+    return opensimSimulationJNI.ModelComponentIterator_getStateVariableDerivativeValue__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/ModelComponentList.java b/Gui/opensim/modeling/src/org/opensim/modeling/ModelComponentList.java
index 517392f8d..eb477d229 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/ModelComponentList.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/ModelComponentList.java
@@ -60,8 +60,7 @@ public ModelComponentList(Component root, ComponentFilter f) {
 
   /**
    *  Constructor that takes only a Component to iterate over (itself and its<br>
-   *     descendants). ComponentFilterMatchAll is used internally. You can<br>
-   *     change the filter using setFilter() method. 
+   *     descendants). You can change the filter using setFilter() method.
    */
   public ModelComponentList(Component root) {
     this(opensimSimulationJNI.new_ModelComponentList__SWIG_1(Component.getCPtr(root), root), true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MuscleIterator.java b/Gui/opensim/modeling/src/org/opensim/modeling/MuscleIterator.java
index 3c26fcd13..924b98934 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/MuscleIterator.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MuscleIterator.java
@@ -844,6 +844,21 @@ public void addInControls(Vector actuatorControls, Vector modelControls) {
     opensimSimulationJNI.MuscleIterator_addInControls(swigCPtr, this, Vector.getCPtr(actuatorControls), actuatorControls, Vector.getCPtr(modelControls), modelControls);
   }
 
+  /**
+   * Uses `implProduceForces` to produce (emit) forces evaluated from `state` into the<br>
+   * provided `ForceConsumer`.<br>
+   * <br>
+   * Note: this function only produces the forces and does not apply them to anything. It's<br>
+   *       up to the `ForceConsumer` implementation to handle the forces. Therefore,<br>
+   *       `Force::appliesForces` is ignored by this method.<br>
+   * <br>
+   * @param state       the state used to evaluate forces<br>
+   * 
+   */
+  public void produceForces(State state, SWIGTYPE_p_OpenSim__ForceConsumer forceConsumer) {
+    opensimSimulationJNI.MuscleIterator_produceForces(swigCPtr, this, State.getCPtr(state), state, SWIGTYPE_p_OpenSim__ForceConsumer.getCPtr(forceConsumer));
+  }
+
   public boolean get_appliesForce(int i) {
     return opensimSimulationJNI.MuscleIterator_get_appliesForce__SWIG_0(swigCPtr, this, i);
   }
@@ -1358,7 +1373,11 @@ public AbstractOutput getOutput(String name) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public int getModelingOption(State state, String path) {
-    return opensimSimulationJNI.MuscleIterator_getModelingOption(swigCPtr, this, State.getCPtr(state), state, path);
+    return opensimSimulationJNI.MuscleIterator_getModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path);
+  }
+
+  public int getModelingOption(State state, ComponentPath path) {
+    return opensimSimulationJNI.MuscleIterator_getModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
@@ -1387,7 +1406,11 @@ public int getModelingOption(State state, String path) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public void setModelingOption(State state, String path, int flag) {
-    opensimSimulationJNI.MuscleIterator_setModelingOption(swigCPtr, this, State.getCPtr(state), state, path, flag);
+    opensimSimulationJNI.MuscleIterator_setModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path, flag);
+  }
+
+  public void setModelingOption(State state, ComponentPath path, int flag) {
+    opensimSimulationJNI.MuscleIterator_setModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path, flag);
   }
 
   /**
@@ -1421,7 +1444,7 @@ public double getStateVariableValue(State state, String name) {
    }<br>
    * <br>
    * @param state   the State for which to get the value<br>
-   * <br>
+   * @param path    path to the state variable of interest<br>
    * @throws ComponentHasNoSystem if this Component has not been added to a<br>
    *         System (i.e., if initSystem has not been called)
    */
@@ -1486,7 +1509,19 @@ public void setStateVariableValues(State state, Vector values) {
    *         System (i.e., if initSystem has not been called)
    */
   public double getStateVariableDerivativeValue(State state, String name) {
-    return opensimSimulationJNI.MuscleIterator_getStateVariableDerivativeValue(swigCPtr, this, State.getCPtr(state), state, name);
+    return opensimSimulationJNI.MuscleIterator_getStateVariableDerivativeValue__SWIG_0(swigCPtr, this, State.getCPtr(state), state, name);
+  }
+
+  /**
+   * Get the value of a state variable derivative computed by this Component.<br>
+   * <br>
+   * @param state   the State for which to get the derivative value<br>
+   * @param path    path to the state variable of interest<br>
+   * @throws ComponentHasNoSystem if this Component has not been added to a<br>
+   *         System (i.e., if initSystem has not been called)
+   */
+  public double getStateVariableDerivativeValue(State state, ComponentPath path) {
+    return opensimSimulationJNI.MuscleIterator_getStateVariableDerivativeValue__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/MuscleList.java b/Gui/opensim/modeling/src/org/opensim/modeling/MuscleList.java
index db9824469..ca83ba3dd 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/MuscleList.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/MuscleList.java
@@ -60,8 +60,7 @@ public MuscleList(Component root, ComponentFilter f) {
 
   /**
    *  Constructor that takes only a Component to iterate over (itself and its<br>
-   *     descendants). ComponentFilterMatchAll is used internally. You can<br>
-   *     change the filter using setFilter() method. 
+   *     descendants). You can change the filter using setFilter() method.
    */
   public MuscleList(Component root) {
     this(opensimSimulationJNI.new_MuscleList__SWIG_1(Component.getCPtr(root), root), true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/PathActuator.java b/Gui/opensim/modeling/src/org/opensim/modeling/PathActuator.java
index 26c3d849a..bd98dc140 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/PathActuator.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/PathActuator.java
@@ -219,10 +219,6 @@ public void addNewPathPoint(String proposedName, PhysicalFrame aBody, Vec3 aPosi
     opensimSimulationJNI.PathActuator_addNewPathPoint(swigCPtr, this, proposedName, PhysicalFrame.getCPtr(aBody), aBody, Vec3.getCPtr(aPositionOnBody), aPositionOnBody);
   }
 
-  public void computeForce(State state, VectorOfSpatialVec bodyForces, Vector mobilityForces) {
-    opensimSimulationJNI.PathActuator_computeForce(swigCPtr, this, State.getCPtr(state), state, VectorOfSpatialVec.getCPtr(bodyForces), bodyForces, Vector.getCPtr(mobilityForces), mobilityForces);
-  }
-
   public double computeActuation(State s) {
     return opensimSimulationJNI.PathActuator_computeActuation(swigCPtr, this, State.getCPtr(s), s);
   }
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/PathSpring.java b/Gui/opensim/modeling/src/org/opensim/modeling/PathSpring.java
index 1b0eb8cd8..d4cea73b5 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/PathSpring.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/PathSpring.java
@@ -22,7 +22,7 @@
  * <br>
  * @author Ajay Seth
  */
-public class PathSpring extends Force {
+public class PathSpring extends ForceProducer {
   private transient long swigCPtr;
 
   public PathSpring(long cPtr, boolean cMemoryOwn) {
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/PointForceDirection.java b/Gui/opensim/modeling/src/org/opensim/modeling/PointForceDirection.java
index ab7885e5e..132dfb856 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/PointForceDirection.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/PointForceDirection.java
@@ -9,10 +9,10 @@
 package org.opensim.modeling;
 
 /**
- *  Convenience class for a generic representation of geometry of a complex<br>
- *     Force (or any other object) with multiple points of contact through<br>
- *     which forces are applied to bodies. This represents one such point and an<br>
- *     array of these objects defines a complete Force distribution (ie. path).<br>
+ * Convenience class for a generic representation of geometry of a complex<br>
+ * Force (or any other object) with multiple points of contact through<br>
+ * which forces are applied to bodies. This represents one such point and an<br>
+ * array of these objects defines a complete Force distribution (i.e., path).<br>
  * <br>
  * @author Ajay Seth<br>
  * @version 1.0
@@ -57,52 +57,44 @@ public synchronized void delete() {
     }
   }
 
-  /**
-   *  Default constructor takes the point, body, direction and scale<br>
-   *         as arguments 
-   */
-  public PointForceDirection(Vec3 point, PhysicalFrame frame, Vec3 direction, double scale) {
-    this(opensimSimulationJNI.new_PointForceDirection__SWIG_0(Vec3.getCPtr(point), point, PhysicalFrame.getCPtr(frame), frame, Vec3.getCPtr(direction), direction, scale), true);
+  public PointForceDirection(Vec3 point, PhysicalFrame frame, Vec3 direction) {
+    this(opensimSimulationJNI.new_PointForceDirection__SWIG_0(Vec3.getCPtr(point), point, PhysicalFrame.getCPtr(frame), frame, Vec3.getCPtr(direction), direction), true);
   }
 
-  /**
-   *  Default constructor takes the point, body, direction and scale<br>
-   *         as arguments 
-   */
-  public PointForceDirection(Vec3 point, PhysicalFrame frame, Vec3 direction) {
-    this(opensimSimulationJNI.new_PointForceDirection__SWIG_1(Vec3.getCPtr(point), point, PhysicalFrame.getCPtr(frame), frame, Vec3.getCPtr(direction), direction), true);
+  public PointForceDirection(Vec3 point, PhysicalFrame frame, Vec3 direction, double scale) {
+    this(opensimSimulationJNI.new_PointForceDirection__SWIG_1(Vec3.getCPtr(point), point, PhysicalFrame.getCPtr(frame), frame, Vec3.getCPtr(direction), direction, scale), true);
   }
 
   /**
-   *  get point of "contact" with on a body defined in the body frame 
+   *  Returns the point of "contact", defined in `frame()` 
    */
   public Vec3 point() {
     return new Vec3(opensimSimulationJNI.PointForceDirection_point(swigCPtr, this), true);
   }
 
   /**
-   *  get the body in which the point is defined 
+   *  Returns the frame in which `point()` is defined 
    */
   public PhysicalFrame frame() {
     return new PhysicalFrame(opensimSimulationJNI.PointForceDirection_frame(swigCPtr, this), false);
   }
 
   /**
-   *  get direction of the force at the point defined in ground 
+   *  Returns the (potentially, non-unit-length) direction, defined in ground, of the force at `point()` 
    */
   public Vec3 direction() {
     return new Vec3(opensimSimulationJNI.PointForceDirection_direction(swigCPtr, this), true);
   }
 
   /**
-   *  get the scale factor on the force 
+   *  Returns the scale factor of the force 
    */
   public double scale() {
     return opensimSimulationJNI.PointForceDirection_scale(swigCPtr, this);
   }
 
   /**
-   *  replace the current direction with the resultant with a new direction 
+   *  Replaces the current direction with `direction + newDirection` 
    */
   public void addToDirection(Vec3 newDirection) {
     opensimSimulationJNI.PointForceDirection_addToDirection(swigCPtr, this, Vec3.getCPtr(newDirection), newDirection);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/PolynomialPathFitter.java b/Gui/opensim/modeling/src/org/opensim/modeling/PolynomialPathFitter.java
index 7d1717ddf..403313591 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/PolynomialPathFitter.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/PolynomialPathFitter.java
@@ -44,9 +44,9 @@
  * lengths computed from the original model paths and the fitted polynomial<br>
  * paths. The `setNumSamplesPerFrame` method specifies the number of samples<br>
  * taken per time frame in the coordinate values table used to fit each path.<br>
- * The `setNumParallelThreads` method specifies the number of threads used to <br>
- * parallelize the path fitting process. The `setLatinHypercubeAlgorithm` method <br>
- * specifies the Latin hypercube sampling algorithm used to sample coordinate <br>
+ * The `setNumParallelThreads` method specifies the number of threads used to<br>
+ * parallelize the path fitting process. The `setLatinHypercubeAlgorithm` method<br>
+ * specifies the Latin hypercube sampling algorithm used to sample coordinate<br>
  * values for path fitting.<br>
  * <br>
  * The default settings are as follows:<br>
@@ -58,7 +58,7 @@
  *    - Moment arm tolerance: 1e-4 meters<br>
  *    - Path length tolerance: 1e-4 meters<br>
  *    - Number of samples per frame: 25<br>
- *    - Number of threads: (# of available hardware threads) - 2<br>
+ *    - Number of threads: number of available hardware threads<br>
  *    - Latin hypercube sampling algorithm: "random"<br>
  *    - Use stepwise regression: False<br>
  * <br>
@@ -292,10 +292,10 @@ public String getOutputDirectory() {
   }
 
   /**
-   * Whether or not to use stepwise regression to fit a minimal set of <br>
+   * Whether or not to use stepwise regression to fit a minimal set of<br>
    * polynomial coefficients.<br>
    * <br>
-   * Stepwise regression builds a vector of coefficients by individually <br>
+   * Stepwise regression builds a vector of coefficients by individually<br>
    * adding polynomial terms that result in the smallest path length and<br>
    * moment arm error. When a new term is added, the fitting process is<br>
    * repeated to recompute the coefficients. Polynomial terms are added until<br>
@@ -303,7 +303,7 @@ public String getOutputDirectory() {
    * of terms is reached.<br>
    * <br>
    * Note: By default, this setting is false.<br>
-   * Note: If enabled, stepwise regression will fit coefficients using the <br>
+   * Note: If enabled, stepwise regression will fit coefficients using the<br>
    *       maximum polynomial order based on `setMaximumPolynomialOrder()`.
    */
   public void setUseStepwiseRegression(boolean tf) {
@@ -495,8 +495,7 @@ public int getNumSamplesPerFrame() {
    * moment arm computations, and path fitting across multiple threads. The<br>
    * number of threads must be greater than zero.<br>
    * <br>
-   * Note: The default number of threads is set to two fewer than the number<br>
-   *       of available hardware threads.
+   * Note: The default is the number of available hardware threads.
    */
   public void setNumParallelThreads(int numThreads) {
     opensimActuatorsAnalysesToolsJNI.PolynomialPathFitter_setNumParallelThreads(swigCPtr, this, numThreads);
@@ -534,11 +533,11 @@ public String getLatinHypercubeAlgorithm() {
   }
 
   /**
-   * Whether or not to include moment arm functions in the fitted path <br>
+   * Whether or not to include moment arm functions in the fitted path<br>
    * (default: false).<br>
    * <br>
    * The moment arm functions are constructed by taking the derivative of the<br>
-   * path length function with respect to the coordinate values using <br>
+   * path length function with respect to the coordinate values using<br>
    * symbolic differentiation. The function coefficients are negated to match<br>
    * the moment arm convention in OpenSim.
    */
@@ -557,16 +556,16 @@ public boolean getIncludeMomentArmFunctions() {
    * Whether or not to include the lengthening speed function in the fitted<br>
    * path (default: false).<br>
    * <br>
-   * The lengthening speed function is computed by taking dot product of the <br>
-   * moment arm functions by the vector of time derivatives of the coordinate <br>
-   * values using symbolic math. The result is negated to offset the negation <br>
+   * The lengthening speed function is computed by taking dot product of the<br>
+   * moment arm functions by the vector of time derivatives of the coordinate<br>
+   * values using symbolic math. The result is negated to offset the negation<br>
    * applied to the moment arm function expressions.<br>
    * <br>
-   * Note: Since FunctionBasedPath uses cached moment arm values to compute <br>
-   *       lengthening speed, including this function in the path definition <br>
+   * Note: Since FunctionBasedPath uses cached moment arm values to compute<br>
+   *       lengthening speed, including this function in the path definition<br>
    *       may make lengthening speed evaluation slower compared to<br>
    *       only including the moment arm functions (the moment arm expressions<br>
-   *       are effectively evaluated twice). Therefore, this setting is <br>
+   *       are effectively evaluated twice). Therefore, this setting is<br>
    *       disabled by default.
    */
   public void setIncludeLengtheningSpeedFunction(boolean tf) {
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/PrescribedForce.java b/Gui/opensim/modeling/src/org/opensim/modeling/PrescribedForce.java
index 86cad1295..f20107384 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/PrescribedForce.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/PrescribedForce.java
@@ -28,7 +28,7 @@
  * <br>
  * @author Peter Eastman, Matt DeMers
  */
-public class PrescribedForce extends Force {
+public class PrescribedForce extends ForceProducer {
   private transient long swigCPtr;
 
   public PrescribedForce(long cPtr, boolean cMemoryOwn) {
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/SWIGTYPE_p_OpenSim__ForceConsumer.java b/Gui/opensim/modeling/src/org/opensim/modeling/SWIGTYPE_p_OpenSim__ForceConsumer.java
new file mode 100644
index 000000000..bfb98cbc1
--- /dev/null
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/SWIGTYPE_p_OpenSim__ForceConsumer.java
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (https://www.swig.org).
+ * Version 4.1.1
+ *
+ * Do not make changes to this file unless you know what you are doing - modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+package org.opensim.modeling;
+
+public class SWIGTYPE_p_OpenSim__ForceConsumer {
+  private transient long swigCPtr;
+
+  protected SWIGTYPE_p_OpenSim__ForceConsumer(long cPtr, @SuppressWarnings("unused") boolean futureUse) {
+    swigCPtr = cPtr;
+  }
+
+  protected SWIGTYPE_p_OpenSim__ForceConsumer() {
+    swigCPtr = 0;
+  }
+
+  protected static long getCPtr(SWIGTYPE_p_OpenSim__ForceConsumer obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+
+  protected static long swigRelease(SWIGTYPE_p_OpenSim__ForceConsumer obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+}
+
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/SpringGeneralizedForce.java b/Gui/opensim/modeling/src/org/opensim/modeling/SpringGeneralizedForce.java
index 4d48e012b..bfa05bd1e 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/SpringGeneralizedForce.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/SpringGeneralizedForce.java
@@ -15,7 +15,7 @@
  * @author Frank C. Anderson, Ajay Seth<br>
  * @version 2.0
  */
-public class SpringGeneralizedForce extends Force {
+public class SpringGeneralizedForce extends ForceProducer {
   private transient long swigCPtr;
 
   public SpringGeneralizedForce(long cPtr, boolean cMemoryOwn) {
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/SynergyController.java b/Gui/opensim/modeling/src/org/opensim/modeling/SynergyController.java
new file mode 100644
index 000000000..55c56e6e2
--- /dev/null
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/SynergyController.java
@@ -0,0 +1,186 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (https://www.swig.org).
+ * Version 4.1.1
+ *
+ * Do not make changes to this file unless you know what you are doing - modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+package org.opensim.modeling;
+
+/**
+ * <br>
+ * A controller that computes controls for a model based on a linear combination<br>
+ * of a set of Input control signals and a set of synergy vectors. <br>
+ * <br>
+ * Each synergy vector represents a set of control weights that are multiplied <br>
+ * by the Input control signals to compute the contribution to the total control<br>
+ * signal for that synergy. The synergy vectors should have the same size as the<br>
+ * number of actuators connected to the controller, and the controller expects<br>
+ * the number Input controls to be equal to the number of synergy vectors.<br>
+ * <br>
+ * Added synergy vectors are named "synergy_vector_<index>", where &lt;index&gt; is<br>
+ * the index of the vector in the controller (e.g., "synergy_vector_0", <br>
+ * "synergy_vector_1", etc.). Similarly, the Input control labels are named<br>
+ * "synergy_excitation_<index>" (e.g., "synergy_excitation_0",<br>
+ * "synergy_excitation_1", etc.).<br>
+ * <br>
+ * Note: In Moco, SynergyController%s in a model provided to MocoProblem will<br>
+ * be automatically detected. The Input controls for each SynergyController will<br>
+ * be given variable names based on the path to the controller appended with the<br>
+ * Input control labels (e.g., "/path/to/controller/synergy_excitation_0"). 
+ */
+public class SynergyController extends InputController {
+  private transient long swigCPtr;
+
+  public SynergyController(long cPtr, boolean cMemoryOwn) {
+    super(opensimSimulationJNI.SynergyController_SWIGUpcast(cPtr), cMemoryOwn);
+    swigCPtr = cPtr;
+  }
+
+  public static long getCPtr(SynergyController obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+
+  public static long swigRelease(SynergyController obj) {
+    long ptr = 0;
+    if (obj != null) {
+      if (!obj.swigCMemOwn)
+        throw new RuntimeException("Cannot release ownership as memory is not owned");
+      ptr = obj.swigCPtr;
+      obj.swigCMemOwn = false;
+      obj.delete();
+    }
+    return ptr;
+  }
+
+  @SuppressWarnings("deprecation")
+  protected void finalize() {
+    delete();
+  }
+
+  public synchronized void delete() {
+    if (swigCPtr != 0) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        opensimSimulationJNI.delete_SynergyController(swigCPtr);
+      }
+      swigCPtr = 0;
+    }
+    super.delete();
+  }
+
+  public static SynergyController safeDownCast(OpenSimObject obj) {
+    long cPtr = opensimSimulationJNI.SynergyController_safeDownCast(OpenSimObject.getCPtr(obj), obj);
+    return (cPtr == 0) ? null : new SynergyController(cPtr, false);
+  }
+
+  public void assign(OpenSimObject aObject) {
+    opensimSimulationJNI.SynergyController_assign(swigCPtr, this, OpenSimObject.getCPtr(aObject), aObject);
+  }
+
+  public static String getClassName() {
+    return opensimSimulationJNI.SynergyController_getClassName();
+  }
+
+  public OpenSimObject clone() {
+    long cPtr = opensimSimulationJNI.SynergyController_clone(swigCPtr, this);
+    return (cPtr == 0) ? null : new SynergyController(cPtr, true);
+  }
+
+  public String getConcreteClassName() {
+    return opensimSimulationJNI.SynergyController_getConcreteClassName(swigCPtr, this);
+  }
+
+  public void copyProperty_synergy_vectors(SynergyController source) {
+    opensimSimulationJNI.SynergyController_copyProperty_synergy_vectors(swigCPtr, this, SynergyController.getCPtr(source), source);
+  }
+
+  public SynergyVector get_synergy_vectors(int i) {
+    return new SynergyVector(opensimSimulationJNI.SynergyController_get_synergy_vectors(swigCPtr, this, i), false);
+  }
+
+  public SynergyVector upd_synergy_vectors(int i) {
+    return new SynergyVector(opensimSimulationJNI.SynergyController_upd_synergy_vectors(swigCPtr, this, i), false);
+  }
+
+  public void set_synergy_vectors(int i, SynergyVector value) {
+    opensimSimulationJNI.SynergyController_set_synergy_vectors(swigCPtr, this, i, SynergyVector.getCPtr(value), value);
+  }
+
+  public int append_synergy_vectors(SynergyVector value) {
+    return opensimSimulationJNI.SynergyController_append_synergy_vectors(swigCPtr, this, SynergyVector.getCPtr(value), value);
+  }
+
+  public void constructProperty_synergy_vectors() {
+    opensimSimulationJNI.SynergyController_constructProperty_synergy_vectors(swigCPtr, this);
+  }
+
+  public SynergyController() {
+    this(opensimSimulationJNI.new_SynergyController__SWIG_0(), true);
+  }
+
+  public SynergyController(SynergyController other) {
+    this(opensimSimulationJNI.new_SynergyController__SWIG_1(SynergyController.getCPtr(other), other), true);
+  }
+
+  /**
+   * Add a synergy vector to the controller. <br>
+   * <br>
+   * The size of the vector should be equal to the number of actuators<br>
+   * connected to the controller. Adding a synergy vector increases the number<br>
+   * of control inputs expected by the controller by one.
+   */
+  public void addSynergyVector(Vector vector) {
+    opensimSimulationJNI.SynergyController_addSynergyVector(swigCPtr, this, Vector.getCPtr(vector), vector);
+  }
+
+  /**
+   * Update an existing synergy vector in the controller. <br>
+   * <br>
+   * The size of the vector should be equal to the number of actuators<br>
+   * connected to the controller. 
+   */
+  public void updSynergyVector(int index, Vector vector) {
+    opensimSimulationJNI.SynergyController_updSynergyVector(swigCPtr, this, index, Vector.getCPtr(vector), vector);
+  }
+
+  /**
+   * Get a synergy vector by index. 
+   */
+  public Vector getSynergyVector(int index) {
+    return new Vector(opensimSimulationJNI.SynergyController_getSynergyVector(swigCPtr, this, index), false);
+  }
+
+  /**
+   * Get the number of synergies vectors in the controller. <br>
+   * <br>
+   * The controller expects this number of control Inputs to be connected when<br>
+   * the connections are finalized in the model.
+   */
+  public int getNumSynergies() {
+    return opensimSimulationJNI.SynergyController_getNumSynergies(swigCPtr, this);
+  }
+
+  /**
+   * Get all synergy vectors as a matrix. <br>
+   * <br>
+   * The number of rows in the matrix is equal to the number of actuators<br>
+   * connected to the controller, and the number of columns is equal to the<br>
+   * number of synergy vectors in the controller. <br>
+   * <br>
+   * 
+   */
+  public Matrix getSynergyVectorsAsMatrix() {
+    return new Matrix(opensimSimulationJNI.SynergyController_getSynergyVectorsAsMatrix(swigCPtr, this), true);
+  }
+
+  public StdVectorString getInputControlLabels() {
+    return new StdVectorString(opensimSimulationJNI.SynergyController_getInputControlLabels(swigCPtr, this), true);
+  }
+
+  public void computeControlsImpl(State s, Vector controls) {
+    opensimSimulationJNI.SynergyController_computeControlsImpl(swigCPtr, this, State.getCPtr(s), s, Vector.getCPtr(controls), controls);
+  }
+
+}
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/SynergyVector.java b/Gui/opensim/modeling/src/org/opensim/modeling/SynergyVector.java
new file mode 100644
index 000000000..0504a0ea7
--- /dev/null
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/SynergyVector.java
@@ -0,0 +1,123 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (https://www.swig.org).
+ * Version 4.1.1
+ *
+ * Do not make changes to this file unless you know what you are doing - modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+package org.opensim.modeling;
+
+/**
+ * <br>
+ * A vector that represents the control weights for a single synergy in a <br>
+ * SynergyController. The size of the vector should be equal to the number of <br>
+ * actuators connected to the controller.
+ */
+public class SynergyVector extends OpenSimObject {
+  private transient long swigCPtr;
+
+  public SynergyVector(long cPtr, boolean cMemoryOwn) {
+    super(opensimSimulationJNI.SynergyVector_SWIGUpcast(cPtr), cMemoryOwn);
+    swigCPtr = cPtr;
+  }
+
+  public static long getCPtr(SynergyVector obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+
+  public static long swigRelease(SynergyVector obj) {
+    long ptr = 0;
+    if (obj != null) {
+      if (!obj.swigCMemOwn)
+        throw new RuntimeException("Cannot release ownership as memory is not owned");
+      ptr = obj.swigCPtr;
+      obj.swigCMemOwn = false;
+      obj.delete();
+    }
+    return ptr;
+  }
+
+  @SuppressWarnings("deprecation")
+  protected void finalize() {
+    delete();
+  }
+
+  public synchronized void delete() {
+    if (swigCPtr != 0) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        opensimSimulationJNI.delete_SynergyVector(swigCPtr);
+      }
+      swigCPtr = 0;
+    }
+    super.delete();
+  }
+
+  public static SynergyVector safeDownCast(OpenSimObject obj) {
+    long cPtr = opensimSimulationJNI.SynergyVector_safeDownCast(OpenSimObject.getCPtr(obj), obj);
+    return (cPtr == 0) ? null : new SynergyVector(cPtr, false);
+  }
+
+  public void assign(OpenSimObject aObject) {
+    opensimSimulationJNI.SynergyVector_assign(swigCPtr, this, OpenSimObject.getCPtr(aObject), aObject);
+  }
+
+  public static String getClassName() {
+    return opensimSimulationJNI.SynergyVector_getClassName();
+  }
+
+  public OpenSimObject clone() {
+    long cPtr = opensimSimulationJNI.SynergyVector_clone(swigCPtr, this);
+    return (cPtr == 0) ? null : new SynergyVector(cPtr, true);
+  }
+
+  public String getConcreteClassName() {
+    return opensimSimulationJNI.SynergyVector_getConcreteClassName(swigCPtr, this);
+  }
+
+  public void copyProperty_synergy_weights(SynergyVector source) {
+    opensimSimulationJNI.SynergyVector_copyProperty_synergy_weights(swigCPtr, this, SynergyVector.getCPtr(source), source);
+  }
+
+  public Vector get_synergy_weights(int i) {
+    return new Vector(opensimSimulationJNI.SynergyVector_get_synergy_weights__SWIG_0(swigCPtr, this, i), false);
+  }
+
+  public Vector upd_synergy_weights(int i) {
+    return new Vector(opensimSimulationJNI.SynergyVector_upd_synergy_weights__SWIG_0(swigCPtr, this, i), false);
+  }
+
+  public void set_synergy_weights(int i, Vector value) {
+    opensimSimulationJNI.SynergyVector_set_synergy_weights__SWIG_0(swigCPtr, this, i, Vector.getCPtr(value), value);
+  }
+
+  public int append_synergy_weights(Vector value) {
+    return opensimSimulationJNI.SynergyVector_append_synergy_weights(swigCPtr, this, Vector.getCPtr(value), value);
+  }
+
+  public void constructProperty_synergy_weights(Vector initValue) {
+    opensimSimulationJNI.SynergyVector_constructProperty_synergy_weights(swigCPtr, this, Vector.getCPtr(initValue), initValue);
+  }
+
+  public Vector get_synergy_weights() {
+    return new Vector(opensimSimulationJNI.SynergyVector_get_synergy_weights__SWIG_1(swigCPtr, this), false);
+  }
+
+  public Vector upd_synergy_weights() {
+    return new Vector(opensimSimulationJNI.SynergyVector_upd_synergy_weights__SWIG_1(swigCPtr, this), false);
+  }
+
+  public void set_synergy_weights(Vector value) {
+    opensimSimulationJNI.SynergyVector_set_synergy_weights__SWIG_1(swigCPtr, this, Vector.getCPtr(value), value);
+  }
+
+  public SynergyVector() {
+    this(opensimSimulationJNI.new_SynergyVector__SWIG_0(), true);
+  }
+
+  public SynergyVector(String name, Vector weights) {
+    this(opensimSimulationJNI.new_SynergyVector__SWIG_1(name, Vector.getCPtr(weights), weights), true);
+  }
+
+}
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/TabOpAppendCoordinateValueDerivativesAsSpeeds.java b/Gui/opensim/modeling/src/org/opensim/modeling/TabOpAppendCoordinateValueDerivativesAsSpeeds.java
index 2fa7258b1..55914456a 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/TabOpAppendCoordinateValueDerivativesAsSpeeds.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/TabOpAppendCoordinateValueDerivativesAsSpeeds.java
@@ -10,7 +10,7 @@
 
 /**
  *  Invoke SimulationUtilities::appendCoordinateValueDerivativesAsSpeeds() on<br>
- * the table 
+ * the table. 
  */
 public class TabOpAppendCoordinateValueDerivativesAsSpeeds extends TableOperator {
   private transient long swigCPtr;
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/Thelen2003MuscleIterator.java b/Gui/opensim/modeling/src/org/opensim/modeling/Thelen2003MuscleIterator.java
index ce1ca698c..70592c317 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/Thelen2003MuscleIterator.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/Thelen2003MuscleIterator.java
@@ -1024,6 +1024,21 @@ public void addInControls(Vector actuatorControls, Vector modelControls) {
     opensimSimulationJNI.Thelen2003MuscleIterator_addInControls(swigCPtr, this, Vector.getCPtr(actuatorControls), actuatorControls, Vector.getCPtr(modelControls), modelControls);
   }
 
+  /**
+   * Uses `implProduceForces` to produce (emit) forces evaluated from `state` into the<br>
+   * provided `ForceConsumer`.<br>
+   * <br>
+   * Note: this function only produces the forces and does not apply them to anything. It's<br>
+   *       up to the `ForceConsumer` implementation to handle the forces. Therefore,<br>
+   *       `Force::appliesForces` is ignored by this method.<br>
+   * <br>
+   * @param state       the state used to evaluate forces<br>
+   * 
+   */
+  public void produceForces(State state, SWIGTYPE_p_OpenSim__ForceConsumer forceConsumer) {
+    opensimSimulationJNI.Thelen2003MuscleIterator_produceForces(swigCPtr, this, State.getCPtr(state), state, SWIGTYPE_p_OpenSim__ForceConsumer.getCPtr(forceConsumer));
+  }
+
   public boolean get_appliesForce(int i) {
     return opensimSimulationJNI.Thelen2003MuscleIterator_get_appliesForce__SWIG_0(swigCPtr, this, i);
   }
@@ -1538,7 +1553,11 @@ public AbstractOutput getOutput(String name) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public int getModelingOption(State state, String path) {
-    return opensimSimulationJNI.Thelen2003MuscleIterator_getModelingOption(swigCPtr, this, State.getCPtr(state), state, path);
+    return opensimSimulationJNI.Thelen2003MuscleIterator_getModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path);
+  }
+
+  public int getModelingOption(State state, ComponentPath path) {
+    return opensimSimulationJNI.Thelen2003MuscleIterator_getModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
@@ -1567,7 +1586,11 @@ public int getModelingOption(State state, String path) {
    * @see Component#resolveVariableNameAndOwner()
    */
   public void setModelingOption(State state, String path, int flag) {
-    opensimSimulationJNI.Thelen2003MuscleIterator_setModelingOption(swigCPtr, this, State.getCPtr(state), state, path, flag);
+    opensimSimulationJNI.Thelen2003MuscleIterator_setModelingOption__SWIG_0(swigCPtr, this, State.getCPtr(state), state, path, flag);
+  }
+
+  public void setModelingOption(State state, ComponentPath path, int flag) {
+    opensimSimulationJNI.Thelen2003MuscleIterator_setModelingOption__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path, flag);
   }
 
   /**
@@ -1601,7 +1624,7 @@ public double getStateVariableValue(State state, String name) {
    }<br>
    * <br>
    * @param state   the State for which to get the value<br>
-   * <br>
+   * @param path    path to the state variable of interest<br>
    * @throws ComponentHasNoSystem if this Component has not been added to a<br>
    *         System (i.e., if initSystem has not been called)
    */
@@ -1666,7 +1689,19 @@ public void setStateVariableValues(State state, Vector values) {
    *         System (i.e., if initSystem has not been called)
    */
   public double getStateVariableDerivativeValue(State state, String name) {
-    return opensimSimulationJNI.Thelen2003MuscleIterator_getStateVariableDerivativeValue(swigCPtr, this, State.getCPtr(state), state, name);
+    return opensimSimulationJNI.Thelen2003MuscleIterator_getStateVariableDerivativeValue__SWIG_0(swigCPtr, this, State.getCPtr(state), state, name);
+  }
+
+  /**
+   * Get the value of a state variable derivative computed by this Component.<br>
+   * <br>
+   * @param state   the State for which to get the derivative value<br>
+   * @param path    path to the state variable of interest<br>
+   * @throws ComponentHasNoSystem if this Component has not been added to a<br>
+   *         System (i.e., if initSystem has not been called)
+   */
+  public double getStateVariableDerivativeValue(State state, ComponentPath path) {
+    return opensimSimulationJNI.Thelen2003MuscleIterator_getStateVariableDerivativeValue__SWIG_1(swigCPtr, this, State.getCPtr(state), state, ComponentPath.getCPtr(path), path);
   }
 
   /**
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/Thelen2003MuscleList.java b/Gui/opensim/modeling/src/org/opensim/modeling/Thelen2003MuscleList.java
index dd12e9834..df514b33f 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/Thelen2003MuscleList.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/Thelen2003MuscleList.java
@@ -60,8 +60,7 @@ public Thelen2003MuscleList(Component root, ComponentFilter f) {
 
   /**
    *  Constructor that takes only a Component to iterate over (itself and its<br>
-   *     descendants). ComponentFilterMatchAll is used internally. You can<br>
-   *     change the filter using setFilter() method. 
+   *     descendants). You can change the filter using setFilter() method.
    */
   public Thelen2003MuscleList(Component root) {
     this(opensimSimulationJNI.new_Thelen2003MuscleList__SWIG_1(Component.getCPtr(root), root), true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTable.java b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTable.java
index 03271f4d8..e94ac6ef3 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTable.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTable.java
@@ -252,10 +252,11 @@ public RowVector averageRow(double beginTime, double endTime) {
   }
 
   /**
-   * Trim TimeSeriesTable to rows that have times that lies between <br>
-   * newStartTime, newFinalTime. The trimming is done in place, no copy is made. <br>
+   * Trim TimeSeriesTable to rows that have times that lies between newStartTime<br>
+   * and newFinalTime (inclusive). The trimming is done in place, no copy is made.<br>
    * Uses getRowIndexAfterTime to locate first row and<br>
-   * getNearestRowIndexForTime method to locate last row.
+   *      getRowIndexBeforeTime to locate last row.<br>
+   * @throws EmptyTable if the trim would make the table empty.
    */
   public void trim(double newStartTime, double newFinalTime) {
     opensimCommonJNI.TimeSeriesTable_trim(swigCPtr, this, newStartTime, newFinalTime);
@@ -275,6 +276,15 @@ public void trimTo(double newFinalTime) {
     opensimCommonJNI.TimeSeriesTable_trimTo(swigCPtr, this, newFinalTime);
   }
 
+  /**
+   * Trim table to rows between start_index and last_index (inclusive).<br>
+   * @throws InvalidIndices if the last index is out of range.<br>
+   * @throws EmptyTable if the trim would make the table empty.
+   */
+  public void trimToIndices(long start_index, long last_index) {
+    opensimCommonJNI.TimeSeriesTable_trimToIndices(swigCPtr, this, start_index, last_index);
+  }
+
   public TimeSeriesTable clone() {
     long cPtr = opensimCommonJNI.TimeSeriesTable_clone(swigCPtr, this);
     return (cPtr == 0) ? null : new TimeSeriesTable(cPtr, true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableMat33.java b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableMat33.java
index d03fb67c2..f5c8ea6f4 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableMat33.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableMat33.java
@@ -252,10 +252,11 @@ public RowVectorMat33 averageRow(double beginTime, double endTime) {
   }
 
   /**
-   * Trim TimeSeriesTable to rows that have times that lies between <br>
-   * newStartTime, newFinalTime. The trimming is done in place, no copy is made. <br>
+   * Trim TimeSeriesTable to rows that have times that lies between newStartTime<br>
+   * and newFinalTime (inclusive). The trimming is done in place, no copy is made.<br>
    * Uses getRowIndexAfterTime to locate first row and<br>
-   * getNearestRowIndexForTime method to locate last row.
+   *      getRowIndexBeforeTime to locate last row.<br>
+   * @throws EmptyTable if the trim would make the table empty.
    */
   public void trim(double newStartTime, double newFinalTime) {
     opensimCommonJNI.TimeSeriesTableMat33_trim(swigCPtr, this, newStartTime, newFinalTime);
@@ -275,6 +276,15 @@ public void trimTo(double newFinalTime) {
     opensimCommonJNI.TimeSeriesTableMat33_trimTo(swigCPtr, this, newFinalTime);
   }
 
+  /**
+   * Trim table to rows between start_index and last_index (inclusive).<br>
+   * @throws InvalidIndices if the last index is out of range.<br>
+   * @throws EmptyTable if the trim would make the table empty.
+   */
+  public void trimToIndices(long start_index, long last_index) {
+    opensimCommonJNI.TimeSeriesTableMat33_trimToIndices(swigCPtr, this, start_index, last_index);
+  }
+
   public TimeSeriesTableMat33 clone() {
     long cPtr = opensimCommonJNI.TimeSeriesTableMat33_clone(swigCPtr, this);
     return (cPtr == 0) ? null : new TimeSeriesTableMat33(cPtr, true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableQuaternion.java b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableQuaternion.java
index 65c1da90b..dd109bf9d 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableQuaternion.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableQuaternion.java
@@ -252,10 +252,11 @@ public RowVectorQuaternion averageRow(double beginTime, double endTime) {
   }
 
   /**
-   * Trim TimeSeriesTable to rows that have times that lies between <br>
-   * newStartTime, newFinalTime. The trimming is done in place, no copy is made. <br>
+   * Trim TimeSeriesTable to rows that have times that lies between newStartTime<br>
+   * and newFinalTime (inclusive). The trimming is done in place, no copy is made.<br>
    * Uses getRowIndexAfterTime to locate first row and<br>
-   * getNearestRowIndexForTime method to locate last row.
+   *      getRowIndexBeforeTime to locate last row.<br>
+   * @throws EmptyTable if the trim would make the table empty.
    */
   public void trim(double newStartTime, double newFinalTime) {
     opensimCommonJNI.TimeSeriesTableQuaternion_trim(swigCPtr, this, newStartTime, newFinalTime);
@@ -275,6 +276,15 @@ public void trimTo(double newFinalTime) {
     opensimCommonJNI.TimeSeriesTableQuaternion_trimTo(swigCPtr, this, newFinalTime);
   }
 
+  /**
+   * Trim table to rows between start_index and last_index (inclusive).<br>
+   * @throws InvalidIndices if the last index is out of range.<br>
+   * @throws EmptyTable if the trim would make the table empty.
+   */
+  public void trimToIndices(long start_index, long last_index) {
+    opensimCommonJNI.TimeSeriesTableQuaternion_trimToIndices(swigCPtr, this, start_index, last_index);
+  }
+
   public TimeSeriesTableQuaternion clone() {
     long cPtr = opensimCommonJNI.TimeSeriesTableQuaternion_clone(swigCPtr, this);
     return (cPtr == 0) ? null : new TimeSeriesTableQuaternion(cPtr, true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableRotation.java b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableRotation.java
index 654c46c0c..f70563e89 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableRotation.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableRotation.java
@@ -252,10 +252,11 @@ public RowVectorRotation averageRow(double beginTime, double endTime) {
   }
 
   /**
-   * Trim TimeSeriesTable to rows that have times that lies between <br>
-   * newStartTime, newFinalTime. The trimming is done in place, no copy is made. <br>
+   * Trim TimeSeriesTable to rows that have times that lies between newStartTime<br>
+   * and newFinalTime (inclusive). The trimming is done in place, no copy is made.<br>
    * Uses getRowIndexAfterTime to locate first row and<br>
-   * getNearestRowIndexForTime method to locate last row.
+   *      getRowIndexBeforeTime to locate last row.<br>
+   * @throws EmptyTable if the trim would make the table empty.
    */
   public void trim(double newStartTime, double newFinalTime) {
     opensimCommonJNI.TimeSeriesTableRotation_trim(swigCPtr, this, newStartTime, newFinalTime);
@@ -275,6 +276,15 @@ public void trimTo(double newFinalTime) {
     opensimCommonJNI.TimeSeriesTableRotation_trimTo(swigCPtr, this, newFinalTime);
   }
 
+  /**
+   * Trim table to rows between start_index and last_index (inclusive).<br>
+   * @throws InvalidIndices if the last index is out of range.<br>
+   * @throws EmptyTable if the trim would make the table empty.
+   */
+  public void trimToIndices(long start_index, long last_index) {
+    opensimCommonJNI.TimeSeriesTableRotation_trimToIndices(swigCPtr, this, start_index, last_index);
+  }
+
   public TimeSeriesTableRotation clone() {
     long cPtr = opensimCommonJNI.TimeSeriesTableRotation_clone(swigCPtr, this);
     return (cPtr == 0) ? null : new TimeSeriesTableRotation(cPtr, true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableSpatialVec.java b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableSpatialVec.java
index d860452ac..a493e41c4 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableSpatialVec.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableSpatialVec.java
@@ -252,10 +252,11 @@ public SWIGTYPE_p_SimTK__RowVector_T_SimTK__VecT_2_SimTK__Vec3_1_t_t averageRow(
   }
 
   /**
-   * Trim TimeSeriesTable to rows that have times that lies between <br>
-   * newStartTime, newFinalTime. The trimming is done in place, no copy is made. <br>
+   * Trim TimeSeriesTable to rows that have times that lies between newStartTime<br>
+   * and newFinalTime (inclusive). The trimming is done in place, no copy is made.<br>
    * Uses getRowIndexAfterTime to locate first row and<br>
-   * getNearestRowIndexForTime method to locate last row.
+   *      getRowIndexBeforeTime to locate last row.<br>
+   * @throws EmptyTable if the trim would make the table empty.
    */
   public void trim(double newStartTime, double newFinalTime) {
     opensimCommonJNI.TimeSeriesTableSpatialVec_trim(swigCPtr, this, newStartTime, newFinalTime);
@@ -275,6 +276,15 @@ public void trimTo(double newFinalTime) {
     opensimCommonJNI.TimeSeriesTableSpatialVec_trimTo(swigCPtr, this, newFinalTime);
   }
 
+  /**
+   * Trim table to rows between start_index and last_index (inclusive).<br>
+   * @throws InvalidIndices if the last index is out of range.<br>
+   * @throws EmptyTable if the trim would make the table empty.
+   */
+  public void trimToIndices(long start_index, long last_index) {
+    opensimCommonJNI.TimeSeriesTableSpatialVec_trimToIndices(swigCPtr, this, start_index, last_index);
+  }
+
   public TimeSeriesTableSpatialVec clone() {
     long cPtr = opensimCommonJNI.TimeSeriesTableSpatialVec_clone(swigCPtr, this);
     return (cPtr == 0) ? null : new TimeSeriesTableSpatialVec(cPtr, true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableUnitVec3.java b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableUnitVec3.java
index b8f8442aa..d6c71cdf7 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableUnitVec3.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableUnitVec3.java
@@ -252,10 +252,11 @@ public SWIGTYPE_p_SimTK__RowVector_T_SimTK__UnitVecT_double_1_t_t averageRow(dou
   }
 
   /**
-   * Trim TimeSeriesTable to rows that have times that lies between <br>
-   * newStartTime, newFinalTime. The trimming is done in place, no copy is made. <br>
+   * Trim TimeSeriesTable to rows that have times that lies between newStartTime<br>
+   * and newFinalTime (inclusive). The trimming is done in place, no copy is made.<br>
    * Uses getRowIndexAfterTime to locate first row and<br>
-   * getNearestRowIndexForTime method to locate last row.
+   *      getRowIndexBeforeTime to locate last row.<br>
+   * @throws EmptyTable if the trim would make the table empty.
    */
   public void trim(double newStartTime, double newFinalTime) {
     opensimCommonJNI.TimeSeriesTableUnitVec3_trim(swigCPtr, this, newStartTime, newFinalTime);
@@ -275,6 +276,15 @@ public void trimTo(double newFinalTime) {
     opensimCommonJNI.TimeSeriesTableUnitVec3_trimTo(swigCPtr, this, newFinalTime);
   }
 
+  /**
+   * Trim table to rows between start_index and last_index (inclusive).<br>
+   * @throws InvalidIndices if the last index is out of range.<br>
+   * @throws EmptyTable if the trim would make the table empty.
+   */
+  public void trimToIndices(long start_index, long last_index) {
+    opensimCommonJNI.TimeSeriesTableUnitVec3_trimToIndices(swigCPtr, this, start_index, last_index);
+  }
+
   public TimeSeriesTableUnitVec3 clone() {
     long cPtr = opensimCommonJNI.TimeSeriesTableUnitVec3_clone(swigCPtr, this);
     return (cPtr == 0) ? null : new TimeSeriesTableUnitVec3(cPtr, true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableVec3.java b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableVec3.java
index 8f84444ae..907d41500 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableVec3.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableVec3.java
@@ -252,10 +252,11 @@ public RowVectorVec3 averageRow(double beginTime, double endTime) {
   }
 
   /**
-   * Trim TimeSeriesTable to rows that have times that lies between <br>
-   * newStartTime, newFinalTime. The trimming is done in place, no copy is made. <br>
+   * Trim TimeSeriesTable to rows that have times that lies between newStartTime<br>
+   * and newFinalTime (inclusive). The trimming is done in place, no copy is made.<br>
    * Uses getRowIndexAfterTime to locate first row and<br>
-   * getNearestRowIndexForTime method to locate last row.
+   *      getRowIndexBeforeTime to locate last row.<br>
+   * @throws EmptyTable if the trim would make the table empty.
    */
   public void trim(double newStartTime, double newFinalTime) {
     opensimCommonJNI.TimeSeriesTableVec3_trim(swigCPtr, this, newStartTime, newFinalTime);
@@ -275,6 +276,15 @@ public void trimTo(double newFinalTime) {
     opensimCommonJNI.TimeSeriesTableVec3_trimTo(swigCPtr, this, newFinalTime);
   }
 
+  /**
+   * Trim table to rows between start_index and last_index (inclusive).<br>
+   * @throws InvalidIndices if the last index is out of range.<br>
+   * @throws EmptyTable if the trim would make the table empty.
+   */
+  public void trimToIndices(long start_index, long last_index) {
+    opensimCommonJNI.TimeSeriesTableVec3_trimToIndices(swigCPtr, this, start_index, last_index);
+  }
+
   public TimeSeriesTableVec3 clone() {
     long cPtr = opensimCommonJNI.TimeSeriesTableVec3_clone(swigCPtr, this);
     return (cPtr == 0) ? null : new TimeSeriesTableVec3(cPtr, true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableVec6.java b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableVec6.java
index 5476a9348..e9f64ec97 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableVec6.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/TimeSeriesTableVec6.java
@@ -252,10 +252,11 @@ public RowVectorVec6 averageRow(double beginTime, double endTime) {
   }
 
   /**
-   * Trim TimeSeriesTable to rows that have times that lies between <br>
-   * newStartTime, newFinalTime. The trimming is done in place, no copy is made. <br>
+   * Trim TimeSeriesTable to rows that have times that lies between newStartTime<br>
+   * and newFinalTime (inclusive). The trimming is done in place, no copy is made.<br>
    * Uses getRowIndexAfterTime to locate first row and<br>
-   * getNearestRowIndexForTime method to locate last row.
+   *      getRowIndexBeforeTime to locate last row.<br>
+   * @throws EmptyTable if the trim would make the table empty.
    */
   public void trim(double newStartTime, double newFinalTime) {
     opensimCommonJNI.TimeSeriesTableVec6_trim(swigCPtr, this, newStartTime, newFinalTime);
@@ -275,6 +276,15 @@ public void trimTo(double newFinalTime) {
     opensimCommonJNI.TimeSeriesTableVec6_trimTo(swigCPtr, this, newFinalTime);
   }
 
+  /**
+   * Trim table to rows between start_index and last_index (inclusive).<br>
+   * @throws InvalidIndices if the last index is out of range.<br>
+   * @throws EmptyTable if the trim would make the table empty.
+   */
+  public void trimToIndices(long start_index, long last_index) {
+    opensimCommonJNI.TimeSeriesTableVec6_trimToIndices(swigCPtr, this, start_index, last_index);
+  }
+
   public TimeSeriesTableVec6 clone() {
     long cPtr = opensimCommonJNI.TimeSeriesTableVec6_clone(swigCPtr, this);
     return (cPtr == 0) ? null : new TimeSeriesTableVec6(cPtr, true);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/TwoFrameLinkerForceProducer.java b/Gui/opensim/modeling/src/org/opensim/modeling/TwoFrameLinkerForceProducer.java
new file mode 100644
index 000000000..ac015ed40
--- /dev/null
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/TwoFrameLinkerForceProducer.java
@@ -0,0 +1,202 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (https://www.swig.org).
+ * Version 4.1.1
+ *
+ * Do not make changes to this file unless you know what you are doing - modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+package org.opensim.modeling;
+
+/**
+ * TwoFrameLinker is a utility class to extend a Component such that it connects<br>
+ * two Frames. For example, a WeldConstraint and BushingForces operate between<br>
+ * two frames to restrict their motion. A TwoFrameLinker&lt;Force, PhysicalFrame&gt;,<br>
+ * for example, is a Force that operates between two PhyscialFrames and it is <br>
+ * the base class for BushingForces.<br>
+ * (A class whose super class is a template parameter is called a mixin class.)<br>
+ * <br>
+ * {@code 
+   class BushingForce : public TwoFrameLinker<Force, PhysicalFrame>
+}<br>
+ * <br>
+ * <br>
+ * <br>
+ * <br>
+ * @author Ajay Seth
+ */
+public class TwoFrameLinkerForceProducer extends ForceProducer {
+  private transient long swigCPtr;
+
+  public TwoFrameLinkerForceProducer(long cPtr, boolean cMemoryOwn) {
+    super(opensimSimulationJNI.TwoFrameLinkerForceProducer_SWIGUpcast(cPtr), cMemoryOwn);
+    swigCPtr = cPtr;
+  }
+
+  public static long getCPtr(TwoFrameLinkerForceProducer obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
+
+  public static long swigRelease(TwoFrameLinkerForceProducer obj) {
+    long ptr = 0;
+    if (obj != null) {
+      if (!obj.swigCMemOwn)
+        throw new RuntimeException("Cannot release ownership as memory is not owned");
+      ptr = obj.swigCPtr;
+      obj.swigCMemOwn = false;
+      obj.delete();
+    }
+    return ptr;
+  }
+
+  @SuppressWarnings("deprecation")
+  protected void finalize() {
+    delete();
+  }
+
+  public synchronized void delete() {
+    if (swigCPtr != 0) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        opensimSimulationJNI.delete_TwoFrameLinkerForceProducer(swigCPtr);
+      }
+      swigCPtr = 0;
+    }
+    super.delete();
+  }
+
+  public static TwoFrameLinkerForceProducer safeDownCast(OpenSimObject obj) {
+    long cPtr = opensimSimulationJNI.TwoFrameLinkerForceProducer_safeDownCast(OpenSimObject.getCPtr(obj), obj);
+    return (cPtr == 0) ? null : new TwoFrameLinkerForceProducer(cPtr, false);
+  }
+
+  public void assign(OpenSimObject aObject) {
+    opensimSimulationJNI.TwoFrameLinkerForceProducer_assign(swigCPtr, this, OpenSimObject.getCPtr(aObject), aObject);
+  }
+
+  public static String getClassName() {
+    return opensimSimulationJNI.TwoFrameLinkerForceProducer_getClassName();
+  }
+
+  public OpenSimObject clone() {
+    long cPtr = opensimSimulationJNI.TwoFrameLinkerForceProducer_clone(swigCPtr, this);
+    return (cPtr == 0) ? null : new TwoFrameLinkerForceProducer(cPtr, true);
+  }
+
+  public String getConcreteClassName() {
+    return opensimSimulationJNI.TwoFrameLinkerForceProducer_getConcreteClassName(swigCPtr, this);
+  }
+
+  /**
+   *  Frames added to satisfy the sockets of this TwoFrameLinker Component
+   */
+  public void copyProperty_frames(TwoFrameLinkerForceProducer source) {
+    opensimSimulationJNI.TwoFrameLinkerForceProducer_copyProperty_frames(swigCPtr, this, TwoFrameLinkerForceProducer.getCPtr(source), source);
+  }
+
+  public PhysicalFrame get_frames(int i) {
+    return new PhysicalFrame(opensimSimulationJNI.TwoFrameLinkerForceProducer_get_frames(swigCPtr, this, i), false);
+  }
+
+  public PhysicalFrame upd_frames(int i) {
+    return new PhysicalFrame(opensimSimulationJNI.TwoFrameLinkerForceProducer_upd_frames(swigCPtr, this, i), false);
+  }
+
+  public void set_frames(int i, PhysicalFrame value) {
+    opensimSimulationJNI.TwoFrameLinkerForceProducer_set_frames(swigCPtr, this, i, PhysicalFrame.getCPtr(value), value);
+  }
+
+  public int append_frames(PhysicalFrame value) {
+    return opensimSimulationJNI.TwoFrameLinkerForceProducer_append_frames(swigCPtr, this, PhysicalFrame.getCPtr(value), value);
+  }
+
+  public void constructProperty_frames() {
+    opensimSimulationJNI.TwoFrameLinkerForceProducer_constructProperty_frames(swigCPtr, this);
+  }
+
+  public void setPropertyIndex_socket_frame1(SWIGTYPE_p_OpenSim__PropertyIndex value) {
+    opensimSimulationJNI.TwoFrameLinkerForceProducer_PropertyIndex_socket_frame1_set(swigCPtr, this, SWIGTYPE_p_OpenSim__PropertyIndex.getCPtr(value));
+  }
+
+  public SWIGTYPE_p_OpenSim__PropertyIndex getPropertyIndex_socket_frame1() {
+    return new SWIGTYPE_p_OpenSim__PropertyIndex(opensimSimulationJNI.TwoFrameLinkerForceProducer_PropertyIndex_socket_frame1_get(swigCPtr, this), true);
+  }
+
+  public void connectSocket_frame1(OpenSimObject object) {
+    opensimSimulationJNI.TwoFrameLinkerForceProducer_connectSocket_frame1(swigCPtr, this, OpenSimObject.getCPtr(object), object);
+  }
+
+  public void setPropertyIndex_socket_frame2(SWIGTYPE_p_OpenSim__PropertyIndex value) {
+    opensimSimulationJNI.TwoFrameLinkerForceProducer_PropertyIndex_socket_frame2_set(swigCPtr, this, SWIGTYPE_p_OpenSim__PropertyIndex.getCPtr(value));
+  }
+
+  public SWIGTYPE_p_OpenSim__PropertyIndex getPropertyIndex_socket_frame2() {
+    return new SWIGTYPE_p_OpenSim__PropertyIndex(opensimSimulationJNI.TwoFrameLinkerForceProducer_PropertyIndex_socket_frame2_get(swigCPtr, this), true);
+  }
+
+  public void connectSocket_frame2(OpenSimObject object) {
+    opensimSimulationJNI.TwoFrameLinkerForceProducer_connectSocket_frame2(swigCPtr, this, OpenSimObject.getCPtr(object), object);
+  }
+
+  /**
+   *  Access the first frame the TwoFrameLinker component connects.<br>
+   *         Note, if an offset was introduced at construction, then this will be<br>
+   *         the offset frame. 
+   */
+  public PhysicalFrame getFrame1() {
+    return new PhysicalFrame(opensimSimulationJNI.TwoFrameLinkerForceProducer_getFrame1(swigCPtr, this), false);
+  }
+
+  /**
+   *  Access the second frame the TwoFrameLinker component connects.<br>
+   *         Note, if an offset was introduced at construction, then this will be<br>
+   *         the offset frame. 
+   */
+  public PhysicalFrame getFrame2() {
+    return new PhysicalFrame(opensimSimulationJNI.TwoFrameLinkerForceProducer_getFrame2(swigCPtr, this), false);
+  }
+
+  /**
+   *  Compute the relative offset Transform between the two frames linked by <br>
+   *         this TwoFrameLinker component at a given State, expressed in frame1. 
+   */
+  public Transform computeRelativeOffset(State s) {
+    return new Transform(opensimSimulationJNI.TwoFrameLinkerForceProducer_computeRelativeOffset(swigCPtr, this, State.getCPtr(s), s), true);
+  }
+
+  /**
+   *  Compute the relative spatial velocity between the two frames linked by<br>
+   *         this TwoFrameLinker component at a given State, expressed in frame1. 
+   */
+  public SpatialVec computeRelativeVelocity(State s) {
+    return new SpatialVec(opensimSimulationJNI.TwoFrameLinkerForceProducer_computeRelativeVelocity(swigCPtr, this, State.getCPtr(s), s), true);
+  }
+
+  /**
+   *  Compute the deflection (spatial separation) of the two frames connected<br>
+   *         by the TwoFrameLinker. Angular deflections expressed as XYZ body-fixed <br>
+   *         Euler angles of frame2 w.r.t frame1.<br>
+   *         NOTE: When using deflections to compute spatial forces, these forces<br>
+   *             may not be valid for large deflections, because Euler angles are <br>
+   *             unable to uniquely distinguish an X rotation angle of +/-180 degs,<br>
+   *             and subsequent rotations that are +/-90 degs. It is mainly useful<br>
+   *             for calculating errors for constraints and forces for computing <br>
+   *             restoration forces.<br>
+   *      @return dq     Vec6 of (3) angular and (3) translational deflections. 
+   */
+  public Vec6 computeDeflection(State s) {
+    return new Vec6(opensimSimulationJNI.TwoFrameLinkerForceProducer_computeDeflection(swigCPtr, this, State.getCPtr(s), s), true);
+  }
+
+  /**
+   *  Compute the deflection rate (dqdot) of the two frames connected by<br>
+   *         this TwoFrameLinker component. Angular velocity is expressed as Euler<br>
+   *         (XYZ body-fixed) angle derivatives. Note that the derivatives <br>
+   *         become singular as the second Euler angle approaches 90 degs.<br>
+   *     @return dqdot  Vec6 of (3) angular and (3) translational deflection rates. 
+   */
+  public Vec6 computeDeflectionRate(State s) {
+    return new Vec6(opensimSimulationJNI.TwoFrameLinkerForceProducer_computeDeflectionRate(swigCPtr, this, State.getCPtr(s), s), true);
+  }
+
+}
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/opensimActuatorsAnalysesToolsJNI.java b/Gui/opensim/modeling/src/org/opensim/modeling/opensimActuatorsAnalysesToolsJNI.java
index b7c811027..667c788f6 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/opensimActuatorsAnalysesToolsJNI.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/opensimActuatorsAnalysesToolsJNI.java
@@ -1078,6 +1078,14 @@ public class opensimActuatorsAnalysesToolsJNI {
   public final static native long new_ModOpReplacePathsWithFunctionBasedPaths__SWIG_1(String jarg1);
   public final static native void ModOpReplacePathsWithFunctionBasedPaths_operate(long jarg1, ModOpReplacePathsWithFunctionBasedPaths jarg1_, long jarg2, Model jarg2_, String jarg3);
   public final static native void delete_ModOpReplacePathsWithFunctionBasedPaths(long jarg1);
+  public final static native long ModOpPrescribeCoordinateValues_safeDownCast(long jarg1, OpenSimObject jarg1_);
+  public final static native void ModOpPrescribeCoordinateValues_assign(long jarg1, ModOpPrescribeCoordinateValues jarg1_, long jarg2, OpenSimObject jarg2_);
+  public final static native String ModOpPrescribeCoordinateValues_getClassName();
+  public final static native long ModOpPrescribeCoordinateValues_clone(long jarg1, ModOpPrescribeCoordinateValues jarg1_);
+  public final static native String ModOpPrescribeCoordinateValues_getConcreteClassName(long jarg1, ModOpPrescribeCoordinateValues jarg1_);
+  public final static native long new_ModOpPrescribeCoordinateValues(long jarg1, TableProcessor jarg1_);
+  public final static native void ModOpPrescribeCoordinateValues_operate(long jarg1, ModOpPrescribeCoordinateValues jarg1_, long jarg2, Model jarg2_, String jarg3);
+  public final static native void delete_ModOpPrescribeCoordinateValues(long jarg1);
   public final static native long PolynomialPathFitterBounds_safeDownCast(long jarg1, OpenSimObject jarg1_);
   public final static native void PolynomialPathFitterBounds_assign(long jarg1, PolynomialPathFitterBounds jarg1_, long jarg2, OpenSimObject jarg2_);
   public final static native String PolynomialPathFitterBounds_getClassName();
@@ -2533,6 +2541,7 @@ public class opensimActuatorsAnalysesToolsJNI {
   public final static native long ModOpReplaceJointsWithWelds_SWIGUpcast(long jarg1);
   public final static native long ModOpReplaceMusclesWithPathActuators_SWIGUpcast(long jarg1);
   public final static native long ModOpReplacePathsWithFunctionBasedPaths_SWIGUpcast(long jarg1);
+  public final static native long ModOpPrescribeCoordinateValues_SWIGUpcast(long jarg1);
   public final static native long PolynomialPathFitterBounds_SWIGUpcast(long jarg1);
   public final static native long PolynomialPathFitter_SWIGUpcast(long jarg1);
   public final static native long Kinematics_SWIGUpcast(long jarg1);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/opensimCommon.java b/Gui/opensim/modeling/src/org/opensim/modeling/opensimCommon.java
index b8ae57671..5f90988c3 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/opensimCommon.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/opensimCommon.java
@@ -89,26 +89,51 @@ public static Vector createVectorLinspace(int length, double start, double end)
    *  Linearly interpolate y(x) at new values of x. The optional 'ignoreNaNs'<br>
    *  argument will ignore any NaN values contained in the input vectors and<br>
    *  create the interpolant from the non-NaN values only. Note that this option<br>
-   *  does not necessarily prevent NaN values from being returned in 'newX', which<br>
-   *  will have NaN for any values of newX outside of the range of x.<br>
+   *  does not necessarily prevent NaN values from being returned, which will<br>
+   *  have NaN for any values of newX outside of the range of x. This is done with<br>
+   *  the 'extrapolate' option. If the 'extrapolate' argument is true, then the<br>
+   *  interpolant values will be extrapolated based on a piecewise linear function.<br>
+   *  Setting both 'ignoreNaNs' and 'extrapolate' to true prevents NaN values from<br>
+   *  occurring in the interpolant.<br>
+   *  @throws Exception if x and y are different sizes, or x or y is empty.<br>
+   *  
+   */
+  public static Vector interpolate(Vector x, Vector y, Vector newX, boolean ignoreNaNs, boolean extrapolate) {
+    return new Vector(opensimCommonJNI.interpolate__SWIG_0(Vector.getCPtr(x), x, Vector.getCPtr(y), y, Vector.getCPtr(newX), newX, ignoreNaNs, extrapolate), true);
+  }
+
+  /**
+   *  Linearly interpolate y(x) at new values of x. The optional 'ignoreNaNs'<br>
+   *  argument will ignore any NaN values contained in the input vectors and<br>
+   *  create the interpolant from the non-NaN values only. Note that this option<br>
+   *  does not necessarily prevent NaN values from being returned, which will<br>
+   *  have NaN for any values of newX outside of the range of x. This is done with<br>
+   *  the 'extrapolate' option. If the 'extrapolate' argument is true, then the<br>
+   *  interpolant values will be extrapolated based on a piecewise linear function.<br>
+   *  Setting both 'ignoreNaNs' and 'extrapolate' to true prevents NaN values from<br>
+   *  occurring in the interpolant.<br>
    *  @throws Exception if x and y are different sizes, or x or y is empty.<br>
    *  
    */
   public static Vector interpolate(Vector x, Vector y, Vector newX, boolean ignoreNaNs) {
-    return new Vector(opensimCommonJNI.interpolate__SWIG_0(Vector.getCPtr(x), x, Vector.getCPtr(y), y, Vector.getCPtr(newX), newX, ignoreNaNs), true);
+    return new Vector(opensimCommonJNI.interpolate__SWIG_1(Vector.getCPtr(x), x, Vector.getCPtr(y), y, Vector.getCPtr(newX), newX, ignoreNaNs), true);
   }
 
   /**
    *  Linearly interpolate y(x) at new values of x. The optional 'ignoreNaNs'<br>
    *  argument will ignore any NaN values contained in the input vectors and<br>
    *  create the interpolant from the non-NaN values only. Note that this option<br>
-   *  does not necessarily prevent NaN values from being returned in 'newX', which<br>
-   *  will have NaN for any values of newX outside of the range of x.<br>
+   *  does not necessarily prevent NaN values from being returned, which will<br>
+   *  have NaN for any values of newX outside of the range of x. This is done with<br>
+   *  the 'extrapolate' option. If the 'extrapolate' argument is true, then the<br>
+   *  interpolant values will be extrapolated based on a piecewise linear function.<br>
+   *  Setting both 'ignoreNaNs' and 'extrapolate' to true prevents NaN values from<br>
+   *  occurring in the interpolant.<br>
    *  @throws Exception if x and y are different sizes, or x or y is empty.<br>
    *  
    */
   public static Vector interpolate(Vector x, Vector y, Vector newX) {
-    return new Vector(opensimCommonJNI.interpolate__SWIG_1(Vector.getCPtr(x), x, Vector.getCPtr(y), y, Vector.getCPtr(newX), newX), true);
+    return new Vector(opensimCommonJNI.interpolate__SWIG_2(Vector.getCPtr(x), x, Vector.getCPtr(y), y, Vector.getCPtr(newX), newX), true);
   }
 
   /**
@@ -199,6 +224,29 @@ public static Matrix computeKNearestNeighbors(Matrix x, Matrix y) {
     return new Matrix(opensimCommonJNI.computeKNearestNeighbors__SWIG_1(Matrix.getCPtr(x), x, Matrix.getCPtr(y), y), true);
   }
 
+  /**
+   *  Use non-negative matrix factorization to decompose an matrix A (NxM) for a <br>
+   *  selected number of factors 'K' into two matrices W (NxK) and H (KxM) such <br>
+   *  that A = W * H. The alternating least squares (ALS) algorithm is used to <br>
+   *  solve for W and H by minimizing the Frobenius norm of the error between A <br>
+   *  and W * H. The matrices W and H are scaled assuming that the rows of H<br>
+   *  have magnitudes as if all elements in H were equal to 0.5, which prevents<br>
+   *  individual factors from being very large or very small. The algorithm <br>
+   *  terminates when the change in the error norm is less than the specified <br>
+   *  tolerance or the maximum number of iterations is reached.<br>
+   * <br>
+   *  @return The final Frobenius norm of the error between A and W * H.<br>
+   * <br>
+   *  Reference<br>
+   *  ---------<br>
+   *  Berry, M. W., et al. (2007). Algorithms and Applications for Approximate <br>
+   *  Nonnegative Matrix Factorization. Computational Statistics &amp; Data Analysis, <br>
+   *  52(1), 155-173. doi:10.1016/j.csda.2006.11.006.
+   */
+  public static double factorizeMatrixNonNegative(Matrix A, int numFactors, int maxIterations, double tolerance, Matrix W, Matrix H) {
+    return opensimCommonJNI.factorizeMatrixNonNegative(Matrix.getCPtr(A), A, numFactors, maxIterations, tolerance, Matrix.getCPtr(W), W, Matrix.getCPtr(H), H);
+  }
+
   public static String getObjectDEFAULT_NAME() {
     return opensimCommonJNI.ObjectDEFAULT_NAME_get();
   }
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/opensimCommonJNI.java b/Gui/opensim/modeling/src/org/opensim/modeling/opensimCommonJNI.java
index ef4bccfd8..76b673c00 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/opensimCommonJNI.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/opensimCommonJNI.java
@@ -90,14 +90,16 @@ public class opensimCommonJNI {
   public final static native void FileRemover_remove(long jarg1, FileRemover jarg1_);
   public final static native void delete_FileRemover(long jarg1);
   public final static native long createVectorLinspace(int jarg1, double jarg2, double jarg3);
-  public final static native long interpolate__SWIG_0(long jarg1, Vector jarg1_, long jarg2, Vector jarg2_, long jarg3, Vector jarg3_, boolean jarg4);
-  public final static native long interpolate__SWIG_1(long jarg1, Vector jarg1_, long jarg2, Vector jarg2_, long jarg3, Vector jarg3_);
+  public final static native long interpolate__SWIG_0(long jarg1, Vector jarg1_, long jarg2, Vector jarg2_, long jarg3, Vector jarg3_, boolean jarg4, boolean jarg5);
+  public final static native long interpolate__SWIG_1(long jarg1, Vector jarg1_, long jarg2, Vector jarg2_, long jarg3, Vector jarg3_, boolean jarg4);
+  public final static native long interpolate__SWIG_2(long jarg1, Vector jarg1_, long jarg2, Vector jarg2_, long jarg3, Vector jarg3_);
   public final static native String convertRelativeFilePathToAbsoluteFromXMLDocument(String jarg1, String jarg2);
   public final static native double solveBisection__SWIG_0(long jarg1, double jarg2, double jarg3, double jarg4, int jarg5);
   public final static native double solveBisection__SWIG_1(long jarg1, double jarg2, double jarg3, double jarg4);
   public final static native double solveBisection__SWIG_2(long jarg1, double jarg2, double jarg3);
   public final static native long computeKNearestNeighbors__SWIG_0(long jarg1, Matrix jarg1_, long jarg2, Matrix jarg2_, int jarg3);
   public final static native long computeKNearestNeighbors__SWIG_1(long jarg1, Matrix jarg1_, long jarg2, Matrix jarg2_);
+  public final static native double factorizeMatrixNonNegative(long jarg1, Matrix jarg1_, int jarg2, int jarg3, double jarg4, long jarg5, Matrix jarg5_, long jarg6, Matrix jarg6_);
   public final static native void delete_LogSink(long jarg1);
   public final static native void LogSink_sinkImpl(long jarg1, LogSink jarg1_, String jarg2);
   public final static native void LogSink_flushImpl(long jarg1, LogSink jarg1_);
@@ -1066,6 +1068,34 @@ public class opensimCommonJNI {
   public final static native long MultivariatePolynomialFunction_generateDerivativeFunction__SWIG_1(long jarg1, MultivariatePolynomialFunction jarg1_, int jarg2);
   public final static native long MultivariatePolynomialFunction_generatePartialVelocityFunction(long jarg1, MultivariatePolynomialFunction jarg1_);
   public final static native void delete_MultivariatePolynomialFunction(long jarg1);
+  public final static native long ExpressionBasedFunction_safeDownCast(long jarg1, OpenSimObject jarg1_);
+  public final static native void ExpressionBasedFunction_assign(long jarg1, ExpressionBasedFunction jarg1_, long jarg2, OpenSimObject jarg2_);
+  public final static native String ExpressionBasedFunction_getClassName();
+  public final static native long ExpressionBasedFunction_clone(long jarg1, ExpressionBasedFunction jarg1_);
+  public final static native String ExpressionBasedFunction_getConcreteClassName(long jarg1, ExpressionBasedFunction jarg1_);
+  public final static native void ExpressionBasedFunction_copyProperty_expression(long jarg1, ExpressionBasedFunction jarg1_, long jarg2, ExpressionBasedFunction jarg2_);
+  public final static native String ExpressionBasedFunction_get_expression__SWIG_0(long jarg1, ExpressionBasedFunction jarg1_, int jarg2);
+  public final static native long ExpressionBasedFunction_upd_expression__SWIG_0(long jarg1, ExpressionBasedFunction jarg1_, int jarg2);
+  public final static native void ExpressionBasedFunction_set_expression__SWIG_0(long jarg1, ExpressionBasedFunction jarg1_, int jarg2, String jarg3);
+  public final static native int ExpressionBasedFunction_append_expression(long jarg1, ExpressionBasedFunction jarg1_, String jarg2);
+  public final static native void ExpressionBasedFunction_constructProperty_expression(long jarg1, ExpressionBasedFunction jarg1_, String jarg2);
+  public final static native String ExpressionBasedFunction_get_expression__SWIG_1(long jarg1, ExpressionBasedFunction jarg1_);
+  public final static native long ExpressionBasedFunction_upd_expression__SWIG_1(long jarg1, ExpressionBasedFunction jarg1_);
+  public final static native void ExpressionBasedFunction_set_expression__SWIG_1(long jarg1, ExpressionBasedFunction jarg1_, String jarg2);
+  public final static native void ExpressionBasedFunction_copyProperty_variables(long jarg1, ExpressionBasedFunction jarg1_, long jarg2, ExpressionBasedFunction jarg2_);
+  public final static native String ExpressionBasedFunction_get_variables(long jarg1, ExpressionBasedFunction jarg1_, int jarg2);
+  public final static native long ExpressionBasedFunction_upd_variables(long jarg1, ExpressionBasedFunction jarg1_, int jarg2);
+  public final static native void ExpressionBasedFunction_set_variables(long jarg1, ExpressionBasedFunction jarg1_, int jarg2, String jarg3);
+  public final static native int ExpressionBasedFunction_append_variables(long jarg1, ExpressionBasedFunction jarg1_, String jarg2);
+  public final static native void ExpressionBasedFunction_constructProperty_variables(long jarg1, ExpressionBasedFunction jarg1_);
+  public final static native long new_ExpressionBasedFunction__SWIG_0();
+  public final static native long new_ExpressionBasedFunction__SWIG_1(String jarg1, long jarg2, StdVectorString jarg2_);
+  public final static native void ExpressionBasedFunction_setExpression(long jarg1, ExpressionBasedFunction jarg1_, String jarg2);
+  public final static native String ExpressionBasedFunction_getExpression(long jarg1, ExpressionBasedFunction jarg1_);
+  public final static native void ExpressionBasedFunction_setVariables(long jarg1, ExpressionBasedFunction jarg1_, long jarg2, StdVectorString jarg2_);
+  public final static native long ExpressionBasedFunction_getVariables(long jarg1, ExpressionBasedFunction jarg1_);
+  public final static native long ExpressionBasedFunction_createSimTKFunction(long jarg1, ExpressionBasedFunction jarg1_);
+  public final static native void delete_ExpressionBasedFunction(long jarg1);
   public final static native long SmoothSegmentedFunctionFactory_createFiberActiveForceLengthCurve(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, boolean jarg8, String jarg9);
   public final static native long SmoothSegmentedFunctionFactory_createFiberForceVelocityCurve(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, boolean jarg9, String jarg10);
   public final static native long SmoothSegmentedFunctionFactory_createFiberForceVelocityInverseCurve(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6, double jarg7, double jarg8, boolean jarg9, String jarg10);
@@ -1720,6 +1750,7 @@ public class opensimCommonJNI {
   public final static native boolean ComponentFilterAbsolutePathNameContainsString_isMatch(long jarg1, ComponentFilterAbsolutePathNameContainsString jarg1_, long jarg2, Component jarg2_);
   public final static native long ComponentFilterAbsolutePathNameContainsString_clone(long jarg1, ComponentFilterAbsolutePathNameContainsString jarg1_);
   public final static native void delete_ComponentFilterAbsolutePathNameContainsString(long jarg1);
+  public final static native char ComponentPath_separator();
   public final static native long ComponentPath_root();
   public final static native long new_ComponentPath__SWIG_0();
   public final static native long new_ComponentPath__SWIG_1(String jarg1);
@@ -1818,14 +1849,17 @@ public class opensimCommonJNI {
   public final static native long Component_getOutput(long jarg1, Component jarg1_, String jarg2);
   public final static native long Component_tryUpdOutput(long jarg1, Component jarg1_, String jarg2);
   public final static native long Component_updOutput(long jarg1, Component jarg1_, String jarg2);
-  public final static native int Component_getModelingOption(long jarg1, Component jarg1_, long jarg2, State jarg2_, String jarg3);
-  public final static native void Component_setModelingOption(long jarg1, Component jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native int Component_getModelingOption__SWIG_0(long jarg1, Component jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native int Component_getModelingOption__SWIG_1(long jarg1, Component jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
+  public final static native void Component_setModelingOption__SWIG_0(long jarg1, Component jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native void Component_setModelingOption__SWIG_1(long jarg1, Component jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_, int jarg4);
   public final static native double Component_getStateVariableValue__SWIG_0(long jarg1, Component jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native double Component_getStateVariableValue__SWIG_1(long jarg1, Component jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native void Component_setStateVariableValue(long jarg1, Component jarg1_, long jarg2, State jarg2_, String jarg3, double jarg4);
   public final static native long Component_getStateVariableValues(long jarg1, Component jarg1_, long jarg2, State jarg2_);
   public final static native void Component_setStateVariableValues(long jarg1, Component jarg1_, long jarg2, State jarg2_, long jarg3, Vector jarg3_);
-  public final static native double Component_getStateVariableDerivativeValue(long jarg1, Component jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double Component_getStateVariableDerivativeValue__SWIG_0(long jarg1, Component jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double Component_getStateVariableDerivativeValue__SWIG_1(long jarg1, Component jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native long Component_resolveVariableNameAndOwner(long jarg1, Component jarg1_, long jarg2, ComponentPath jarg2_, long jarg3);
   public final static native double Component_getDiscreteVariableValue(long jarg1, Component jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native long Component_getDiscreteVariableAbstractValue(long jarg1, Component jarg1_, long jarg2, State jarg2_, String jarg3);
@@ -1894,14 +1928,17 @@ public class opensimCommonJNI {
   public final static native long ComponentIterator_getInput(long jarg1, ComponentIterator jarg1_, String jarg2);
   public final static native long ComponentIterator_tryGetOutput(long jarg1, ComponentIterator jarg1_, String jarg2);
   public final static native long ComponentIterator_getOutput(long jarg1, ComponentIterator jarg1_, String jarg2);
-  public final static native int ComponentIterator_getModelingOption(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3);
-  public final static native void ComponentIterator_setModelingOption(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native int ComponentIterator_getModelingOption__SWIG_0(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native int ComponentIterator_getModelingOption__SWIG_1(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
+  public final static native void ComponentIterator_setModelingOption__SWIG_0(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native void ComponentIterator_setModelingOption__SWIG_1(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_, int jarg4);
   public final static native double ComponentIterator_getStateVariableValue__SWIG_0(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native double ComponentIterator_getStateVariableValue__SWIG_1(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native void ComponentIterator_setStateVariableValue(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3, double jarg4);
   public final static native long ComponentIterator_getStateVariableValues(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_);
   public final static native void ComponentIterator_setStateVariableValues(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_, long jarg3, Vector jarg3_);
-  public final static native double ComponentIterator_getStateVariableDerivativeValue(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double ComponentIterator_getStateVariableDerivativeValue__SWIG_0(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double ComponentIterator_getStateVariableDerivativeValue__SWIG_1(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native long ComponentIterator_resolveVariableNameAndOwner(long jarg1, ComponentIterator jarg1_, long jarg2, ComponentPath jarg2_, long jarg3);
   public final static native double ComponentIterator_getDiscreteVariableValue(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native long ComponentIterator_getDiscreteVariableAbstractValue(long jarg1, ComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3);
@@ -2119,6 +2156,8 @@ public class opensimCommonJNI {
   public final static native void delete_TimeOutOfRange(long jarg1);
   public final static native long new_InvalidTimeRange(String jarg1, long jarg2, String jarg3, double jarg4, double jarg5);
   public final static native void delete_InvalidTimeRange(long jarg1);
+  public final static native long new_InvalidIndices(String jarg1, long jarg2, String jarg3, long jarg4, long jarg5, long jarg6);
+  public final static native void delete_InvalidIndices(long jarg1);
   public final static native void TableUtilities_checkNonUniqueLabels(long jarg1, StdVectorString jarg1_);
   public final static native boolean TableUtilities_isInDegrees(long jarg1, TimeSeriesTable jarg1_);
   public final static native int TableUtilities_findStateLabelIndex__SWIG_0(long jarg1, ArrayStr jarg1_, String jarg2);
@@ -2498,6 +2537,7 @@ public class opensimCommonJNI {
   public final static native void TimeSeriesTable_trim(long jarg1, TimeSeriesTable jarg1_, double jarg2, double jarg3);
   public final static native void TimeSeriesTable_trimFrom(long jarg1, TimeSeriesTable jarg1_, double jarg2);
   public final static native void TimeSeriesTable_trimTo(long jarg1, TimeSeriesTable jarg1_, double jarg2);
+  public final static native void TimeSeriesTable_trimToIndices(long jarg1, TimeSeriesTable jarg1_, long jarg2, long jarg3);
   public final static native long TimeSeriesTable_clone(long jarg1, TimeSeriesTable jarg1_);
   public final static native long TimeSeriesTable_packVec3__SWIG_0(long jarg1, TimeSeriesTable jarg1_);
   public final static native long TimeSeriesTable_packVec3__SWIG_1(long jarg1, TimeSeriesTable jarg1_, long jarg2, StdVectorString jarg2_);
@@ -2527,6 +2567,7 @@ public class opensimCommonJNI {
   public final static native void TimeSeriesTableVec3_trim(long jarg1, TimeSeriesTableVec3 jarg1_, double jarg2, double jarg3);
   public final static native void TimeSeriesTableVec3_trimFrom(long jarg1, TimeSeriesTableVec3 jarg1_, double jarg2);
   public final static native void TimeSeriesTableVec3_trimTo(long jarg1, TimeSeriesTableVec3 jarg1_, double jarg2);
+  public final static native void TimeSeriesTableVec3_trimToIndices(long jarg1, TimeSeriesTableVec3 jarg1_, long jarg2, long jarg3);
   public final static native long TimeSeriesTableVec3_clone(long jarg1, TimeSeriesTableVec3 jarg1_);
   public final static native long TimeSeriesTableVec3_flatten__SWIG_0(long jarg1, TimeSeriesTableVec3 jarg1_);
   public final static native long TimeSeriesTableVec3_flatten__SWIG_1(long jarg1, TimeSeriesTableVec3 jarg1_, long jarg2, StdVectorString jarg2_);
@@ -2550,6 +2591,7 @@ public class opensimCommonJNI {
   public final static native void TimeSeriesTableUnitVec3_trim(long jarg1, TimeSeriesTableUnitVec3 jarg1_, double jarg2, double jarg3);
   public final static native void TimeSeriesTableUnitVec3_trimFrom(long jarg1, TimeSeriesTableUnitVec3 jarg1_, double jarg2);
   public final static native void TimeSeriesTableUnitVec3_trimTo(long jarg1, TimeSeriesTableUnitVec3 jarg1_, double jarg2);
+  public final static native void TimeSeriesTableUnitVec3_trimToIndices(long jarg1, TimeSeriesTableUnitVec3 jarg1_, long jarg2, long jarg3);
   public final static native long TimeSeriesTableUnitVec3_clone(long jarg1, TimeSeriesTableUnitVec3 jarg1_);
   public final static native long TimeSeriesTableUnitVec3_flatten__SWIG_0(long jarg1, TimeSeriesTableUnitVec3 jarg1_);
   public final static native long TimeSeriesTableUnitVec3_flatten__SWIG_1(long jarg1, TimeSeriesTableUnitVec3 jarg1_, long jarg2, StdVectorString jarg2_);
@@ -2573,6 +2615,7 @@ public class opensimCommonJNI {
   public final static native void TimeSeriesTableQuaternion_trim(long jarg1, TimeSeriesTableQuaternion jarg1_, double jarg2, double jarg3);
   public final static native void TimeSeriesTableQuaternion_trimFrom(long jarg1, TimeSeriesTableQuaternion jarg1_, double jarg2);
   public final static native void TimeSeriesTableQuaternion_trimTo(long jarg1, TimeSeriesTableQuaternion jarg1_, double jarg2);
+  public final static native void TimeSeriesTableQuaternion_trimToIndices(long jarg1, TimeSeriesTableQuaternion jarg1_, long jarg2, long jarg3);
   public final static native long TimeSeriesTableQuaternion_clone(long jarg1, TimeSeriesTableQuaternion jarg1_);
   public final static native long new_TimeSeriesTableVec6__SWIG_0();
   public final static native long new_TimeSeriesTableVec6__SWIG_1(long jarg1, TimeSeriesTableVec6 jarg1_);
@@ -2594,6 +2637,7 @@ public class opensimCommonJNI {
   public final static native void TimeSeriesTableVec6_trim(long jarg1, TimeSeriesTableVec6 jarg1_, double jarg2, double jarg3);
   public final static native void TimeSeriesTableVec6_trimFrom(long jarg1, TimeSeriesTableVec6 jarg1_, double jarg2);
   public final static native void TimeSeriesTableVec6_trimTo(long jarg1, TimeSeriesTableVec6 jarg1_, double jarg2);
+  public final static native void TimeSeriesTableVec6_trimToIndices(long jarg1, TimeSeriesTableVec6 jarg1_, long jarg2, long jarg3);
   public final static native long TimeSeriesTableVec6_clone(long jarg1, TimeSeriesTableVec6 jarg1_);
   public final static native long TimeSeriesTableVec6_flatten__SWIG_0(long jarg1, TimeSeriesTableVec6 jarg1_);
   public final static native long TimeSeriesTableVec6_flatten__SWIG_1(long jarg1, TimeSeriesTableVec6 jarg1_, long jarg2, StdVectorString jarg2_);
@@ -2617,6 +2661,7 @@ public class opensimCommonJNI {
   public final static native void TimeSeriesTableSpatialVec_trim(long jarg1, TimeSeriesTableSpatialVec jarg1_, double jarg2, double jarg3);
   public final static native void TimeSeriesTableSpatialVec_trimFrom(long jarg1, TimeSeriesTableSpatialVec jarg1_, double jarg2);
   public final static native void TimeSeriesTableSpatialVec_trimTo(long jarg1, TimeSeriesTableSpatialVec jarg1_, double jarg2);
+  public final static native void TimeSeriesTableSpatialVec_trimToIndices(long jarg1, TimeSeriesTableSpatialVec jarg1_, long jarg2, long jarg3);
   public final static native long TimeSeriesTableSpatialVec_clone(long jarg1, TimeSeriesTableSpatialVec jarg1_);
   public final static native long TimeSeriesTableSpatialVec_flatten__SWIG_0(long jarg1, TimeSeriesTableSpatialVec jarg1_);
   public final static native long TimeSeriesTableSpatialVec_flatten__SWIG_1(long jarg1, TimeSeriesTableSpatialVec jarg1_, long jarg2, StdVectorString jarg2_);
@@ -2640,6 +2685,7 @@ public class opensimCommonJNI {
   public final static native void TimeSeriesTableMat33_trim(long jarg1, TimeSeriesTableMat33 jarg1_, double jarg2, double jarg3);
   public final static native void TimeSeriesTableMat33_trimFrom(long jarg1, TimeSeriesTableMat33 jarg1_, double jarg2);
   public final static native void TimeSeriesTableMat33_trimTo(long jarg1, TimeSeriesTableMat33 jarg1_, double jarg2);
+  public final static native void TimeSeriesTableMat33_trimToIndices(long jarg1, TimeSeriesTableMat33 jarg1_, long jarg2, long jarg3);
   public final static native long TimeSeriesTableMat33_clone(long jarg1, TimeSeriesTableMat33 jarg1_);
   public final static native long new_TimeSeriesTableRotation__SWIG_0();
   public final static native long new_TimeSeriesTableRotation__SWIG_1(long jarg1, TimeSeriesTableRotation jarg1_);
@@ -2661,6 +2707,7 @@ public class opensimCommonJNI {
   public final static native void TimeSeriesTableRotation_trim(long jarg1, TimeSeriesTableRotation jarg1_, double jarg2, double jarg3);
   public final static native void TimeSeriesTableRotation_trimFrom(long jarg1, TimeSeriesTableRotation jarg1_, double jarg2);
   public final static native void TimeSeriesTableRotation_trimTo(long jarg1, TimeSeriesTableRotation jarg1_, double jarg2);
+  public final static native void TimeSeriesTableRotation_trimToIndices(long jarg1, TimeSeriesTableRotation jarg1_, long jarg2, long jarg3);
   public final static native long TimeSeriesTableRotation_clone(long jarg1, TimeSeriesTableRotation jarg1_);
   public final static native void Event_label_set(long jarg1, Event jarg1_, String jarg2);
   public final static native String Event_label_get(long jarg1, Event jarg1_);
@@ -3156,6 +3203,7 @@ public class opensimCommonJNI {
   public final static native long Sine_SWIGUpcast(long jarg1);
   public final static native long PolynomialFunction_SWIGUpcast(long jarg1);
   public final static native long MultivariatePolynomialFunction_SWIGUpcast(long jarg1);
+  public final static native long ExpressionBasedFunction_SWIGUpcast(long jarg1);
   public final static native long XYFunctionInterface_SWIGUpcast(long jarg1);
   public final static native long ModelDisplayHints_SWIGUpcast(long jarg1);
   public final static native long OutputDouble_SWIGUpcast(long jarg1);
@@ -3210,6 +3258,7 @@ public class opensimCommonJNI {
   public final static native long TimestampGreaterThanEqualToNext_SWIGUpcast(long jarg1);
   public final static native long TimeOutOfRange_SWIGUpcast(long jarg1);
   public final static native long InvalidTimeRange_SWIGUpcast(long jarg1);
+  public final static native long InvalidIndices_SWIGUpcast(long jarg1);
   public final static native long DataTable_SWIGSmartPtrUpcast(long jarg1);
   public final static native long DataTableVec3_SWIGSmartPtrUpcast(long jarg1);
   public final static native long DataTableUnitVec3_SWIGSmartPtrUpcast(long jarg1);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/opensimMocoJNI.java b/Gui/opensim/modeling/src/org/opensim/modeling/opensimMocoJNI.java
index ea0822b43..b5a53c002 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/opensimMocoJNI.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/opensimMocoJNI.java
@@ -486,6 +486,18 @@ public class opensimMocoJNI {
   public final static native int MocoContactImpulseTrackingGoal_getImpulseAxis(long jarg1, MocoContactImpulseTrackingGoal jarg1_);
   public final static native void MocoContactImpulseTrackingGoal_addScaleFactor(long jarg1, MocoContactImpulseTrackingGoal jarg1_, String jarg2, String jarg3, long jarg4, MocoBounds jarg4_);
   public final static native void delete_MocoContactImpulseTrackingGoal(long jarg1);
+  public final static native long MocoExpressionBasedParameterGoal_safeDownCast(long jarg1, OpenSimObject jarg1_);
+  public final static native void MocoExpressionBasedParameterGoal_assign(long jarg1, MocoExpressionBasedParameterGoal jarg1_, long jarg2, OpenSimObject jarg2_);
+  public final static native String MocoExpressionBasedParameterGoal_getClassName();
+  public final static native long MocoExpressionBasedParameterGoal_clone(long jarg1, MocoExpressionBasedParameterGoal jarg1_);
+  public final static native String MocoExpressionBasedParameterGoal_getConcreteClassName(long jarg1, MocoExpressionBasedParameterGoal jarg1_);
+  public final static native long new_MocoExpressionBasedParameterGoal__SWIG_0();
+  public final static native long new_MocoExpressionBasedParameterGoal__SWIG_1(String jarg1);
+  public final static native long new_MocoExpressionBasedParameterGoal__SWIG_2(String jarg1, double jarg2);
+  public final static native long new_MocoExpressionBasedParameterGoal__SWIG_3(String jarg1, double jarg2, String jarg3);
+  public final static native void MocoExpressionBasedParameterGoal_setExpression(long jarg1, MocoExpressionBasedParameterGoal jarg1_, String jarg2);
+  public final static native void MocoExpressionBasedParameterGoal_addParameter(long jarg1, MocoExpressionBasedParameterGoal jarg1_, long jarg2, MocoParameter jarg2_, String jarg3);
+  public final static native void delete_MocoExpressionBasedParameterGoal(long jarg1);
   public final static native long MocoInitialActivationGoal_safeDownCast(long jarg1, OpenSimObject jarg1_);
   public final static native void MocoInitialActivationGoal_assign(long jarg1, MocoInitialActivationGoal jarg1_, long jarg2, OpenSimObject jarg2_);
   public final static native String MocoInitialActivationGoal_getClassName();
@@ -601,6 +613,10 @@ public class opensimMocoJNI {
   public final static native String MocoOutputBase_getConcreteClassName(long jarg1, MocoOutputBase jarg1_);
   public final static native void MocoOutputBase_setOutputPath(long jarg1, MocoOutputBase jarg1_, String jarg2);
   public final static native String MocoOutputBase_getOutputPath(long jarg1, MocoOutputBase jarg1_);
+  public final static native void MocoOutputBase_setSecondOutputPath(long jarg1, MocoOutputBase jarg1_, String jarg2);
+  public final static native String MocoOutputBase_getSecondOutputPath(long jarg1, MocoOutputBase jarg1_);
+  public final static native void MocoOutputBase_setOperation(long jarg1, MocoOutputBase jarg1_, String jarg2);
+  public final static native String MocoOutputBase_getOperation(long jarg1, MocoOutputBase jarg1_);
   public final static native void MocoOutputBase_setExponent(long jarg1, MocoOutputBase jarg1_, int jarg2);
   public final static native int MocoOutputBase_getExponent(long jarg1, MocoOutputBase jarg1_);
   public final static native void MocoOutputBase_setOutputIndex(long jarg1, MocoOutputBase jarg1_, int jarg2);
@@ -810,6 +826,7 @@ public class opensimMocoJNI {
   public final static native void MocoGeneralizedForceTrackingGoal_setForcePaths(long jarg1, MocoGeneralizedForceTrackingGoal jarg1_, long jarg2, StdVectorString jarg2_);
   public final static native long MocoGeneralizedForceTrackingGoal_getForcePaths(long jarg1, MocoGeneralizedForceTrackingGoal jarg1_);
   public final static native void MocoGeneralizedForceTrackingGoal_setWeightForGeneralizedForce(long jarg1, MocoGeneralizedForceTrackingGoal jarg1_, String jarg2, double jarg3);
+  public final static native void MocoGeneralizedForceTrackingGoal_setWeightForGeneralizedForcePattern(long jarg1, MocoGeneralizedForceTrackingGoal jarg1_, String jarg2, double jarg3);
   public final static native void MocoGeneralizedForceTrackingGoal_setWeightSet(long jarg1, MocoGeneralizedForceTrackingGoal jarg1_, long jarg2, MocoWeightSet jarg2_);
   public final static native void MocoGeneralizedForceTrackingGoal_setAllowUnusedReferences(long jarg1, MocoGeneralizedForceTrackingGoal jarg1_, boolean jarg2);
   public final static native void MocoGeneralizedForceTrackingGoal_setNormalizeTrackingError(long jarg1, MocoGeneralizedForceTrackingGoal jarg1_, boolean jarg2);
@@ -892,6 +909,54 @@ public class opensimMocoJNI {
   public final static native void MocoControlBoundConstraint_setEqualityWithLower(long jarg1, MocoControlBoundConstraint jarg1_, boolean jarg2);
   public final static native boolean MocoControlBoundConstraint_getEqualityWithLower(long jarg1, MocoControlBoundConstraint jarg1_);
   public final static native void delete_MocoControlBoundConstraint(long jarg1);
+  public final static native long MocoOutputBoundConstraint_safeDownCast(long jarg1, OpenSimObject jarg1_);
+  public final static native void MocoOutputBoundConstraint_assign(long jarg1, MocoOutputBoundConstraint jarg1_, long jarg2, OpenSimObject jarg2_);
+  public final static native String MocoOutputBoundConstraint_getClassName();
+  public final static native long MocoOutputBoundConstraint_clone(long jarg1, MocoOutputBoundConstraint jarg1_);
+  public final static native String MocoOutputBoundConstraint_getConcreteClassName(long jarg1, MocoOutputBoundConstraint jarg1_);
+  public final static native long new_MocoOutputBoundConstraint();
+  public final static native void MocoOutputBoundConstraint_setOutputPath(long jarg1, MocoOutputBoundConstraint jarg1_, String jarg2);
+  public final static native String MocoOutputBoundConstraint_getOutputPath(long jarg1, MocoOutputBoundConstraint jarg1_);
+  public final static native void MocoOutputBoundConstraint_setSecondOutputPath(long jarg1, MocoOutputBoundConstraint jarg1_, String jarg2);
+  public final static native String MocoOutputBoundConstraint_getSecondOutputPath(long jarg1, MocoOutputBoundConstraint jarg1_);
+  public final static native void MocoOutputBoundConstraint_setOperation(long jarg1, MocoOutputBoundConstraint jarg1_, String jarg2);
+  public final static native String MocoOutputBoundConstraint_getOperation(long jarg1, MocoOutputBoundConstraint jarg1_);
+  public final static native void MocoOutputBoundConstraint_setExponent(long jarg1, MocoOutputBoundConstraint jarg1_, int jarg2);
+  public final static native int MocoOutputBoundConstraint_getExponent(long jarg1, MocoOutputBoundConstraint jarg1_);
+  public final static native void MocoOutputBoundConstraint_setOutputIndex(long jarg1, MocoOutputBoundConstraint jarg1_, int jarg2);
+  public final static native int MocoOutputBoundConstraint_getOutputIndex(long jarg1, MocoOutputBoundConstraint jarg1_);
+  public final static native void MocoOutputBoundConstraint_setLowerBound(long jarg1, MocoOutputBoundConstraint jarg1_, long jarg2, Function jarg2_);
+  public final static native void MocoOutputBoundConstraint_clearLowerBound(long jarg1, MocoOutputBoundConstraint jarg1_);
+  public final static native boolean MocoOutputBoundConstraint_hasLowerBound(long jarg1, MocoOutputBoundConstraint jarg1_);
+  public final static native long MocoOutputBoundConstraint_getLowerBound(long jarg1, MocoOutputBoundConstraint jarg1_);
+  public final static native void MocoOutputBoundConstraint_setUpperBound(long jarg1, MocoOutputBoundConstraint jarg1_, long jarg2, Function jarg2_);
+  public final static native void MocoOutputBoundConstraint_clearUpperBound(long jarg1, MocoOutputBoundConstraint jarg1_);
+  public final static native boolean MocoOutputBoundConstraint_hasUpperBound(long jarg1, MocoOutputBoundConstraint jarg1_);
+  public final static native long MocoOutputBoundConstraint_getUpperBound(long jarg1, MocoOutputBoundConstraint jarg1_);
+  public final static native void MocoOutputBoundConstraint_setEqualityWithLower(long jarg1, MocoOutputBoundConstraint jarg1_, boolean jarg2);
+  public final static native boolean MocoOutputBoundConstraint_getEqualityWithLower(long jarg1, MocoOutputBoundConstraint jarg1_);
+  public final static native void delete_MocoOutputBoundConstraint(long jarg1);
+  public final static native long MocoStateBoundConstraint_safeDownCast(long jarg1, OpenSimObject jarg1_);
+  public final static native void MocoStateBoundConstraint_assign(long jarg1, MocoStateBoundConstraint jarg1_, long jarg2, OpenSimObject jarg2_);
+  public final static native String MocoStateBoundConstraint_getClassName();
+  public final static native long MocoStateBoundConstraint_clone(long jarg1, MocoStateBoundConstraint jarg1_);
+  public final static native String MocoStateBoundConstraint_getConcreteClassName(long jarg1, MocoStateBoundConstraint jarg1_);
+  public final static native long new_MocoStateBoundConstraint();
+  public final static native void MocoStateBoundConstraint_addStatePath(long jarg1, MocoStateBoundConstraint jarg1_, String jarg2);
+  public final static native void MocoStateBoundConstraint_setStatePaths(long jarg1, MocoStateBoundConstraint jarg1_, long jarg2, StdVectorString jarg2_);
+  public final static native void MocoStateBoundConstraint_clearStatePaths(long jarg1, MocoStateBoundConstraint jarg1_);
+  public final static native long MocoStateBoundConstraint_getStatePaths(long jarg1, MocoStateBoundConstraint jarg1_);
+  public final static native void MocoStateBoundConstraint_setLowerBound(long jarg1, MocoStateBoundConstraint jarg1_, long jarg2, Function jarg2_);
+  public final static native void MocoStateBoundConstraint_clearLowerBound(long jarg1, MocoStateBoundConstraint jarg1_);
+  public final static native boolean MocoStateBoundConstraint_hasLowerBound(long jarg1, MocoStateBoundConstraint jarg1_);
+  public final static native long MocoStateBoundConstraint_getLowerBound(long jarg1, MocoStateBoundConstraint jarg1_);
+  public final static native void MocoStateBoundConstraint_setUpperBound(long jarg1, MocoStateBoundConstraint jarg1_, long jarg2, Function jarg2_);
+  public final static native void MocoStateBoundConstraint_clearUpperBound(long jarg1, MocoStateBoundConstraint jarg1_);
+  public final static native boolean MocoStateBoundConstraint_hasUpperBound(long jarg1, MocoStateBoundConstraint jarg1_);
+  public final static native long MocoStateBoundConstraint_getUpperBound(long jarg1, MocoStateBoundConstraint jarg1_);
+  public final static native void MocoStateBoundConstraint_setEqualityWithLower(long jarg1, MocoStateBoundConstraint jarg1_, boolean jarg2);
+  public final static native boolean MocoStateBoundConstraint_getEqualityWithLower(long jarg1, MocoStateBoundConstraint jarg1_);
+  public final static native void delete_MocoStateBoundConstraint(long jarg1);
   public final static native long MocoFrameDistanceConstraintPair_safeDownCast(long jarg1, OpenSimObject jarg1_);
   public final static native void MocoFrameDistanceConstraintPair_assign(long jarg1, MocoFrameDistanceConstraintPair jarg1_, long jarg2, OpenSimObject jarg2_);
   public final static native String MocoFrameDistanceConstraintPair_getClassName();
@@ -958,6 +1023,10 @@ public class opensimMocoJNI {
   public final static native long new_MocoOutputConstraint();
   public final static native void MocoOutputConstraint_setOutputPath(long jarg1, MocoOutputConstraint jarg1_, String jarg2);
   public final static native String MocoOutputConstraint_getOutputPath(long jarg1, MocoOutputConstraint jarg1_);
+  public final static native void MocoOutputConstraint_setSecondOutputPath(long jarg1, MocoOutputConstraint jarg1_, String jarg2);
+  public final static native String MocoOutputConstraint_getSecondOutputPath(long jarg1, MocoOutputConstraint jarg1_);
+  public final static native void MocoOutputConstraint_setOperation(long jarg1, MocoOutputConstraint jarg1_, String jarg2);
+  public final static native String MocoOutputConstraint_getOperation(long jarg1, MocoOutputConstraint jarg1_);
   public final static native void MocoOutputConstraint_setExponent(long jarg1, MocoOutputConstraint jarg1_, int jarg2);
   public final static native int MocoOutputConstraint_getExponent(long jarg1, MocoOutputConstraint jarg1_);
   public final static native void MocoOutputConstraint_setOutputIndex(long jarg1, MocoOutputConstraint jarg1_, int jarg2);
@@ -1138,6 +1207,7 @@ public class opensimMocoJNI {
   public final static native void MocoParameter_setBounds(long jarg1, MocoParameter jarg1_, long jarg2, MocoBounds jarg2_);
   public final static native void MocoParameter_setPropertyName(long jarg1, MocoParameter jarg1_, String jarg2);
   public final static native void MocoParameter_appendComponentPath(long jarg1, MocoParameter jarg1_, String jarg2);
+  public final static native int MocoParameter_getPropertyElement(long jarg1, MocoParameter jarg1_);
   public final static native void MocoParameter_initializeOnModel(long jarg1, MocoParameter jarg1_, long jarg2, Model jarg2_);
   public final static native void MocoParameter_applyParameterToModelProperties(long jarg1, MocoParameter jarg1_, double jarg2);
   public final static native void MocoParameter_printDescription(long jarg1, MocoParameter jarg1_);
@@ -1164,11 +1234,10 @@ public class opensimMocoJNI {
   public final static native void MocoTrajectory_setTime(long jarg1, MocoTrajectory jarg1_, long jarg2, Vector jarg2_);
   public final static native void MocoTrajectory_setState(long jarg1, MocoTrajectory jarg1_, String jarg2, long jarg3, Vector jarg3_);
   public final static native void MocoTrajectory_setControl(long jarg1, MocoTrajectory jarg1_, String jarg2, long jarg3, Vector jarg3_);
-  public final static native void MocoTrajectory_setInputControl__SWIG_0(long jarg1, MocoTrajectory jarg1_, String jarg2, long jarg3, Vector jarg3_);
+  public final static native void MocoTrajectory_setInputControl(long jarg1, MocoTrajectory jarg1_, String jarg2, long jarg3, Vector jarg3_);
   public final static native void MocoTrajectory_setMultiplier(long jarg1, MocoTrajectory jarg1_, String jarg2, long jarg3, Vector jarg3_);
   public final static native void MocoTrajectory_setDerivative(long jarg1, MocoTrajectory jarg1_, String jarg2, long jarg3, Vector jarg3_);
   public final static native void MocoTrajectory_setParameter(long jarg1, MocoTrajectory jarg1_, String jarg2, double jarg3);
-  public final static native void MocoTrajectory_setInputControl__SWIG_1(long jarg1, MocoTrajectory jarg1_, String jarg2, long jarg3);
   public final static native void MocoTrajectory_setStatesTrajectory__SWIG_0(long jarg1, MocoTrajectory jarg1_, long jarg2, TimeSeriesTable jarg2_, boolean jarg3, boolean jarg4);
   public final static native void MocoTrajectory_setStatesTrajectory__SWIG_1(long jarg1, MocoTrajectory jarg1_, long jarg2, TimeSeriesTable jarg2_, boolean jarg3);
   public final static native void MocoTrajectory_setStatesTrajectory__SWIG_2(long jarg1, MocoTrajectory jarg1_, long jarg2, TimeSeriesTable jarg2_);
@@ -1311,15 +1380,15 @@ public class opensimMocoJNI {
   public final static native String MocoDirectCollocationSolver_get_transcription_scheme__SWIG_1(long jarg1, MocoDirectCollocationSolver jarg1_);
   public final static native long MocoDirectCollocationSolver_upd_transcription_scheme__SWIG_1(long jarg1, MocoDirectCollocationSolver jarg1_);
   public final static native void MocoDirectCollocationSolver_set_transcription_scheme__SWIG_1(long jarg1, MocoDirectCollocationSolver jarg1_, String jarg2);
-  public final static native void MocoDirectCollocationSolver_copyProperty_interpolate_control_midpoints(long jarg1, MocoDirectCollocationSolver jarg1_, long jarg2, MocoDirectCollocationSolver jarg2_);
-  public final static native boolean MocoDirectCollocationSolver_get_interpolate_control_midpoints__SWIG_0(long jarg1, MocoDirectCollocationSolver jarg1_, int jarg2);
-  public final static native long MocoDirectCollocationSolver_upd_interpolate_control_midpoints__SWIG_0(long jarg1, MocoDirectCollocationSolver jarg1_, int jarg2);
-  public final static native void MocoDirectCollocationSolver_set_interpolate_control_midpoints__SWIG_0(long jarg1, MocoDirectCollocationSolver jarg1_, int jarg2, boolean jarg3);
-  public final static native int MocoDirectCollocationSolver_append_interpolate_control_midpoints(long jarg1, MocoDirectCollocationSolver jarg1_, boolean jarg2);
-  public final static native void MocoDirectCollocationSolver_constructProperty_interpolate_control_midpoints(long jarg1, MocoDirectCollocationSolver jarg1_, boolean jarg2);
-  public final static native boolean MocoDirectCollocationSolver_get_interpolate_control_midpoints__SWIG_1(long jarg1, MocoDirectCollocationSolver jarg1_);
-  public final static native long MocoDirectCollocationSolver_upd_interpolate_control_midpoints__SWIG_1(long jarg1, MocoDirectCollocationSolver jarg1_);
-  public final static native void MocoDirectCollocationSolver_set_interpolate_control_midpoints__SWIG_1(long jarg1, MocoDirectCollocationSolver jarg1_, boolean jarg2);
+  public final static native void MocoDirectCollocationSolver_copyProperty_interpolate_control_mesh_interior_points(long jarg1, MocoDirectCollocationSolver jarg1_, long jarg2, MocoDirectCollocationSolver jarg2_);
+  public final static native boolean MocoDirectCollocationSolver_get_interpolate_control_mesh_interior_points__SWIG_0(long jarg1, MocoDirectCollocationSolver jarg1_, int jarg2);
+  public final static native long MocoDirectCollocationSolver_upd_interpolate_control_mesh_interior_points__SWIG_0(long jarg1, MocoDirectCollocationSolver jarg1_, int jarg2);
+  public final static native void MocoDirectCollocationSolver_set_interpolate_control_mesh_interior_points__SWIG_0(long jarg1, MocoDirectCollocationSolver jarg1_, int jarg2, boolean jarg3);
+  public final static native int MocoDirectCollocationSolver_append_interpolate_control_mesh_interior_points(long jarg1, MocoDirectCollocationSolver jarg1_, boolean jarg2);
+  public final static native void MocoDirectCollocationSolver_constructProperty_interpolate_control_mesh_interior_points(long jarg1, MocoDirectCollocationSolver jarg1_, boolean jarg2);
+  public final static native boolean MocoDirectCollocationSolver_get_interpolate_control_mesh_interior_points__SWIG_1(long jarg1, MocoDirectCollocationSolver jarg1_);
+  public final static native long MocoDirectCollocationSolver_upd_interpolate_control_mesh_interior_points__SWIG_1(long jarg1, MocoDirectCollocationSolver jarg1_);
+  public final static native void MocoDirectCollocationSolver_set_interpolate_control_mesh_interior_points__SWIG_1(long jarg1, MocoDirectCollocationSolver jarg1_, boolean jarg2);
   public final static native void MocoDirectCollocationSolver_copyProperty_multibody_dynamics_mode(long jarg1, MocoDirectCollocationSolver jarg1_, long jarg2, MocoDirectCollocationSolver jarg2_);
   public final static native String MocoDirectCollocationSolver_get_multibody_dynamics_mode__SWIG_0(long jarg1, MocoDirectCollocationSolver jarg1_, int jarg2);
   public final static native long MocoDirectCollocationSolver_upd_multibody_dynamics_mode__SWIG_0(long jarg1, MocoDirectCollocationSolver jarg1_, int jarg2);
@@ -1438,6 +1507,15 @@ public class opensimMocoJNI {
   public final static native long MocoDirectCollocationSolver_get_implicit_auxiliary_derivative_bounds__SWIG_1(long jarg1, MocoDirectCollocationSolver jarg1_);
   public final static native long MocoDirectCollocationSolver_upd_implicit_auxiliary_derivative_bounds__SWIG_1(long jarg1, MocoDirectCollocationSolver jarg1_);
   public final static native void MocoDirectCollocationSolver_set_implicit_auxiliary_derivative_bounds__SWIG_1(long jarg1, MocoDirectCollocationSolver jarg1_, long jarg2, MocoBounds jarg2_);
+  public final static native void MocoDirectCollocationSolver_copyProperty_kinematic_constraint_method(long jarg1, MocoDirectCollocationSolver jarg1_, long jarg2, MocoDirectCollocationSolver jarg2_);
+  public final static native String MocoDirectCollocationSolver_get_kinematic_constraint_method__SWIG_0(long jarg1, MocoDirectCollocationSolver jarg1_, int jarg2);
+  public final static native long MocoDirectCollocationSolver_upd_kinematic_constraint_method__SWIG_0(long jarg1, MocoDirectCollocationSolver jarg1_, int jarg2);
+  public final static native void MocoDirectCollocationSolver_set_kinematic_constraint_method__SWIG_0(long jarg1, MocoDirectCollocationSolver jarg1_, int jarg2, String jarg3);
+  public final static native int MocoDirectCollocationSolver_append_kinematic_constraint_method(long jarg1, MocoDirectCollocationSolver jarg1_, String jarg2);
+  public final static native void MocoDirectCollocationSolver_constructProperty_kinematic_constraint_method(long jarg1, MocoDirectCollocationSolver jarg1_, String jarg2);
+  public final static native String MocoDirectCollocationSolver_get_kinematic_constraint_method__SWIG_1(long jarg1, MocoDirectCollocationSolver jarg1_);
+  public final static native long MocoDirectCollocationSolver_upd_kinematic_constraint_method__SWIG_1(long jarg1, MocoDirectCollocationSolver jarg1_);
+  public final static native void MocoDirectCollocationSolver_set_kinematic_constraint_method__SWIG_1(long jarg1, MocoDirectCollocationSolver jarg1_, String jarg2);
   public final static native void MocoDirectCollocationSolver_setMesh(long jarg1, MocoDirectCollocationSolver jarg1_, long jarg2, StdVectorDouble jarg2_);
   public final static native void delete_MocoDirectCollocationSolver(long jarg1);
   public final static native long new_MocoTropterSolverNotAvailable(String jarg1, int jarg2, String jarg3);
@@ -1594,15 +1672,42 @@ public class opensimMocoJNI {
   public final static native double MocoCasADiSolver_get_implicit_auxiliary_derivatives_weight__SWIG_1(long jarg1, MocoCasADiSolver jarg1_);
   public final static native long MocoCasADiSolver_upd_implicit_auxiliary_derivatives_weight__SWIG_1(long jarg1, MocoCasADiSolver jarg1_);
   public final static native void MocoCasADiSolver_set_implicit_auxiliary_derivatives_weight__SWIG_1(long jarg1, MocoCasADiSolver jarg1_, double jarg2);
-  public final static native void MocoCasADiSolver_copyProperty_enforce_path_constraint_midpoints(long jarg1, MocoCasADiSolver jarg1_, long jarg2, MocoCasADiSolver jarg2_);
-  public final static native boolean MocoCasADiSolver_get_enforce_path_constraint_midpoints__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, int jarg2);
-  public final static native long MocoCasADiSolver_upd_enforce_path_constraint_midpoints__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, int jarg2);
-  public final static native void MocoCasADiSolver_set_enforce_path_constraint_midpoints__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, int jarg2, boolean jarg3);
-  public final static native int MocoCasADiSolver_append_enforce_path_constraint_midpoints(long jarg1, MocoCasADiSolver jarg1_, boolean jarg2);
-  public final static native void MocoCasADiSolver_constructProperty_enforce_path_constraint_midpoints(long jarg1, MocoCasADiSolver jarg1_, boolean jarg2);
-  public final static native boolean MocoCasADiSolver_get_enforce_path_constraint_midpoints__SWIG_1(long jarg1, MocoCasADiSolver jarg1_);
-  public final static native long MocoCasADiSolver_upd_enforce_path_constraint_midpoints__SWIG_1(long jarg1, MocoCasADiSolver jarg1_);
-  public final static native void MocoCasADiSolver_set_enforce_path_constraint_midpoints__SWIG_1(long jarg1, MocoCasADiSolver jarg1_, boolean jarg2);
+  public final static native void MocoCasADiSolver_copyProperty_enforce_path_constraint_mesh_interior_points(long jarg1, MocoCasADiSolver jarg1_, long jarg2, MocoCasADiSolver jarg2_);
+  public final static native boolean MocoCasADiSolver_get_enforce_path_constraint_mesh_interior_points__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, int jarg2);
+  public final static native long MocoCasADiSolver_upd_enforce_path_constraint_mesh_interior_points__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, int jarg2);
+  public final static native void MocoCasADiSolver_set_enforce_path_constraint_mesh_interior_points__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, int jarg2, boolean jarg3);
+  public final static native int MocoCasADiSolver_append_enforce_path_constraint_mesh_interior_points(long jarg1, MocoCasADiSolver jarg1_, boolean jarg2);
+  public final static native void MocoCasADiSolver_constructProperty_enforce_path_constraint_mesh_interior_points(long jarg1, MocoCasADiSolver jarg1_, boolean jarg2);
+  public final static native boolean MocoCasADiSolver_get_enforce_path_constraint_mesh_interior_points__SWIG_1(long jarg1, MocoCasADiSolver jarg1_);
+  public final static native long MocoCasADiSolver_upd_enforce_path_constraint_mesh_interior_points__SWIG_1(long jarg1, MocoCasADiSolver jarg1_);
+  public final static native void MocoCasADiSolver_set_enforce_path_constraint_mesh_interior_points__SWIG_1(long jarg1, MocoCasADiSolver jarg1_, boolean jarg2);
+  public final static native void MocoCasADiSolver_copyProperty_minimize_state_projection_distance(long jarg1, MocoCasADiSolver jarg1_, long jarg2, MocoCasADiSolver jarg2_);
+  public final static native boolean MocoCasADiSolver_get_minimize_state_projection_distance__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, int jarg2);
+  public final static native long MocoCasADiSolver_upd_minimize_state_projection_distance__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, int jarg2);
+  public final static native void MocoCasADiSolver_set_minimize_state_projection_distance__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, int jarg2, boolean jarg3);
+  public final static native int MocoCasADiSolver_append_minimize_state_projection_distance(long jarg1, MocoCasADiSolver jarg1_, boolean jarg2);
+  public final static native void MocoCasADiSolver_constructProperty_minimize_state_projection_distance(long jarg1, MocoCasADiSolver jarg1_, boolean jarg2);
+  public final static native boolean MocoCasADiSolver_get_minimize_state_projection_distance__SWIG_1(long jarg1, MocoCasADiSolver jarg1_);
+  public final static native long MocoCasADiSolver_upd_minimize_state_projection_distance__SWIG_1(long jarg1, MocoCasADiSolver jarg1_);
+  public final static native void MocoCasADiSolver_set_minimize_state_projection_distance__SWIG_1(long jarg1, MocoCasADiSolver jarg1_, boolean jarg2);
+  public final static native void MocoCasADiSolver_copyProperty_state_projection_distance_weight(long jarg1, MocoCasADiSolver jarg1_, long jarg2, MocoCasADiSolver jarg2_);
+  public final static native double MocoCasADiSolver_get_state_projection_distance_weight__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, int jarg2);
+  public final static native long MocoCasADiSolver_upd_state_projection_distance_weight__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, int jarg2);
+  public final static native void MocoCasADiSolver_set_state_projection_distance_weight__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, int jarg2, double jarg3);
+  public final static native int MocoCasADiSolver_append_state_projection_distance_weight(long jarg1, MocoCasADiSolver jarg1_, double jarg2);
+  public final static native void MocoCasADiSolver_constructProperty_state_projection_distance_weight(long jarg1, MocoCasADiSolver jarg1_, double jarg2);
+  public final static native double MocoCasADiSolver_get_state_projection_distance_weight__SWIG_1(long jarg1, MocoCasADiSolver jarg1_);
+  public final static native long MocoCasADiSolver_upd_state_projection_distance_weight__SWIG_1(long jarg1, MocoCasADiSolver jarg1_);
+  public final static native void MocoCasADiSolver_set_state_projection_distance_weight__SWIG_1(long jarg1, MocoCasADiSolver jarg1_, double jarg2);
+  public final static native void MocoCasADiSolver_copyProperty_projection_slack_variable_bounds(long jarg1, MocoCasADiSolver jarg1_, long jarg2, MocoCasADiSolver jarg2_);
+  public final static native long MocoCasADiSolver_get_projection_slack_variable_bounds__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, int jarg2);
+  public final static native long MocoCasADiSolver_upd_projection_slack_variable_bounds__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, int jarg2);
+  public final static native void MocoCasADiSolver_set_projection_slack_variable_bounds__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, int jarg2, long jarg3, MocoBounds jarg3_);
+  public final static native int MocoCasADiSolver_append_projection_slack_variable_bounds(long jarg1, MocoCasADiSolver jarg1_, long jarg2, MocoBounds jarg2_);
+  public final static native void MocoCasADiSolver_constructProperty_projection_slack_variable_bounds(long jarg1, MocoCasADiSolver jarg1_, long jarg2, MocoBounds jarg2_);
+  public final static native long MocoCasADiSolver_get_projection_slack_variable_bounds__SWIG_1(long jarg1, MocoCasADiSolver jarg1_);
+  public final static native long MocoCasADiSolver_upd_projection_slack_variable_bounds__SWIG_1(long jarg1, MocoCasADiSolver jarg1_);
+  public final static native void MocoCasADiSolver_set_projection_slack_variable_bounds__SWIG_1(long jarg1, MocoCasADiSolver jarg1_, long jarg2, MocoBounds jarg2_);
   public final static native long new_MocoCasADiSolver();
   public final static native boolean MocoCasADiSolver_isAvailable();
   public final static native long MocoCasADiSolver_createGuess__SWIG_0(long jarg1, MocoCasADiSolver jarg1_, String jarg2);
@@ -1787,6 +1892,7 @@ public class opensimMocoJNI {
   public final static native long new_MocoInverse();
   public final static native void MocoInverse_setKinematics(long jarg1, MocoInverse jarg1_, long jarg2, TableProcessor jarg2_);
   public final static native long MocoInverse_initialize(long jarg1, MocoInverse jarg1_);
+  public final static native long MocoInverse_initializeKinematics(long jarg1, MocoInverse jarg1_);
   public final static native long MocoInverse_solve(long jarg1, MocoInverse jarg1_);
   public final static native void delete_MocoInverse(long jarg1);
   public final static native long MocoTrack_safeDownCast(long jarg1, OpenSimObject jarg1_);
@@ -2032,6 +2138,7 @@ public class opensimMocoJNI {
   public final static native long MocoContactTrackingGoal_SWIGUpcast(long jarg1);
   public final static native long MocoContactImpulseTrackingGoalGroup_SWIGUpcast(long jarg1);
   public final static native long MocoContactImpulseTrackingGoal_SWIGUpcast(long jarg1);
+  public final static native long MocoExpressionBasedParameterGoal_SWIGUpcast(long jarg1);
   public final static native long MocoInitialActivationGoal_SWIGUpcast(long jarg1);
   public final static native long MocoJointReactionGoal_SWIGUpcast(long jarg1);
   public final static native long MocoSumSquaredStateGoal_SWIGUpcast(long jarg1);
@@ -2057,6 +2164,8 @@ public class opensimMocoJNI {
   public final static native long MocoConstraintInfo_SWIGUpcast(long jarg1);
   public final static native long MocoPathConstraint_SWIGUpcast(long jarg1);
   public final static native long MocoControlBoundConstraint_SWIGUpcast(long jarg1);
+  public final static native long MocoOutputBoundConstraint_SWIGUpcast(long jarg1);
+  public final static native long MocoStateBoundConstraint_SWIGUpcast(long jarg1);
   public final static native long MocoFrameDistanceConstraintPair_SWIGUpcast(long jarg1);
   public final static native long MocoFrameDistanceConstraint_SWIGUpcast(long jarg1);
   public final static native long MocoOutputConstraint_SWIGUpcast(long jarg1);
diff --git a/Gui/opensim/modeling/src/org/opensim/modeling/opensimSimulationJNI.java b/Gui/opensim/modeling/src/org/opensim/modeling/opensimSimulationJNI.java
index 024e50b76..8e8fa03a2 100644
--- a/Gui/opensim/modeling/src/org/opensim/modeling/opensimSimulationJNI.java
+++ b/Gui/opensim/modeling/src/org/opensim/modeling/opensimSimulationJNI.java
@@ -1551,6 +1551,14 @@ public class opensimSimulationJNI {
   public final static native boolean Force_hasVisualPath(long jarg1, Force jarg1_);
   public final static native long Force_getForceIndex(long jarg1, Force jarg1_);
   public final static native void delete_Force(long jarg1);
+  public final static native long ForceProducer_safeDownCast(long jarg1, OpenSimObject jarg1_);
+  public final static native void ForceProducer_assign(long jarg1, ForceProducer jarg1_, long jarg2, OpenSimObject jarg2_);
+  public final static native String ForceProducer_getClassName();
+  public final static native long ForceProducer_clone(long jarg1, ForceProducer jarg1_);
+  public final static native String ForceProducer_getConcreteClassName(long jarg1, ForceProducer jarg1_);
+  public final static native void ForceProducer_produceForces(long jarg1, ForceProducer jarg1_, long jarg2, State jarg2_, long jarg3);
+  public final static native void ForceProducer_computeForce(long jarg1, ForceProducer jarg1_, long jarg2, State jarg2_, long jarg3, VectorOfSpatialVec jarg3_, long jarg4, Vector jarg4_);
+  public final static native void delete_ForceProducer(long jarg1);
   public final static native long SetForces_safeDownCast(long jarg1, OpenSimObject jarg1_);
   public final static native void SetForces_assign(long jarg1, SetForces jarg1_, long jarg2, OpenSimObject jarg2_);
   public final static native String SetForces_getClassName();
@@ -1797,6 +1805,30 @@ public class opensimSimulationJNI {
   public final static native long TwoFrameLinkerForce_computeDeflection(long jarg1, TwoFrameLinkerForce jarg1_, long jarg2, State jarg2_);
   public final static native long TwoFrameLinkerForce_computeDeflectionRate(long jarg1, TwoFrameLinkerForce jarg1_, long jarg2, State jarg2_);
   public final static native void delete_TwoFrameLinkerForce(long jarg1);
+  public final static native long TwoFrameLinkerForceProducer_safeDownCast(long jarg1, OpenSimObject jarg1_);
+  public final static native void TwoFrameLinkerForceProducer_assign(long jarg1, TwoFrameLinkerForceProducer jarg1_, long jarg2, OpenSimObject jarg2_);
+  public final static native String TwoFrameLinkerForceProducer_getClassName();
+  public final static native long TwoFrameLinkerForceProducer_clone(long jarg1, TwoFrameLinkerForceProducer jarg1_);
+  public final static native String TwoFrameLinkerForceProducer_getConcreteClassName(long jarg1, TwoFrameLinkerForceProducer jarg1_);
+  public final static native void TwoFrameLinkerForceProducer_copyProperty_frames(long jarg1, TwoFrameLinkerForceProducer jarg1_, long jarg2, TwoFrameLinkerForceProducer jarg2_);
+  public final static native long TwoFrameLinkerForceProducer_get_frames(long jarg1, TwoFrameLinkerForceProducer jarg1_, int jarg2);
+  public final static native long TwoFrameLinkerForceProducer_upd_frames(long jarg1, TwoFrameLinkerForceProducer jarg1_, int jarg2);
+  public final static native void TwoFrameLinkerForceProducer_set_frames(long jarg1, TwoFrameLinkerForceProducer jarg1_, int jarg2, long jarg3, PhysicalFrame jarg3_);
+  public final static native int TwoFrameLinkerForceProducer_append_frames(long jarg1, TwoFrameLinkerForceProducer jarg1_, long jarg2, PhysicalFrame jarg2_);
+  public final static native void TwoFrameLinkerForceProducer_constructProperty_frames(long jarg1, TwoFrameLinkerForceProducer jarg1_);
+  public final static native void TwoFrameLinkerForceProducer_PropertyIndex_socket_frame1_set(long jarg1, TwoFrameLinkerForceProducer jarg1_, long jarg2);
+  public final static native long TwoFrameLinkerForceProducer_PropertyIndex_socket_frame1_get(long jarg1, TwoFrameLinkerForceProducer jarg1_);
+  public final static native void TwoFrameLinkerForceProducer_connectSocket_frame1(long jarg1, TwoFrameLinkerForceProducer jarg1_, long jarg2, OpenSimObject jarg2_);
+  public final static native void TwoFrameLinkerForceProducer_PropertyIndex_socket_frame2_set(long jarg1, TwoFrameLinkerForceProducer jarg1_, long jarg2);
+  public final static native long TwoFrameLinkerForceProducer_PropertyIndex_socket_frame2_get(long jarg1, TwoFrameLinkerForceProducer jarg1_);
+  public final static native void TwoFrameLinkerForceProducer_connectSocket_frame2(long jarg1, TwoFrameLinkerForceProducer jarg1_, long jarg2, OpenSimObject jarg2_);
+  public final static native long TwoFrameLinkerForceProducer_getFrame1(long jarg1, TwoFrameLinkerForceProducer jarg1_);
+  public final static native long TwoFrameLinkerForceProducer_getFrame2(long jarg1, TwoFrameLinkerForceProducer jarg1_);
+  public final static native long TwoFrameLinkerForceProducer_computeRelativeOffset(long jarg1, TwoFrameLinkerForceProducer jarg1_, long jarg2, State jarg2_);
+  public final static native long TwoFrameLinkerForceProducer_computeRelativeVelocity(long jarg1, TwoFrameLinkerForceProducer jarg1_, long jarg2, State jarg2_);
+  public final static native long TwoFrameLinkerForceProducer_computeDeflection(long jarg1, TwoFrameLinkerForceProducer jarg1_, long jarg2, State jarg2_);
+  public final static native long TwoFrameLinkerForceProducer_computeDeflectionRate(long jarg1, TwoFrameLinkerForceProducer jarg1_, long jarg2, State jarg2_);
+  public final static native void delete_TwoFrameLinkerForceProducer(long jarg1);
   public final static native long TwoFrameLinkerConstraint_safeDownCast(long jarg1, OpenSimObject jarg1_);
   public final static native void TwoFrameLinkerConstraint_assign(long jarg1, TwoFrameLinkerConstraint jarg1_, long jarg2, OpenSimObject jarg2_);
   public final static native String TwoFrameLinkerConstraint_getClassName();
@@ -3335,6 +3367,62 @@ public class opensimSimulationJNI {
   public final static native void PrescribedController_computeControls(long jarg1, PrescribedController jarg1_, long jarg2, State jarg2_, long jarg3, Vector jarg3_);
   public final static native void PrescribedController_prescribeControlForActuator_private__SWIG_0(long jarg1, PrescribedController jarg1_, String jarg2, long jarg3, Function jarg3_);
   public final static native void PrescribedController_prescribeControlForActuator_private__SWIG_1(long jarg1, PrescribedController jarg1_, int jarg2, long jarg3, Function jarg3_);
+  public final static native long InputController_safeDownCast(long jarg1, OpenSimObject jarg1_);
+  public final static native void InputController_assign(long jarg1, InputController jarg1_, long jarg2, OpenSimObject jarg2_);
+  public final static native String InputController_getClassName();
+  public final static native long InputController_clone(long jarg1, InputController jarg1_);
+  public final static native String InputController_getConcreteClassName(long jarg1, InputController jarg1_);
+  public final static native void InputController_PropertyIndex_input_controls_set(long jarg1, InputController jarg1_, long jarg2);
+  public final static native long InputController_PropertyIndex_input_controls_get(long jarg1, InputController jarg1_);
+  public final static native void InputController_connectInput_controls__SWIG_0(long jarg1, InputController jarg1_, long jarg2, AbstractOutput jarg2_, String jarg3);
+  public final static native void InputController_connectInput_controls__SWIG_1(long jarg1, InputController jarg1_, long jarg2, AbstractOutput jarg2_);
+  public final static native void InputController_connectInput_controls__SWIG_2(long jarg1, InputController jarg1_, long jarg2, AbstractChannel jarg2_, String jarg3);
+  public final static native void InputController_connectInput_controls__SWIG_3(long jarg1, InputController jarg1_, long jarg2, AbstractChannel jarg2_);
+  public final static native void delete_InputController(long jarg1);
+  public final static native long InputController_getInputControlLabels(long jarg1, InputController jarg1_);
+  public final static native void InputController_computeControlsImpl(long jarg1, InputController jarg1_, long jarg2, State jarg2_, long jarg3, Vector jarg3_);
+  public final static native void InputController_computeControls(long jarg1, InputController jarg1_, long jarg2, State jarg2_, long jarg3, Vector jarg3_);
+  public final static native int InputController_getNumInputControls(long jarg1, InputController jarg1_);
+  public final static native long InputController_getControlNames(long jarg1, InputController jarg1_);
+  public final static native long InputController_getControlIndexes(long jarg1, InputController jarg1_);
+  public final static native long SynergyVector_safeDownCast(long jarg1, OpenSimObject jarg1_);
+  public final static native void SynergyVector_assign(long jarg1, SynergyVector jarg1_, long jarg2, OpenSimObject jarg2_);
+  public final static native String SynergyVector_getClassName();
+  public final static native long SynergyVector_clone(long jarg1, SynergyVector jarg1_);
+  public final static native String SynergyVector_getConcreteClassName(long jarg1, SynergyVector jarg1_);
+  public final static native void SynergyVector_copyProperty_synergy_weights(long jarg1, SynergyVector jarg1_, long jarg2, SynergyVector jarg2_);
+  public final static native long SynergyVector_get_synergy_weights__SWIG_0(long jarg1, SynergyVector jarg1_, int jarg2);
+  public final static native long SynergyVector_upd_synergy_weights__SWIG_0(long jarg1, SynergyVector jarg1_, int jarg2);
+  public final static native void SynergyVector_set_synergy_weights__SWIG_0(long jarg1, SynergyVector jarg1_, int jarg2, long jarg3, Vector jarg3_);
+  public final static native int SynergyVector_append_synergy_weights(long jarg1, SynergyVector jarg1_, long jarg2, Vector jarg2_);
+  public final static native void SynergyVector_constructProperty_synergy_weights(long jarg1, SynergyVector jarg1_, long jarg2, Vector jarg2_);
+  public final static native long SynergyVector_get_synergy_weights__SWIG_1(long jarg1, SynergyVector jarg1_);
+  public final static native long SynergyVector_upd_synergy_weights__SWIG_1(long jarg1, SynergyVector jarg1_);
+  public final static native void SynergyVector_set_synergy_weights__SWIG_1(long jarg1, SynergyVector jarg1_, long jarg2, Vector jarg2_);
+  public final static native long new_SynergyVector__SWIG_0();
+  public final static native long new_SynergyVector__SWIG_1(String jarg1, long jarg2, Vector jarg2_);
+  public final static native void delete_SynergyVector(long jarg1);
+  public final static native long SynergyController_safeDownCast(long jarg1, OpenSimObject jarg1_);
+  public final static native void SynergyController_assign(long jarg1, SynergyController jarg1_, long jarg2, OpenSimObject jarg2_);
+  public final static native String SynergyController_getClassName();
+  public final static native long SynergyController_clone(long jarg1, SynergyController jarg1_);
+  public final static native String SynergyController_getConcreteClassName(long jarg1, SynergyController jarg1_);
+  public final static native void SynergyController_copyProperty_synergy_vectors(long jarg1, SynergyController jarg1_, long jarg2, SynergyController jarg2_);
+  public final static native long SynergyController_get_synergy_vectors(long jarg1, SynergyController jarg1_, int jarg2);
+  public final static native long SynergyController_upd_synergy_vectors(long jarg1, SynergyController jarg1_, int jarg2);
+  public final static native void SynergyController_set_synergy_vectors(long jarg1, SynergyController jarg1_, int jarg2, long jarg3, SynergyVector jarg3_);
+  public final static native int SynergyController_append_synergy_vectors(long jarg1, SynergyController jarg1_, long jarg2, SynergyVector jarg2_);
+  public final static native void SynergyController_constructProperty_synergy_vectors(long jarg1, SynergyController jarg1_);
+  public final static native long new_SynergyController__SWIG_0();
+  public final static native void delete_SynergyController(long jarg1);
+  public final static native long new_SynergyController__SWIG_1(long jarg1, SynergyController jarg1_);
+  public final static native void SynergyController_addSynergyVector(long jarg1, SynergyController jarg1_, long jarg2, Vector jarg2_);
+  public final static native void SynergyController_updSynergyVector(long jarg1, SynergyController jarg1_, int jarg2, long jarg3, Vector jarg3_);
+  public final static native long SynergyController_getSynergyVector(long jarg1, SynergyController jarg1_, int jarg2);
+  public final static native int SynergyController_getNumSynergies(long jarg1, SynergyController jarg1_);
+  public final static native long SynergyController_getSynergyVectorsAsMatrix(long jarg1, SynergyController jarg1_);
+  public final static native long SynergyController_getInputControlLabels(long jarg1, SynergyController jarg1_);
+  public final static native void SynergyController_computeControlsImpl(long jarg1, SynergyController jarg1_, long jarg2, State jarg2_, long jarg3, Vector jarg3_);
   public final static native long new_Manager__SWIG_0(long jarg1, Model jarg1_);
   public final static native long new_Manager__SWIG_1(long jarg1, Model jarg1_, long jarg2, State jarg2_);
   public final static native long new_Manager__SWIG_2();
@@ -5545,14 +5633,14 @@ public class opensimSimulationJNI {
   public final static native long new_PathPointSet__SWIG_1(String jarg1, boolean jarg2) throws java.io.IOException;
   public final static native long new_PathPointSet__SWIG_2(String jarg1) throws java.io.IOException;
   public final static native void delete_PathPointSet(long jarg1);
-  public final static native void delete_PointForceDirection(long jarg1);
-  public final static native long new_PointForceDirection__SWIG_0(long jarg1, Vec3 jarg1_, long jarg2, PhysicalFrame jarg2_, long jarg3, Vec3 jarg3_, double jarg4);
-  public final static native long new_PointForceDirection__SWIG_1(long jarg1, Vec3 jarg1_, long jarg2, PhysicalFrame jarg2_, long jarg3, Vec3 jarg3_);
+  public final static native long new_PointForceDirection__SWIG_0(long jarg1, Vec3 jarg1_, long jarg2, PhysicalFrame jarg2_, long jarg3, Vec3 jarg3_);
+  public final static native long new_PointForceDirection__SWIG_1(long jarg1, Vec3 jarg1_, long jarg2, PhysicalFrame jarg2_, long jarg3, Vec3 jarg3_, double jarg4);
   public final static native long PointForceDirection_point(long jarg1, PointForceDirection jarg1_);
   public final static native long PointForceDirection_frame(long jarg1, PointForceDirection jarg1_);
   public final static native long PointForceDirection_direction(long jarg1, PointForceDirection jarg1_);
   public final static native double PointForceDirection_scale(long jarg1, PointForceDirection jarg1_);
   public final static native void PointForceDirection_addToDirection(long jarg1, PointForceDirection jarg1_, long jarg2, Vec3 jarg2_);
+  public final static native void delete_PointForceDirection(long jarg1);
   public final static native long new_ArrayPointForceDirection__SWIG_0(long jarg1, ArrayPointForceDirection jarg1_);
   public final static native void delete_ArrayPointForceDirection(long jarg1);
   public final static native long new_ArrayPointForceDirection__SWIG_2(long jarg1, PointForceDirection jarg1_, int jarg2, int jarg3);
@@ -5600,6 +5688,7 @@ public class opensimSimulationJNI {
   public final static native void delete_AbstractGeometryPath(long jarg1);
   public final static native double AbstractGeometryPath_getLength(long jarg1, AbstractGeometryPath jarg1_, long jarg2, State jarg2_);
   public final static native double AbstractGeometryPath_getLengtheningSpeed(long jarg1, AbstractGeometryPath jarg1_, long jarg2, State jarg2_);
+  public final static native void AbstractGeometryPath_produceForces(long jarg1, AbstractGeometryPath jarg1_, long jarg2, State jarg2_, double jarg3, long jarg4);
   public final static native void AbstractGeometryPath_addInEquivalentForces(long jarg1, AbstractGeometryPath jarg1_, long jarg2, State jarg2_, double jarg3, long jarg4, VectorOfSpatialVec jarg4_, long jarg5, Vector jarg5_);
   public final static native double AbstractGeometryPath_computeMomentArm(long jarg1, AbstractGeometryPath jarg1_, long jarg2, State jarg2_, long jarg3, Coordinate jarg3_);
   public final static native boolean AbstractGeometryPath_isVisualPath(long jarg1, AbstractGeometryPath jarg1_);
@@ -5637,7 +5726,7 @@ public class opensimSimulationJNI {
   public final static native double GeometryPath_getLengtheningSpeed(long jarg1, GeometryPath jarg1_, long jarg2, State jarg2_);
   public final static native void GeometryPath_setLengtheningSpeed(long jarg1, GeometryPath jarg1_, long jarg2, State jarg2_, double jarg3);
   public final static native void GeometryPath_getPointForceDirections(long jarg1, GeometryPath jarg1_, long jarg2, State jarg2_, long jarg3, ArrayPointForceDirection jarg3_);
-  public final static native void GeometryPath_addInEquivalentForces(long jarg1, GeometryPath jarg1_, long jarg2, State jarg2_, double jarg3, long jarg4, VectorOfSpatialVec jarg4_, long jarg5, Vector jarg5_);
+  public final static native void GeometryPath_produceForces(long jarg1, GeometryPath jarg1_, long jarg2, State jarg2_, double jarg3, long jarg4);
   public final static native boolean GeometryPath_isVisualPath(long jarg1, GeometryPath jarg1_);
   public final static native double GeometryPath_computeMomentArm(long jarg1, GeometryPath jarg1_, long jarg2, State jarg2_, long jarg3, Coordinate jarg3_);
   public final static native void GeometryPath_extendPreScale(long jarg1, GeometryPath jarg1_, long jarg2, State jarg2_, long jarg3, ScaleSet jarg3_);
@@ -5695,7 +5784,7 @@ public class opensimSimulationJNI {
   public final static native double FunctionBasedPath_getLength(long jarg1, FunctionBasedPath jarg1_, long jarg2, State jarg2_);
   public final static native double FunctionBasedPath_getLengtheningSpeed(long jarg1, FunctionBasedPath jarg1_, long jarg2, State jarg2_);
   public final static native double FunctionBasedPath_computeMomentArm(long jarg1, FunctionBasedPath jarg1_, long jarg2, State jarg2_, long jarg3, Coordinate jarg3_);
-  public final static native void FunctionBasedPath_addInEquivalentForces(long jarg1, FunctionBasedPath jarg1_, long jarg2, State jarg2_, double jarg3, long jarg4, VectorOfSpatialVec jarg4_, long jarg5, Vector jarg5_);
+  public final static native void FunctionBasedPath_produceForces(long jarg1, FunctionBasedPath jarg1_, long jarg2, State jarg2_, double jarg3, long jarg4);
   public final static native boolean FunctionBasedPath_isVisualPath(long jarg1, FunctionBasedPath jarg1_);
   public final static native void delete_FunctionBasedPath(long jarg1);
   public final static native long Ligament_safeDownCast(long jarg1, OpenSimObject jarg1_);
@@ -5754,7 +5843,6 @@ public class opensimSimulationJNI {
   public final static native boolean Ligament_setForceLengthCurve(long jarg1, Ligament jarg1_, long jarg2, Function jarg2_);
   public final static native double Ligament_getTension(long jarg1, Ligament jarg1_, long jarg2, State jarg2_);
   public final static native double Ligament_computeMomentArm(long jarg1, Ligament jarg1_, long jarg2, State jarg2_, long jarg3, Coordinate jarg3_);
-  public final static native void Ligament_computeForce(long jarg1, Ligament jarg1_, long jarg2, State jarg2_, long jarg3, VectorOfSpatialVec jarg3_, long jarg4, Vector jarg4_);
   public final static native void Ligament_extendPostScale(long jarg1, Ligament jarg1_, long jarg2, State jarg2_, long jarg3, ScaleSet jarg3_);
   public final static native void delete_Ligament(long jarg1);
   public final static native long Blankevoort1991Ligament_safeDownCast(long jarg1, OpenSimObject jarg1_);
@@ -5845,7 +5933,6 @@ public class opensimSimulationJNI {
   public final static native double Blankevoort1991Ligament_getTransitionLength(long jarg1, Blankevoort1991Ligament jarg1_);
   public final static native double Blankevoort1991Ligament_getDampingCoefficientForceTimePerLength(long jarg1, Blankevoort1991Ligament jarg1_);
   public final static native double Blankevoort1991Ligament_computeMomentArm(long jarg1, Blankevoort1991Ligament jarg1_, long jarg2, State jarg2_, long jarg3, Coordinate jarg3_);
-  public final static native void Blankevoort1991Ligament_computeForce(long jarg1, Blankevoort1991Ligament jarg1_, long jarg2, State jarg2_, long jarg3, VectorOfSpatialVec jarg3_, long jarg4, Vector jarg4_);
   public final static native double Blankevoort1991Ligament_computePotentialEnergy(long jarg1, Blankevoort1991Ligament jarg1_, long jarg2, State jarg2_);
   public final static native void Blankevoort1991Ligament_extendPostScale(long jarg1, Blankevoort1991Ligament jarg1_, long jarg2, State jarg2_, long jarg3, ScaleSet jarg3_);
   public final static native long Blankevoort1991Ligament_getRecordLabels(long jarg1, Blankevoort1991Ligament jarg1_);
@@ -5890,7 +5977,6 @@ public class opensimSimulationJNI {
   public final static native double PathActuator_getPower(long jarg1, PathActuator jarg1_, long jarg2, State jarg2_);
   public final static native double PathActuator_getStress(long jarg1, PathActuator jarg1_, long jarg2, State jarg2_);
   public final static native void PathActuator_addNewPathPoint(long jarg1, PathActuator jarg1_, String jarg2, long jarg3, PhysicalFrame jarg3_, long jarg4, Vec3 jarg4_);
-  public final static native void PathActuator_computeForce(long jarg1, PathActuator jarg1_, long jarg2, State jarg2_, long jarg3, VectorOfSpatialVec jarg3_, long jarg4, Vector jarg4_);
   public final static native double PathActuator_computeActuation(long jarg1, PathActuator jarg1_, long jarg2, State jarg2_);
   public final static native double PathActuator_computeMomentArm(long jarg1, PathActuator jarg1_, long jarg2, State jarg2_, long jarg3, Coordinate jarg3_);
   public final static native void delete_PathActuator(long jarg1);
@@ -6232,6 +6318,8 @@ public class opensimSimulationJNI {
   public final static native String ExpressionBasedPointToPointForce_get_expression__SWIG_1(long jarg1, ExpressionBasedPointToPointForce jarg1_);
   public final static native long ExpressionBasedPointToPointForce_upd_expression__SWIG_1(long jarg1, ExpressionBasedPointToPointForce jarg1_);
   public final static native void ExpressionBasedPointToPointForce_set_expression__SWIG_1(long jarg1, ExpressionBasedPointToPointForce jarg1_, String jarg2);
+  public final static native void ExpressionBasedPointToPointForce__has_output_force_magnitude_set(long jarg1, ExpressionBasedPointToPointForce jarg1_, boolean jarg2);
+  public final static native boolean ExpressionBasedPointToPointForce__has_output_force_magnitude_get(long jarg1, ExpressionBasedPointToPointForce jarg1_);
   public final static native long new_ExpressionBasedPointToPointForce__SWIG_0();
   public final static native long new_ExpressionBasedPointToPointForce__SWIG_1(String jarg1, long jarg2, Vec3 jarg2_, String jarg3, long jarg4, Vec3 jarg4_, String jarg5);
   public final static native void ExpressionBasedPointToPointForce_setBody1Name(long jarg1, ExpressionBasedPointToPointForce jarg1_, String jarg2);
@@ -6244,7 +6332,6 @@ public class opensimSimulationJNI {
   public final static native long ExpressionBasedPointToPointForce_getPoint2(long jarg1, ExpressionBasedPointToPointForce jarg1_);
   public final static native void ExpressionBasedPointToPointForce_setExpression(long jarg1, ExpressionBasedPointToPointForce jarg1_, String jarg2);
   public final static native double ExpressionBasedPointToPointForce_getForceMagnitude(long jarg1, ExpressionBasedPointToPointForce jarg1_, long jarg2, State jarg2_);
-  public final static native void ExpressionBasedPointToPointForce_computeForce(long jarg1, ExpressionBasedPointToPointForce jarg1_, long jarg2, State jarg2_, long jarg3, VectorOfSpatialVec jarg3_, long jarg4, Vector jarg4_);
   public final static native long ExpressionBasedPointToPointForce_getRecordLabels(long jarg1, ExpressionBasedPointToPointForce jarg1_);
   public final static native long ExpressionBasedPointToPointForce_getRecordValues(long jarg1, ExpressionBasedPointToPointForce jarg1_, long jarg2, State jarg2_);
   public final static native void delete_ExpressionBasedPointToPointForce(long jarg1);
@@ -6271,13 +6358,14 @@ public class opensimSimulationJNI {
   public final static native String ExpressionBasedCoordinateForce_get_expression__SWIG_1(long jarg1, ExpressionBasedCoordinateForce jarg1_);
   public final static native long ExpressionBasedCoordinateForce_upd_expression__SWIG_1(long jarg1, ExpressionBasedCoordinateForce jarg1_);
   public final static native void ExpressionBasedCoordinateForce_set_expression__SWIG_1(long jarg1, ExpressionBasedCoordinateForce jarg1_, String jarg2);
+  public final static native void ExpressionBasedCoordinateForce__has_output_force_magnitude_set(long jarg1, ExpressionBasedCoordinateForce jarg1_, boolean jarg2);
+  public final static native boolean ExpressionBasedCoordinateForce__has_output_force_magnitude_get(long jarg1, ExpressionBasedCoordinateForce jarg1_);
   public final static native long new_ExpressionBasedCoordinateForce__SWIG_0();
   public final static native long new_ExpressionBasedCoordinateForce__SWIG_1(String jarg1, String jarg2);
   public final static native void ExpressionBasedCoordinateForce_setCoordinateName(long jarg1, ExpressionBasedCoordinateForce jarg1_, String jarg2);
   public final static native String ExpressionBasedCoordinateForce_getCoordinateName(long jarg1, ExpressionBasedCoordinateForce jarg1_);
   public final static native void ExpressionBasedCoordinateForce_setExpression(long jarg1, ExpressionBasedCoordinateForce jarg1_, String jarg2);
   public final static native double ExpressionBasedCoordinateForce_getForceMagnitude(long jarg1, ExpressionBasedCoordinateForce jarg1_, long jarg2, State jarg2_);
-  public final static native void ExpressionBasedCoordinateForce_computeForce(long jarg1, ExpressionBasedCoordinateForce jarg1_, long jarg2, State jarg2_, long jarg3, VectorOfSpatialVec jarg3_, long jarg4, Vector jarg4_);
   public final static native double ExpressionBasedCoordinateForce_calcExpressionForce(long jarg1, ExpressionBasedCoordinateForce jarg1_, long jarg2, State jarg2_);
   public final static native long ExpressionBasedCoordinateForce_getRecordLabels(long jarg1, ExpressionBasedCoordinateForce jarg1_);
   public final static native long ExpressionBasedCoordinateForce_getRecordValues(long jarg1, ExpressionBasedCoordinateForce jarg1_, long jarg2, State jarg2_);
@@ -6528,7 +6616,6 @@ public class opensimSimulationJNI {
   public final static native void FunctionBasedBushingForce_extendFinalizeFromProperties(long jarg1, FunctionBasedBushingForce jarg1_);
   public final static native long FunctionBasedBushingForce_calcStiffnessForce(long jarg1, FunctionBasedBushingForce jarg1_, long jarg2, State jarg2_);
   public final static native long FunctionBasedBushingForce_calcDampingForce(long jarg1, FunctionBasedBushingForce jarg1_, long jarg2, State jarg2_);
-  public final static native void FunctionBasedBushingForce_computeForce(long jarg1, FunctionBasedBushingForce jarg1_, long jarg2, State jarg2_, long jarg3, VectorOfSpatialVec jarg3_, long jarg4, Vector jarg4_);
   public final static native long FunctionBasedBushingForce_getRecordLabels(long jarg1, FunctionBasedBushingForce jarg1_);
   public final static native long FunctionBasedBushingForce_getRecordValues(long jarg1, FunctionBasedBushingForce jarg1_, long jarg2, State jarg2_);
   public final static native void delete_FunctionBasedBushingForce(long jarg1);
@@ -6639,6 +6726,8 @@ public class opensimSimulationJNI {
   public final static native long ExpressionBasedBushingForce_get_translational_damping__SWIG_1(long jarg1, ExpressionBasedBushingForce jarg1_);
   public final static native long ExpressionBasedBushingForce_upd_translational_damping__SWIG_1(long jarg1, ExpressionBasedBushingForce jarg1_);
   public final static native void ExpressionBasedBushingForce_set_translational_damping__SWIG_1(long jarg1, ExpressionBasedBushingForce jarg1_, long jarg2, Vec3 jarg2_);
+  public final static native void ExpressionBasedBushingForce__has_output_bushing_force_set(long jarg1, ExpressionBasedBushingForce jarg1_, boolean jarg2);
+  public final static native boolean ExpressionBasedBushingForce__has_output_bushing_force_get(long jarg1, ExpressionBasedBushingForce jarg1_);
   public final static native long new_ExpressionBasedBushingForce__SWIG_0();
   public final static native long new_ExpressionBasedBushingForce__SWIG_1(String jarg1, long jarg2, PhysicalFrame jarg2_, long jarg3, PhysicalFrame jarg3_);
   public final static native long new_ExpressionBasedBushingForce__SWIG_2(String jarg1, String jarg2, String jarg3);
@@ -6663,6 +6752,7 @@ public class opensimSimulationJNI {
   public final static native String ExpressionBasedBushingForce_getFzExpression(long jarg1, ExpressionBasedBushingForce jarg1_);
   public final static native long ExpressionBasedBushingForce_calcStiffnessForce(long jarg1, ExpressionBasedBushingForce jarg1_, long jarg2, State jarg2_);
   public final static native long ExpressionBasedBushingForce_calcDampingForce(long jarg1, ExpressionBasedBushingForce jarg1_, long jarg2, State jarg2_);
+  public final static native long ExpressionBasedBushingForce_calcBushingForce(long jarg1, ExpressionBasedBushingForce jarg1_, long jarg2, State jarg2_);
   public final static native long ExpressionBasedBushingForce_getRecordLabels(long jarg1, ExpressionBasedBushingForce jarg1_);
   public final static native long ExpressionBasedBushingForce_getRecordValues(long jarg1, ExpressionBasedBushingForce jarg1_, long jarg2, State jarg2_);
   public final static native void delete_ExpressionBasedBushingForce(long jarg1);
@@ -7469,14 +7559,17 @@ public class opensimSimulationJNI {
   public final static native long FrameIterator_getInput(long jarg1, FrameIterator jarg1_, String jarg2);
   public final static native long FrameIterator_tryGetOutput(long jarg1, FrameIterator jarg1_, String jarg2);
   public final static native long FrameIterator_getOutput(long jarg1, FrameIterator jarg1_, String jarg2);
-  public final static native int FrameIterator_getModelingOption(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_, String jarg3);
-  public final static native void FrameIterator_setModelingOption(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native int FrameIterator_getModelingOption__SWIG_0(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native int FrameIterator_getModelingOption__SWIG_1(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
+  public final static native void FrameIterator_setModelingOption__SWIG_0(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native void FrameIterator_setModelingOption__SWIG_1(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_, int jarg4);
   public final static native double FrameIterator_getStateVariableValue__SWIG_0(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native double FrameIterator_getStateVariableValue__SWIG_1(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native void FrameIterator_setStateVariableValue(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_, String jarg3, double jarg4);
   public final static native long FrameIterator_getStateVariableValues(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_);
   public final static native void FrameIterator_setStateVariableValues(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_, long jarg3, Vector jarg3_);
-  public final static native double FrameIterator_getStateVariableDerivativeValue(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double FrameIterator_getStateVariableDerivativeValue__SWIG_0(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double FrameIterator_getStateVariableDerivativeValue__SWIG_1(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native long FrameIterator_resolveVariableNameAndOwner(long jarg1, FrameIterator jarg1_, long jarg2, ComponentPath jarg2_, long jarg3);
   public final static native double FrameIterator_getDiscreteVariableValue(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native long FrameIterator_getDiscreteVariableAbstractValue(long jarg1, FrameIterator jarg1_, long jarg2, State jarg2_, String jarg3);
@@ -7610,14 +7703,17 @@ public class opensimSimulationJNI {
   public final static native long BodyIterator_getInput(long jarg1, BodyIterator jarg1_, String jarg2);
   public final static native long BodyIterator_tryGetOutput(long jarg1, BodyIterator jarg1_, String jarg2);
   public final static native long BodyIterator_getOutput(long jarg1, BodyIterator jarg1_, String jarg2);
-  public final static native int BodyIterator_getModelingOption(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_, String jarg3);
-  public final static native void BodyIterator_setModelingOption(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native int BodyIterator_getModelingOption__SWIG_0(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native int BodyIterator_getModelingOption__SWIG_1(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
+  public final static native void BodyIterator_setModelingOption__SWIG_0(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native void BodyIterator_setModelingOption__SWIG_1(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_, int jarg4);
   public final static native double BodyIterator_getStateVariableValue__SWIG_0(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native double BodyIterator_getStateVariableValue__SWIG_1(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native void BodyIterator_setStateVariableValue(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_, String jarg3, double jarg4);
   public final static native long BodyIterator_getStateVariableValues(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_);
   public final static native void BodyIterator_setStateVariableValues(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_, long jarg3, Vector jarg3_);
-  public final static native double BodyIterator_getStateVariableDerivativeValue(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double BodyIterator_getStateVariableDerivativeValue__SWIG_0(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double BodyIterator_getStateVariableDerivativeValue__SWIG_1(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native long BodyIterator_resolveVariableNameAndOwner(long jarg1, BodyIterator jarg1_, long jarg2, ComponentPath jarg2_, long jarg3);
   public final static native double BodyIterator_getDiscreteVariableValue(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native long BodyIterator_getDiscreteVariableAbstractValue(long jarg1, BodyIterator jarg1_, long jarg2, State jarg2_, String jarg3);
@@ -7802,6 +7898,7 @@ public class opensimSimulationJNI {
   public final static native void MuscleIterator_getControls(long jarg1, MuscleIterator jarg1_, long jarg2, Vector jarg2_, long jarg3, Vector jarg3_);
   public final static native void MuscleIterator_setControls(long jarg1, MuscleIterator jarg1_, long jarg2, Vector jarg2_, long jarg3, Vector jarg3_);
   public final static native void MuscleIterator_addInControls(long jarg1, MuscleIterator jarg1_, long jarg2, Vector jarg2_, long jarg3, Vector jarg3_);
+  public final static native void MuscleIterator_produceForces(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3);
   public final static native boolean MuscleIterator_get_appliesForce__SWIG_0(long jarg1, MuscleIterator jarg1_, int jarg2);
   public final static native boolean MuscleIterator_get_appliesForce__SWIG_1(long jarg1, MuscleIterator jarg1_);
   public final static native boolean MuscleIterator__has_output_potential_energy_get(long jarg1, MuscleIterator jarg1_);
@@ -7841,14 +7938,17 @@ public class opensimSimulationJNI {
   public final static native long MuscleIterator_getInput(long jarg1, MuscleIterator jarg1_, String jarg2);
   public final static native long MuscleIterator_tryGetOutput(long jarg1, MuscleIterator jarg1_, String jarg2);
   public final static native long MuscleIterator_getOutput(long jarg1, MuscleIterator jarg1_, String jarg2);
-  public final static native int MuscleIterator_getModelingOption(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
-  public final static native void MuscleIterator_setModelingOption(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native int MuscleIterator_getModelingOption__SWIG_0(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native int MuscleIterator_getModelingOption__SWIG_1(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
+  public final static native void MuscleIterator_setModelingOption__SWIG_0(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native void MuscleIterator_setModelingOption__SWIG_1(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_, int jarg4);
   public final static native double MuscleIterator_getStateVariableValue__SWIG_0(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native double MuscleIterator_getStateVariableValue__SWIG_1(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native void MuscleIterator_setStateVariableValue(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3, double jarg4);
   public final static native long MuscleIterator_getStateVariableValues(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_);
   public final static native void MuscleIterator_setStateVariableValues(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3, Vector jarg3_);
-  public final static native double MuscleIterator_getStateVariableDerivativeValue(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double MuscleIterator_getStateVariableDerivativeValue__SWIG_0(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double MuscleIterator_getStateVariableDerivativeValue__SWIG_1(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native long MuscleIterator_resolveVariableNameAndOwner(long jarg1, MuscleIterator jarg1_, long jarg2, ComponentPath jarg2_, long jarg3);
   public final static native double MuscleIterator_getDiscreteVariableValue(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native long MuscleIterator_getDiscreteVariableAbstractValue(long jarg1, MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
@@ -7936,14 +8036,17 @@ public class opensimSimulationJNI {
   public final static native long ModelComponentIterator_getInput(long jarg1, ModelComponentIterator jarg1_, String jarg2);
   public final static native long ModelComponentIterator_tryGetOutput(long jarg1, ModelComponentIterator jarg1_, String jarg2);
   public final static native long ModelComponentIterator_getOutput(long jarg1, ModelComponentIterator jarg1_, String jarg2);
-  public final static native int ModelComponentIterator_getModelingOption(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3);
-  public final static native void ModelComponentIterator_setModelingOption(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native int ModelComponentIterator_getModelingOption__SWIG_0(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native int ModelComponentIterator_getModelingOption__SWIG_1(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
+  public final static native void ModelComponentIterator_setModelingOption__SWIG_0(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native void ModelComponentIterator_setModelingOption__SWIG_1(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_, int jarg4);
   public final static native double ModelComponentIterator_getStateVariableValue__SWIG_0(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native double ModelComponentIterator_getStateVariableValue__SWIG_1(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native void ModelComponentIterator_setStateVariableValue(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3, double jarg4);
   public final static native long ModelComponentIterator_getStateVariableValues(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_);
   public final static native void ModelComponentIterator_setStateVariableValues(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_, long jarg3, Vector jarg3_);
-  public final static native double ModelComponentIterator_getStateVariableDerivativeValue(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double ModelComponentIterator_getStateVariableDerivativeValue__SWIG_0(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double ModelComponentIterator_getStateVariableDerivativeValue__SWIG_1(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native long ModelComponentIterator_resolveVariableNameAndOwner(long jarg1, ModelComponentIterator jarg1_, long jarg2, ComponentPath jarg2_, long jarg3);
   public final static native double ModelComponentIterator_getDiscreteVariableValue(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native long ModelComponentIterator_getDiscreteVariableAbstractValue(long jarg1, ModelComponentIterator jarg1_, long jarg2, State jarg2_, String jarg3);
@@ -8047,14 +8150,17 @@ public class opensimSimulationJNI {
   public final static native long JointIterator_getInput(long jarg1, JointIterator jarg1_, String jarg2);
   public final static native long JointIterator_tryGetOutput(long jarg1, JointIterator jarg1_, String jarg2);
   public final static native long JointIterator_getOutput(long jarg1, JointIterator jarg1_, String jarg2);
-  public final static native int JointIterator_getModelingOption(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_, String jarg3);
-  public final static native void JointIterator_setModelingOption(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native int JointIterator_getModelingOption__SWIG_0(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native int JointIterator_getModelingOption__SWIG_1(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
+  public final static native void JointIterator_setModelingOption__SWIG_0(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native void JointIterator_setModelingOption__SWIG_1(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_, int jarg4);
   public final static native double JointIterator_getStateVariableValue__SWIG_0(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native double JointIterator_getStateVariableValue__SWIG_1(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native void JointIterator_setStateVariableValue(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_, String jarg3, double jarg4);
   public final static native long JointIterator_getStateVariableValues(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_);
   public final static native void JointIterator_setStateVariableValues(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_, long jarg3, Vector jarg3_);
-  public final static native double JointIterator_getStateVariableDerivativeValue(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double JointIterator_getStateVariableDerivativeValue__SWIG_0(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double JointIterator_getStateVariableDerivativeValue__SWIG_1(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native long JointIterator_resolveVariableNameAndOwner(long jarg1, JointIterator jarg1_, long jarg2, ComponentPath jarg2_, long jarg3);
   public final static native double JointIterator_getDiscreteVariableValue(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native long JointIterator_getDiscreteVariableAbstractValue(long jarg1, JointIterator jarg1_, long jarg2, State jarg2_, String jarg3);
@@ -8116,6 +8222,8 @@ public class opensimSimulationJNI {
   public final static native void ActuatorIterator_addInControls(long jarg1, ActuatorIterator jarg1_, long jarg2, Vector jarg2_, long jarg3, Vector jarg3_);
   public final static native double ActuatorIterator_getPower(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_);
   public final static native void ActuatorIterator_computeEquilibrium(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_);
+  public final static native void ActuatorIterator_produceForces(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, long jarg3);
+  public final static native void ActuatorIterator_computeForce(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, long jarg3, VectorOfSpatialVec jarg3_, long jarg4, Vector jarg4_);
   public final static native boolean ActuatorIterator_get_appliesForce__SWIG_0(long jarg1, ActuatorIterator jarg1_, int jarg2);
   public final static native boolean ActuatorIterator_get_appliesForce__SWIG_1(long jarg1, ActuatorIterator jarg1_);
   public final static native boolean ActuatorIterator__has_output_potential_energy_get(long jarg1, ActuatorIterator jarg1_);
@@ -8158,14 +8266,17 @@ public class opensimSimulationJNI {
   public final static native long ActuatorIterator_getInput(long jarg1, ActuatorIterator jarg1_, String jarg2);
   public final static native long ActuatorIterator_tryGetOutput(long jarg1, ActuatorIterator jarg1_, String jarg2);
   public final static native long ActuatorIterator_getOutput(long jarg1, ActuatorIterator jarg1_, String jarg2);
-  public final static native int ActuatorIterator_getModelingOption(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, String jarg3);
-  public final static native void ActuatorIterator_setModelingOption(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native int ActuatorIterator_getModelingOption__SWIG_0(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native int ActuatorIterator_getModelingOption__SWIG_1(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
+  public final static native void ActuatorIterator_setModelingOption__SWIG_0(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native void ActuatorIterator_setModelingOption__SWIG_1(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_, int jarg4);
   public final static native double ActuatorIterator_getStateVariableValue__SWIG_0(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native double ActuatorIterator_getStateVariableValue__SWIG_1(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native void ActuatorIterator_setStateVariableValue(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, String jarg3, double jarg4);
   public final static native long ActuatorIterator_getStateVariableValues(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_);
   public final static native void ActuatorIterator_setStateVariableValues(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, long jarg3, Vector jarg3_);
-  public final static native double ActuatorIterator_getStateVariableDerivativeValue(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double ActuatorIterator_getStateVariableDerivativeValue__SWIG_0(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double ActuatorIterator_getStateVariableDerivativeValue__SWIG_1(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native long ActuatorIterator_resolveVariableNameAndOwner(long jarg1, ActuatorIterator jarg1_, long jarg2, ComponentPath jarg2_, long jarg3);
   public final static native double ActuatorIterator_getDiscreteVariableValue(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native long ActuatorIterator_getDiscreteVariableAbstractValue(long jarg1, ActuatorIterator jarg1_, long jarg2, State jarg2_, String jarg3);
@@ -8390,6 +8501,7 @@ public class opensimSimulationJNI {
   public final static native void Thelen2003MuscleIterator_getControls(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, Vector jarg2_, long jarg3, Vector jarg3_);
   public final static native void Thelen2003MuscleIterator_setControls(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, Vector jarg2_, long jarg3, Vector jarg3_);
   public final static native void Thelen2003MuscleIterator_addInControls(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, Vector jarg2_, long jarg3, Vector jarg3_);
+  public final static native void Thelen2003MuscleIterator_produceForces(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3);
   public final static native boolean Thelen2003MuscleIterator_get_appliesForce__SWIG_0(long jarg1, Thelen2003MuscleIterator jarg1_, int jarg2);
   public final static native boolean Thelen2003MuscleIterator_get_appliesForce__SWIG_1(long jarg1, Thelen2003MuscleIterator jarg1_);
   public final static native boolean Thelen2003MuscleIterator__has_output_potential_energy_get(long jarg1, Thelen2003MuscleIterator jarg1_);
@@ -8429,14 +8541,17 @@ public class opensimSimulationJNI {
   public final static native long Thelen2003MuscleIterator_getInput(long jarg1, Thelen2003MuscleIterator jarg1_, String jarg2);
   public final static native long Thelen2003MuscleIterator_tryGetOutput(long jarg1, Thelen2003MuscleIterator jarg1_, String jarg2);
   public final static native long Thelen2003MuscleIterator_getOutput(long jarg1, Thelen2003MuscleIterator jarg1_, String jarg2);
-  public final static native int Thelen2003MuscleIterator_getModelingOption(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
-  public final static native void Thelen2003MuscleIterator_setModelingOption(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native int Thelen2003MuscleIterator_getModelingOption__SWIG_0(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native int Thelen2003MuscleIterator_getModelingOption__SWIG_1(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
+  public final static native void Thelen2003MuscleIterator_setModelingOption__SWIG_0(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native void Thelen2003MuscleIterator_setModelingOption__SWIG_1(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_, int jarg4);
   public final static native double Thelen2003MuscleIterator_getStateVariableValue__SWIG_0(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native double Thelen2003MuscleIterator_getStateVariableValue__SWIG_1(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native void Thelen2003MuscleIterator_setStateVariableValue(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3, double jarg4);
   public final static native long Thelen2003MuscleIterator_getStateVariableValues(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_);
   public final static native void Thelen2003MuscleIterator_setStateVariableValues(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3, Vector jarg3_);
-  public final static native double Thelen2003MuscleIterator_getStateVariableDerivativeValue(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double Thelen2003MuscleIterator_getStateVariableDerivativeValue__SWIG_0(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double Thelen2003MuscleIterator_getStateVariableDerivativeValue__SWIG_1(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native long Thelen2003MuscleIterator_resolveVariableNameAndOwner(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, ComponentPath jarg2_, long jarg3);
   public final static native double Thelen2003MuscleIterator_getDiscreteVariableValue(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native long Thelen2003MuscleIterator_getDiscreteVariableAbstractValue(long jarg1, Thelen2003MuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
@@ -8674,6 +8789,7 @@ public class opensimSimulationJNI {
   public final static native void Millard2012EquilibriumMuscleIterator_getControls(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, Vector jarg2_, long jarg3, Vector jarg3_);
   public final static native void Millard2012EquilibriumMuscleIterator_setControls(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, Vector jarg2_, long jarg3, Vector jarg3_);
   public final static native void Millard2012EquilibriumMuscleIterator_addInControls(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, Vector jarg2_, long jarg3, Vector jarg3_);
+  public final static native void Millard2012EquilibriumMuscleIterator_produceForces(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3);
   public final static native boolean Millard2012EquilibriumMuscleIterator_get_appliesForce__SWIG_0(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, int jarg2);
   public final static native boolean Millard2012EquilibriumMuscleIterator_get_appliesForce__SWIG_1(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_);
   public final static native boolean Millard2012EquilibriumMuscleIterator__has_output_potential_energy_get(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_);
@@ -8713,14 +8829,17 @@ public class opensimSimulationJNI {
   public final static native long Millard2012EquilibriumMuscleIterator_getInput(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, String jarg2);
   public final static native long Millard2012EquilibriumMuscleIterator_tryGetOutput(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, String jarg2);
   public final static native long Millard2012EquilibriumMuscleIterator_getOutput(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, String jarg2);
-  public final static native int Millard2012EquilibriumMuscleIterator_getModelingOption(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
-  public final static native void Millard2012EquilibriumMuscleIterator_setModelingOption(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native int Millard2012EquilibriumMuscleIterator_getModelingOption__SWIG_0(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native int Millard2012EquilibriumMuscleIterator_getModelingOption__SWIG_1(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
+  public final static native void Millard2012EquilibriumMuscleIterator_setModelingOption__SWIG_0(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3, int jarg4);
+  public final static native void Millard2012EquilibriumMuscleIterator_setModelingOption__SWIG_1(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_, int jarg4);
   public final static native double Millard2012EquilibriumMuscleIterator_getStateVariableValue__SWIG_0(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native double Millard2012EquilibriumMuscleIterator_getStateVariableValue__SWIG_1(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native void Millard2012EquilibriumMuscleIterator_setStateVariableValue(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3, double jarg4);
   public final static native long Millard2012EquilibriumMuscleIterator_getStateVariableValues(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_);
   public final static native void Millard2012EquilibriumMuscleIterator_setStateVariableValues(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3, Vector jarg3_);
-  public final static native double Millard2012EquilibriumMuscleIterator_getStateVariableDerivativeValue(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double Millard2012EquilibriumMuscleIterator_getStateVariableDerivativeValue__SWIG_0(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
+  public final static native double Millard2012EquilibriumMuscleIterator_getStateVariableDerivativeValue__SWIG_1(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, long jarg3, ComponentPath jarg3_);
   public final static native long Millard2012EquilibriumMuscleIterator_resolveVariableNameAndOwner(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, ComponentPath jarg2_, long jarg3);
   public final static native double Millard2012EquilibriumMuscleIterator_getDiscreteVariableValue(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
   public final static native long Millard2012EquilibriumMuscleIterator_getDiscreteVariableAbstractValue(long jarg1, Millard2012EquilibriumMuscleIterator jarg1_, long jarg2, State jarg2_, String jarg3);
@@ -9694,6 +9813,7 @@ public class opensimSimulationJNI {
   public final static native long ModelComponentSetConstraints_SWIGUpcast(long jarg1);
   public final static native long ConstraintSet_SWIGUpcast(long jarg1);
   public final static native long Force_SWIGUpcast(long jarg1);
+  public final static native long ForceProducer_SWIGUpcast(long jarg1);
   public final static native long SetForces_SWIGUpcast(long jarg1);
   public final static native long ModelComponentSetForces_SWIGUpcast(long jarg1);
   public final static native long ForceSet_SWIGUpcast(long jarg1);
@@ -9701,6 +9821,7 @@ public class opensimSimulationJNI {
   public final static native long SetExternalForces_SWIGUpcast(long jarg1);
   public final static native long ModelComponentSetExternalForces_SWIGUpcast(long jarg1);
   public final static native long TwoFrameLinkerForce_SWIGUpcast(long jarg1);
+  public final static native long TwoFrameLinkerForceProducer_SWIGUpcast(long jarg1);
   public final static native long TwoFrameLinkerConstraint_SWIGUpcast(long jarg1);
   public final static native long FreeJoint_SWIGUpcast(long jarg1);
   public final static native long CustomJoint_SWIGUpcast(long jarg1);
@@ -9748,6 +9869,9 @@ public class opensimSimulationJNI {
   public final static native long ControlLinearNode_SWIGUpcast(long jarg1);
   public final static native long ControlLinear_SWIGUpcast(long jarg1);
   public final static native long PrescribedController_SWIGUpcast(long jarg1);
+  public final static native long InputController_SWIGUpcast(long jarg1);
+  public final static native long SynergyVector_SWIGUpcast(long jarg1);
+  public final static native long SynergyController_SWIGUpcast(long jarg1);
   public final static native long AbstractTool_SWIGUpcast(long jarg1);
   public final static native long Point_SWIGUpcast(long jarg1);
   public final static native long Station_SWIGUpcast(long jarg1);