#ifndef TORQUEMUSCLEFUNCTIONFACTORY_H_
#define TORQUEMUSCLEFUNCTIONFACTORY_H_
/*-------------------------------------------------------------------------
                OpenSim:  SmoothSegmentedFunctionFactory.cpp
 --------------------------------------------------------------------------
 The OpenSim API is a toolkit for musculoskeletal modeling and simulation.
 See http:%opensim.stanford.edu and the NOTICE file for more information.
 OpenSim is developed at Stanford University and supported by the US
 National Institutes of Health (U54 GM072970, R24 HD065690) and by DARPA
 through the Warrior Web program.

 Copyright (c) 2005-2012 Stanford University and the Authors
 Author(s): Matthew Millard

 Licensed under the Apache License, Version 2.0 (the 'License'); you may
 not use this file except in compliance with the License. You may obtain a
 copy of the License at http:%www.apache.org/licenses/LICENSE-2.0.

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an 'AS IS' BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 --------------------------------------------------------------------------

 Derivative work
 Date      : September 2016
 Authors(s): Millard
 Updates   : Made active torque-angle, passive-torque-angle, torque-velocity
             and tendon-torque-angle curves based on the equivalent line-type
             curves in OpenSim.
*/

#include "../geometry/SmoothSegmentedFunction.h"
#include "../geometry/SegmentedQuinticBezierToolkit.h"

#include <cstdio>
#include <iostream>
#include <fstream>
#include <cmath>

namespace RigidBodyDynamics {
  namespace Addons {
  namespace Muscle{

class TorqueMuscleFunctionFactory
{
  public:


  /**
  This is a function that will produce a C2 (continuous to the second
  derivative) active torque angle curve. This Bezier curve has been
  fitted to match the active-torque-angle curve described in

  Anderson, Dennis E., Michael L. Madigan, and Maury A. Nussbaum. 
  "Maximum voluntary joint torque as a function of joint angle and 
  angular velocity: model development and application to the lower 
  limb." Journal of biomechanics 40, no. 14 (2007): 3105-3113.

  but note that its range is normalized to [0,1].

  @param c2 (radians)
   The active-torque-angle width parameter. The parameter c2
   is defined by Anderson et al. as

  c2 = pi/(theta_max - theta_min). 

  @param c3 : (radians)
  Then angle which has the largest active-torque.

  @param curveName The name of the joint torque this curve applies to. This
    curve name should have the name of the joint and the
    direction (e.g. hipExtensionTorqueMuscle) so that if
    this curve ever causes an exception, a user friendly
    error message can be displayed to the end user to help
    them debug their model.

  @param smoothSegmentedFunctionToUpdate
      A SmoothSegmentedFunction object that will be erased and filled with 
      the coefficients that are defined by this curve.


*/
static void createAnderson2007ActiveTorqueAngleCurve(
    double c2, 
    double c3,
    const std::string& curveName,
    RigidBodyDynamics::Addons::Geometry::SmoothSegmentedFunction&
      smoothSegmentedFunctionToUpdate);

  /**
  This is a function that will produce a C2 (continuous to the second
  derivative) active torque (angular) velocity curve. This Bezier curve 
  has been fitted to match the active-torque-angle curve described in

  Anderson, Dennis E., Michael L. Madigan, and Maury A. Nussbaum. 
  "Maximum voluntary joint torque as a function of joint angle and 
  angular velocity: model development and application to the lower 
  limb." Journal of biomechanics 40, no. 14 (2007): 3105-3113.

  While the concentric side of the Bezier curve and the original 
  formulation match, the eccentric side does not: the equations 
  Anderson et al. chose decrease down to 0 rapidly. Since Anderson
  et al. did not collect data at the higher eccentric velocities the
  oddities in their chosen curves are likely due to the parameterization
  they chose. The eccentric side of the Bezier curve will be fitted
  so that, if possible, it passes close to the value of the original
  curves for theta = -60 deg/s within the limits imposed by 
  minEccentricMultiplier and maxEccentricMultiplier.

  @param c4 (rads/s)
  Angular velocity when the torque is 75% of the maximum 
  isometric torque.

  @param c5 (rads/s)
  Angular velocity when the torque is 50% of the maximum 
  isometric torque.

  @param c6 
  Multiplier that Anderson et al. uses to describe the 
  change in slope of the curve as the contraction velocity
  changes sign from + to -.

  @param minEccentricMultiplier
  The minimum value of the torque-(angular)-velocity curve 
  tends to at large eccentric contraction velocities. Note
  minEccentricMultiplier > 1.0

  @param maxEccentricMultiplier
  The value of the torque-(angular)-velocity curve tends
  to at large eccentric contraction velocities. Note
  maxEccentricMultiplier > minEccentricMultiplier.

  @param curveName The name of the joint torque this curve applies to. This
    curve name should have the name of the joint and the
    direction (e.g. hipExtensionTorqueMuscle) so that if
    this curve ever causes an exception, a user friendly
    error message can be displayed to the end user to help
    them debug their model.

  @param smoothSegmentedFunctionToUpdate
      A SmoothSegmentedFunction object that will be erased and filled with 
      the coefficients that are defined by this curve.

  */
  static void createAnderson2007ActiveTorqueVelocityCurve(
      double c4, 
      double c5,
      double c6,
      double minEccentricMultiplier,
      double maxEccentricMultiplier,
      const std::string& curveName,
      RigidBodyDynamics::Addons::Geometry::SmoothSegmentedFunction&
        smoothSegmentedFunctionToUpdate);

  /**
  This is a function that will produce a C2 (continuous to the second
  derivative) passive torque angle curve described in

  Anderson, Dennis E., Michael L. Madigan, and Maury A. Nussbaum. 
  "Maximum voluntary joint torque as a function of joint angle and 
  angular velocity: model development and application to the lower 
  limb." Journal of biomechanics 40, no. 14 (2007): 3105-3113.

  Note the following differences between this implementation and
  the original equations presented in Anderson et al.:
  
  1. This function will return a curve that is fitted to the
  positive side of the curve defined by the coefficients 
  b1, k1, b2, and k2. Because of the sign convention employed by
  Anderson et al. the positive side of the curve corresponds to
  the passive curve generated by the torque actuator associated
  with the rest of the coefficients.

  2. This function has been normalized so that a value of 1.0 
   corresponds to one-maximum-isometric-active-contraction
   torque, or c1*subjectWeightInNewtons*subjectHeightInMeters.

  @param scale
   The scaling factor used on the c1 column in Table 3 of 
   Anderson et al.:

   scale = subjectWeightInNewtons * subjectHeightInMeters

  @param c1
   The normalized c1 parameter listed in Tabel 3 of 
   Anderson et al.

  @param b1
   The passive torque angle curve parameter used in 
   Anderson et al.'s Eqn. 1:

   torquePassive = b1*exp(k1*theta) + b2*exp(k2*theta)

  @param k1
   The term k1 in Anderson et al.'s Eqn. 1.

  @param b2
   The term b2 in Anderson et al.'s Eqn. 1.

  @param k2
   The term k2 in Anderson et al.'s Eqn. 1.

  @param curveName The name of the joint torque this curve applies to. This
     curve name should have the name of the joint and the
     direction (e.g. hipExtensionTorqueMuscle) so that if
     this curve ever causes an exception, a user friendly
     error message can be displayed to the end user to help
     them debug their model.

  @param smoothSegmentedFunctionToUpdate
      A SmoothSegmentedFunction object that will be erased and filled with 
      the coefficients that are defined by this curve. 
  */
  static void createAnderson2007PassiveTorqueAngleCurve(
      double scale,
      double c1,
      double b1,
      double k1,
      double b2,
      double k2,      
      const std::string& curveName,
      RigidBodyDynamics::Addons::Geometry::SmoothSegmentedFunction&
        smoothSegmentedFunctionToUpdate);


  /**
    This function creates a normalized torque-velocity curve. The concentric
    side of the curve is fitted to Hill's hyperbola that passes through
    the value of tv-at-half-of-the-maximum-concentric-velocity (a parameter
    supplied by the user). The eccentric side of the curve rapidly, but smoothly
    approaches a terminal value of 
    tv-at-the-maximum-eccentric-contraction-velocity. Outside of the normalized
    velocities of -1 to 1 the curve takes the values of 0, and 
    tvAtEccentricOmegaMax respectively with a slope of 0.

    \image html fig_MuscleAddon_TorqueMuscleFunctionFactory_TorqueVelocityCurveSimple.png

    @param tvAtEccentricOmegaMax
       The value of the torque-velocity-multiplier at the maximum 
       eccentric contraction velocity. This value must be 

    @param tvAtHalfConcentricOmegaMax
       The value of the torque-velocity-

    @param curveName The name of the joint torque this curve applies to. This
       curve name should have the name of the joint and the
       direction (e.g. hipExtensionTorqueMuscle) so that if
       this curve ever causes an exception, a user friendly
       error message can be displayed to the end user to help
       them debug their model.

    @param smoothSegmentedFunctionToUpdate
        A SmoothSegmentedFunction object that will be erased and filled with 
        the coefficients that are defined by this curve. 

    <b>aborts</b>
    -tvAtEccentricOmegaMax < 1.05
    -tvAtHalfOmegaMax >= 0.45    
    -tvAtHalfOmegaMax <= 0.05

    <b>References</b>
    Hill, A. V. (1938). The heat of shortening and the dynamic constants of 
    muscle. Proceedings of the Royal Society of London B: Biological Sciences, 
    126(843), 136-195.

  */
  
  static void createTorqueVelocityCurve(
      double tvAtEccentricOmegaMax,
      double tvAtHalfConcentricOmegaMax,
      const std::string& curveName,
      RigidBodyDynamics::Addons::Geometry::SmoothSegmentedFunction&
        smoothSegmentedFunctionToUpdate );

  /**
    This function creates a normalized torque-velocity curve. The concentric
    side of the curve is fitted to Hill's hyperbola that passes through
    the value of tv-at-half-of-the-maximum-concentric-velocity (a parameter
    supplied by the user). The eccentric side of the curve rapidly, but smoothly
    approaches a terminal value of 
    tv-at-the-maximum-eccentric-contraction-velocity. Shape of the eccentric
    side of the curve can be changed using the slopeNearEccentricOmegaMax 
    and curviness variables. Outside of the normalized
    velocities of -1 to 1 the curve takes the values of 
    slopeAtConcentricOmegaMax and slopeAtEccentricOmegaMax respectively.

    \image html fig_MuscleAddon_TorqueMuscleFunctionFactory_TorqueVelocityCurve.png

    @param tvAtEccentricOmegaMax
       The value of the torque-velocity-multiplier at the maximum 
       eccentric contraction velocity. This value must be 

    @param tvAtHalfConcentricOmegaMax
       The value of the torque-velocity-

    @param slopeAtConcentricOmegaMax
      The slope of the curve at a normalized angular velocity of -1. This slope
      is used to extrapolate \f$\mathbf{t}_V\f$ for normalized angular velocities
      of less than -1.

    @param slopeNearEccentricOmegaMax
      The slope of the eccentric side of the curve as the normalized angular
      velocity approaches 1.

    @param slopeAtEccentricOmegaMax
      The slope of the curve at a normalized angular velocity of 1. This slope
      is used to extrapolate \f$\mathbf{t}_V\f$ for normalized angular velocities
      of greater than 1.

    @param eccentricCurviness
      This parameter controls the shape of the curve between the normalized
      angular velocities of 0 and 1. An eccentricCurviness of 0 will flatten
      the elbow so that the curve closely follows a line that begins at (0,1)
      and ends at (1,tvAtEccentricOmegaMax). An eccentricCurviness of 1 will
      give the curve a strong elbow so that it quickly approaches the line that
      passes through the point (1,tvAtEccentricOmegaMax) and has a slope of 
      slopeNearEccentricOmegaMax.

    @param curveName The name of the joint torque this curve applies to. This
       curve name should have the name of the joint and the
       direction (e.g. hipExtensionTorqueMuscle) so that if
       this curve ever causes an exception, a user friendly
       error message can be displayed to the end user to help
       them debug their model.

    @param smoothSegmentedFunctionToUpdate
        A SmoothSegmentedFunction object that will be erased and filled with 
        the coefficients that are defined by this curve. 

    <b>aborts</b>
    -tvAtEccentricOmegaMax < 1.05
    -tvAtHalfOmegaMax > 0.45  or tvAtHalfOmegaMax < 0.05
    -slopeAtConcentricOmegaMax < 0
    -slopeNearEccentricOmegaMax < 0
    -slopeAtEccentricOmegaMax < 0
    -eccentricCurviness < 0 or eccentricCurviness > 1

    <b>References</b>
    Hill, A. V. (1938). The heat of shortening and the dynamic constants of 
    muscle. Proceedings of the Royal Society of London B: Biological Sciences, 
    126(843), 136-195.

  */
  static void createTorqueVelocityCurve(
      double tvAtEccentricOmegaMax,
      double tvAtHalfConcentricOmegaMax,
      double slopeAtConcentricOmegaMax,
      double slopeNearEccentricOmegaMax,
      double slopeAtEccentricOmegaMax,
      double eccentricCurviness,
      const std::string& curveName,
      RigidBodyDynamics::Addons::Geometry::SmoothSegmentedFunction&
        smoothSegmentedFunctionToUpdate );

  /**
    This function creates a Bezier spline that closely follows the 
    exponential curves that are typically used to model the passive-torque-angle
    characteristic of muscles. This curve has a value and a slope of zero
    for angles that are less than abs(angleAtZeroTorque). For angles that
    have an absolute magnitude larger than abs(angleAtOneNormTorque) the curve
    is simply linearly extrapolated.

    Note that curves can be represented that increase left-to-right, or 
    decrease left-to-right by setting the variables angleAtOneNormTorque and
    angleAtZeroTorque correctly. For example using (0,1) for 
    angleAtOneNormTorque and angleAtZeroTorque produces a curve that increases
    left-to-right while using (-1,0) produces a curve that decreases left to 
    right.

    \image html fig_MuscleAddon_TorqueMuscleFunctionFactory_PassiveTorqueAngleCurveSimple.png

    @param angleAtZeroTorque is the angle at which the curve transitions from
    a flat line and begins curving upwards. (radians)

    @param angleAtOneNormTorque is the angle at which this curve achieves a 
    value of 1.0. (radians)

    @param curveName The name of the joint torque this curve applies to. This
       curve name should have the name of the joint and the
       direction (e.g. hipExtensionTorqueMuscle) so that if
       this curve ever causes an exception, a user friendly
       error message can be displayed to the end user to help
       them debug their model.

    @param smoothSegmentedFunctionToUpdate
        A SmoothSegmentedFunction object that will be erased and filled with 
        the coefficients that are defined by this curve. 

    <b>aborts</b>
    - abs(angleAtOneNormTorque-angleAtZeroTorque) < sqrt(eps)        
  */
  static void createPassiveTorqueAngleCurve(
      double angleAtZeroTorque,    
      double angleAtOneNormTorque,
      const std::string& curveName,
      RigidBodyDynamics::Addons::Geometry::SmoothSegmentedFunction&
        smoothSegmentedFunctionToUpdate );


/**
    This function creates a Bezier spline that closely follows the 
    exponential curves that are typically used to model the passive-torque-angle
    characteristic of muscles. This curve has a value and a slope of zero
    for angles that are less than abs(angleAtZeroTorque). For angles that
    have an absolute magnitude larger than abs(angleAtOneNormTorque) the curve
    is simply linearly extrapolated.

    Note that curves can be represented that increase left-to-right, or 
    decrease left-to-right by setting the variables angleAtOneNormTorque and
    angleAtZeroTorque correctly. For example using (0,1) for 
    angleAtOneNormTorque and angleAtZeroTorque produces a curve that increases
    left-to-right while using (-1,0) produces a curve that decreases left to 
    right.

    \image html fig_MuscleAddon_TorqueMuscleFunctionFactory_PassiveTorqueAngleCurve.png

    @param angleAtZeroTorque is the angle at which the curve transitions from
    a flat line and begins curving upwards. (radians)

    @param angleAtOneNormTorque is the angle at which this curve achieves a 
    value of 1.0. (radians)

    @param stiffnessAtLowTorque
      The normalized stiffness (or slope) of the curve achieves as it begins
      to increase. This is usually chosen to be a small, but non-zero fraction 
      of stiffnessAtOneNormTorque 
      (stiffnessAtLowTorque = 0.025 stiffnessAtOneNormTorque is typical).
      The sign of stiffnessAtLowTorque must be positive if 
      angleAtOneNormTorque > angleAtZeroPassiveTorque. The sign 
      of stiffnessAtLowTorque must be negative if 
      angleAtOneNormTorque < angleAtZeroPassiveTorque.
      (Norm.Torque/radians)  

    @param stiffnessAtOneNormTorque
      The normalized stiffness (or slope) of the fiber curve 
      when the fiber is stretched by  
      angleAtOneNormTorque - angleAtZeroPassiveTorque. The sign 
      of stiffnessAtOneNormTorque must agree with stiffnessAtLowTorque.
      (Norm.Torque/radians)

    @param curviness
      The dimensionless 'curviness' parameter that 
       can vary between 0 (a line) to 1 (a smooth, but 
      sharply bent elbow). A value of 0.5 is typical as it produces a 
       graceful curve.

    @param curveName The name of the joint torque this curve applies to. This
       curve name should have the name of the joint and the
       direction (e.g. hipExtensionTorqueMuscle) so that if
       this curve ever causes an exception, a user friendly
       error message can be displayed to the end user to help
       them debug their model.

    @param smoothSegmentedFunctionToUpdate
        A SmoothSegmentedFunction object that will be erased and filled with 
        the coefficients that are defined by this curve. 

    <b>aborts</b>
    - abs(angleAtOneNormTorque-angleAtZeroTorque) < sqrt(eps)   
    - sign(stiffnessAtLowTorque) != sign(angleAtOneNormTorque-angleAtLowTorque)     
    - sign(stiffnessAtOneNormTorque) != sign(stiffnessAtLowTorque)
    - abs(stiffnessAtLowTorque) > 0.9/abs(angleAtOneNormTorque-angleAtZeroTorque)
    - abs(stiffnessAtOneTorque) <= 1.1/abs(angleAtOneNormTorque-angleAtZeroTorque)
    - curviness < 0 or curviness > 1

  */
  static void createPassiveTorqueAngleCurve(
      double angleAtZeroTorque,
      double angleAtOneNormTorque,
      double stiffnessAtLowTorque,      
      double stiffnessAtOneNormTorque,
      double curviness,
      const std::string& curveName,
      RigidBodyDynamics::Addons::Geometry::SmoothSegmentedFunction&
        smoothSegmentedFunctionToUpdate );


  /**
    This function produces a Bezier curve fitted to a Gaussian function. As the
    tails of the Gaussian curve become small this curve is simply extrapolated
    as a line with a y-value of zero and a slope of zero. 

    \image html fig_MuscleAddon_TorqueMuscleFunctionFactory_GaussianActiveTorqueAngleCurveSimple.png

    @param angleAtOneNormTorque The angle at which the Gaussian curve develops
      a value of 1. 

    @param angularStandardDeviation The angular deviation from 
      the mean at which the Gaussian curve reaches a value of \f$e^{-1/2}\f$.

    @param curveName The name of the joint torque this curve applies to. This
       curve name should have the name of the joint and the
       direction (e.g. hipExtensionTorqueMuscle) so that if
       this curve ever causes an exception, a user friendly
       error message can be displayed to the end user to help
       them debug their model.

    @param smoothSegmentedFunctionToUpdate
        A SmoothSegmentedFunction object that will be erased and filled with 
        the coefficients that are defined by this curve. 

    <b>aborts</b>
    - angularWidthOfOneStandardDeviation < sqrt(eps)  
  */
  static void createGaussianShapedActiveTorqueAngleCurve(
      double angleAtOneNormTorque,
      double angularStandardDeviation,
      const std::string& curveName,
      RigidBodyDynamics::Addons::Geometry::SmoothSegmentedFunction&
        smoothSegmentedFunctionToUpdate 
    );


/**
    This function produces a C2 continuous Bezier curve fitted to a Gaussian 
    function. As the tails of the Gaussian curve become less than 
    minValueAtShoulders, the curve is linearly extrapolated at a sloe of 
    minSlopeOfShoulders.

    \image html fig_MuscleAddon_TorqueMuscleFunctionFactory_GaussianActiveTorqueAngleCurve.png

    @param angleAtOneNormTorque The angle at which the Gaussian curve develops
      a value of 1. 

    @param angularStandardDeviation The angular deviation from 
      the mean at which the Gaussian curve reaches a value of \f$e^{-1/2}\f$.

    @param minSlopeAtShoulders The y-value at which the Bezier curve transitions
    from having a shape like a Gaussian curve to being linearly extrapolated.

    @param minValueAtShoulders The slope of the linear extrapolation of the 
      Bezier curve for y-values that are less than minSlopeAtShoulders. The 
      sign of minValueAtShoulders is automatically set so that it matches the 
      curve near it (see the figure).

    @param curviness
      The dimensionless 'curviness' parameter that 
       can vary between 0 (a line) to 1 (a smooth, but 
      sharply bent elbow). A value of 0.5 is typical as it produces a 
       graceful curve.

    @param curveName The name of the joint torque this curve applies to. This
       curve name should have the name of the joint and the
       direction (e.g. hipExtensionTorqueMuscle) so that if
       this curve ever causes an exception, a user friendly
       error message can be displayed to the end user to help
       them debug their model.

    @param smoothSegmentedFunctionToUpdate
        A SmoothSegmentedFunction object that will be erased and filled with 
        the coefficients that are defined by this curve. 

    <b>aborts</b>
    - angularWidthOfOneStandardDeviation < sqrt(eps)  
    - minSlopeAtShoulders < 0
    - minValueAtShoulders < 0
    - curviness > 1 or curviness < 0

  */
  static void createGaussianShapedActiveTorqueAngleCurve(
      double angleAtOneNormTorque,
      double angularStandardDeviation,
      double minSlopeAtShoulders,
      double minValueAtShoulders,
      double curviness,
      const std::string& curveName,
      RigidBodyDynamics::Addons::Geometry::SmoothSegmentedFunction&
        smoothSegmentedFunctionToUpdate 
    );


  /**
    This function produces a normalized tendon-torque-angle curve with a 
    toe region that is in the range of \f$\mathbf{t}_V\f$ [0,1./3,] after which
    the curve is linearly extrapolated.

    \image html fig_MuscleAddon_TorqueMuscleFunctionFactory_TendonTorqueAngleCurveSimple.png

    @param angularStretchAtOneNormTorque The amount of angular stretch of the 
      joint as the tendon goes from developing zero torque at its slack length
      to developing one maximum isometric torque. (radians)

    @param curveName The name of the joint torque this curve applies to. This
       curve name should have the name of the joint and the
       direction (e.g. hipExtensionTorqueMuscle) so that if
       this curve ever causes an exception, a user friendly
       error message can be displayed to the end user to help
       them debug their model.

    @param smoothSegmentedFunctionToUpdate
        A SmoothSegmentedFunction object that will be erased and filled with 
        the coefficients that are defined by this curve. 

    <b>aborts</b>
    - angularWidthOfOneStandardDeviation < sqrt(eps) 

  */
  static void createTendonTorqueAngleCurve(
      double angularStretchAtOneNormTorque,
      const std::string& curveName,
      RigidBodyDynamics::Addons::Geometry::SmoothSegmentedFunction&
        smoothSegmentedFunctionToUpdate 
    );  

  /**
    This function produces a normalized tendon-torque-angle curve with a 
    toe region, final stiffness, and shape that can be controlled.

    \image html fig_MuscleAddon_TorqueMuscleFunctionFactory_TendonTorqueAngleCurve.png

    @param angularStretchAtOneNormTorque The amount of angular stretch of the 
      joint as the tendon goes from developing zero torque at its slack length
      to developing one maximum isometric torque. (radians)

    @param stiffnessAtOneNormTorque The linear stiffness value of the tendon
      that is used for all y-values greater than the toe region. 
      (Norm. Torque/rad)

    @param normTorqueAtToeEnd The normalized torque value which defines the
      end of the nonlinear-stiffness region of the tendon and the beginning of
      the linear stiffness region of the tendon.

    @param curviness
      The dimensionless 'curviness' parameter that 
       can vary between 0 (a line) to 1 (a smooth, but 
      sharply bent elbow). A value of 0.5 is typical as it produces a 
       graceful curve.

    @param curveName The name of the joint torque this curve applies to. This
       curve name should have the name of the joint and the
       direction (e.g. hipExtensionTorqueMuscle) so that if
       this curve ever causes an exception, a user friendly
       error message can be displayed to the end user to help
       them debug their model.

    @param smoothSegmentedFunctionToUpdate
        A SmoothSegmentedFunction object that will be erased and filled with 
        the coefficients that are defined by this curve. 

    <b>aborts</b>
    - angularStretchAtOneNormTorque < sqrt(eps) 
    - stiffnessAtOneNormTorque < 1.1/angularStretchAtOneNormTorque
    - normTorqueAtToeEnd < sqrt(eps) or normTorqueAtToeEnd > 0.99
    - curviness < 0 or curviness > 1

  */
  static void createTendonTorqueAngleCurve(
      double angularStretchAtOneNormTorque,
      double stiffnessAtOneNormTorque,
      double normTorqueAtToeEnd,
      double curviness,
      const std::string& curveName,
      RigidBodyDynamics::Addons::Geometry::SmoothSegmentedFunction&
        smoothSegmentedFunctionToUpdate 
    );  

};
}
}
}
#endif //TORQUEMUSCLEFUNCTIONFACTORY_H_