Millard2016TorqueMuscle.h

Go to the documentation of this file.

#ifndef MILLARD2016TORQUEMUSCLE_H_
#define MILLARD2016TORQUEMUSCLE_H_
 
/* 
 * RBDL - Rigid Body Dynamics Library: Addon : muscle
 * Copyright (c) 2016 Matthew Millard <millard.matthew@gmail.com>
 *
 * Licensed under the zlib license. See LICENSE for more details.
 */
 
#include <vector>
#include <rbdl/rbdl_math.h>
#include "../geometry/SmoothSegmentedFunction.h"
 
 
 
namespace RigidBodyDynamics {
    namespace Addons {
      namespace Muscle{
        #ifdef RBDL_BUILD_ADDON_MUSCLE_FITTING
          class TorqueMuscleFittingToolkit;
          class FitTorqueMuscleParameters;
        #endif
 
        const static struct DataSet{
          enum item{
              Anderson2007 = 0,
              Gymnast,
              Last
          };
          const static char* names[];
          DataSet(){}
        } DataSet;
 
 
        const static struct GenderSet{
          enum item {
              Male = 0,
              Female,
              Last
          };
          const static char* names[];
          GenderSet(){}
        } GenderSet;
 
        const static struct AgeGroupSet{
          enum item {
              Young18To25 = 0,
              Middle55To65,
              SeniorOver65,
              Last
          };
          const static char* names[];
          AgeGroupSet(){}
        } AgeGroupSet;
 
        const static struct JointTorqueSet{
          enum item{
            HipExtension                  = 0,
            HipFlexion                    = 1,
            KneeExtension                 = 2,
            KneeFlexion                   = 3,
            AnkleExtension                = 4,
            AnkleFlexion                  = 5,
            ElbowExtension                = 6,
            ElbowFlexion                  = 7,
            ShoulderExtension             = 8,
            ShoulderFlexion               = 9,
            WristExtension                = 10,
            WristFlexion                  = 11,
            ShoulderHorizontalAdduction   = 12,
            ShoulderHorizontalAbduction   = 13,
            ShoulderInternalRotation      = 14,
            ShoulderExternalRotation      = 15,
            WristUlnarDeviation           = 16,
            WristRadialDeviation          = 17,
            WristPronation                = 18,
            WristSupination               = 19,
            LumbarExtension               = 20,
            LumbarFlexion                 = 21,
            UnitExtensor                  = 22,
            UnitFlexor                    = 23,
            Last                          = 24
          };
          const static char* names[];
          JointTorqueSet(){}
        } JointTorqueSet;
 
 
        const static struct Anderson2007{
          enum Gender {
              Male   = GenderSet::Male,
              Female = GenderSet::Female,
              LastGender
          };
          enum AgeGroup {
              Young18To25   = AgeGroupSet::Young18To25,
              Middle55To65  = AgeGroupSet::Middle55To65,
              SeniorOver65  = AgeGroupSet::SeniorOver65,
              LastAgeGroup
          };
          enum JointTorque{
            HipExtension                  = JointTorqueSet::HipExtension  ,
            HipFlexion                    = JointTorqueSet::HipFlexion    ,
            KneeExtension                 = JointTorqueSet::KneeExtension ,
            KneeFlexion                   = JointTorqueSet::KneeFlexion   ,
            AnkleExtension                = JointTorqueSet::AnkleExtension,
            AnkleFlexion                  = JointTorqueSet::AnkleFlexion,
            LastJointTorque
          };
          const static char* GenderNames[];
          const static char* AgeGroupNames[];
          const static char* JointTorqueNames[];
          Anderson2007(){}
        } Anderson2007;
 
        const static struct Gymnast{
          enum Gender {
              Male   = GenderSet::Male,
              LastGender
          };
          enum AgeGroup {
              Young18To25   = AgeGroupSet::Young18To25,
              LastAgeGroup
          };
 
          enum TableIndex {
            TauMax = 0,
            OmegaMax,
            ActiveAngleAtOneNormTorque,
            ActiveAngularStandardDeviation,
            TvAtMaxEccentricVelocity,
            TvAtHalfMaxConcentricVelocity,
            PassiveAngleAtZeroTorque,
            PassiveAngleAtOneNormTorque,
            LastTableIndex
          };
 
          enum JointTorque {
            HipExtension                = JointTorqueSet::HipExtension       ,
            HipFlexion                  = JointTorqueSet::HipFlexion         ,
            KneeExtension               = JointTorqueSet::KneeExtension      ,
            KneeFlexion                 = JointTorqueSet::KneeFlexion        ,
            AnkleExtension              = JointTorqueSet::AnkleExtension     ,
            AnkleFlexion                = JointTorqueSet::AnkleFlexion       ,
            ElbowExtension              = JointTorqueSet::ElbowExtension     ,
            ElbowFlexion                = JointTorqueSet::ElbowFlexion       ,
            ShoulderExtension           = JointTorqueSet::ShoulderExtension  ,
            ShoulderFlexion             = JointTorqueSet::ShoulderFlexion    ,
            WristExtension              = JointTorqueSet::WristExtension     ,
            WristFlexion                = JointTorqueSet::WristFlexion       ,
            ShoulderHorizontalAdduction = 
              JointTorqueSet::ShoulderHorizontalAdduction,
            ShoulderHorizontalAbduction = 
              JointTorqueSet::ShoulderHorizontalAbduction,
            ShoulderInternalRotation    = 
              JointTorqueSet::ShoulderInternalRotation   ,
            ShoulderExternalRotation    = 
              JointTorqueSet::ShoulderExternalRotation   ,
            WristUlnarDeviation         = JointTorqueSet::WristUlnarDeviation ,
            WristRadialDeviation        = JointTorqueSet::WristRadialDeviation,
            WristPronation              = JointTorqueSet::WristPronation      ,
            WristSupination             = JointTorqueSet::WristSupination     ,
            LumbarExtension             = JointTorqueSet::LumbarExtension,
            LumbarFlexion               = JointTorqueSet::LumbarFlexion,
            UnitExtensor                = JointTorqueSet::UnitExtensor,
            UnitFlexor                  = JointTorqueSet::UnitFlexor,
            LastJointTorque
          };
          const static char* GenderNames[];
          const static char* AgeGroupNames[];
          const static char* JointTorqueNames[];
          Gymnast(){}
        } Gymnast;
 
 
 
        struct SubjectInformation{
          GenderSet::item gender;
          AgeGroupSet::item ageGroup;
          double heightInMeters;
          double massInKg;          
        };
 
 
 
        struct TorqueMuscleSummary{
          double fiberAngle;
 
          double fiberAngularVelocity;
 
 
          double activation;
 
          double fiberPassiveTorqueAngleMultiplier;
 
          double fiberActiveTorqueAngleMultiplier;
 
          double fiberTorqueAngularVelocityMultiplier;
 
          double fiberNormalizedDampingTorque;
 
          double fiberTorque;
 
          double jointTorque;
 
 
          TorqueMuscleSummary():
            fiberAngle(nan("1")),
            fiberAngularVelocity(nan("1")),
            activation(nan("1")),
            fiberPassiveTorqueAngleMultiplier(nan("1")),
            fiberActiveTorqueAngleMultiplier(nan("1")),
            fiberTorqueAngularVelocityMultiplier(nan("1")),
            fiberNormalizedDampingTorque(nan("1")),
            fiberTorque(nan("1")),
            jointTorque(nan("1")){}
 
        };
 
        struct TorqueMuscleInfo{
 
            double jointAngle;
 
            double jointAngularVelocity;
 
            double fiberAngle;
 
            //The angle that the tendon spans (radians)              
            //double tendonAngle;
 
            double fiberAngularVelocity;
 
            /*The rate-of-angular-lengthening of the tendon.
               A positive sign is for a concentric contraction, 
               that is where the tendon is shortening. (radians/sec)*/   
            //double tendonAngularVelocity;
 
            double fiberPassiveTorqueAngleMultiplier;
            double DfiberPassiveTorqueAngleMultiplier_DblendingVariable;
            double DfiberPassiveTorqueAngleMultiplier_DangleOffset;
            double fiberActiveTorqueAngleMultiplier;
            double DfiberActiveTorqueAngleMultiplier_DblendingVariable;
            double fiberTorqueAngularVelocityMultiplier;
            double DfiberTorqueAngularVelocityMultiplier_DblendingVariable;
            /*The normalized value of the tendon-torque-angle curve. 
               Here a value of 1 means 1 maximum-isometric-torque. (Nm/Nm)*/
            //double tendonTorqueAngleMultiplier;
            
            double activation;
 
            double fiberActiveTorque;
 
            double fiberPassiveTorque;            
 
            double fiberPassiveElasticTorque;
 
            double fiberDampingTorque;
 
            double fiberNormDampingTorque;
 
            double fiberTorque;
 
            /*The torque transmitted through the tendon across the joint (Nm)*/
            //double tendonTorque;
 
            double jointTorque;
 
            double fiberStiffness;
 
            /*The stiffness of the tendon (Nm/rad)*/
            //double tendonStiffness;
 
            double jointStiffness;
            
            double fiberActivePower;
 
            double fiberPassivePower;
 
            double fiberPower;
 
            double jointPower;
 
            double DjointTorque_Dactivation;
            
            double DjointTorque_DjointAngle;
 
            double DjointTorque_DjointAngularVelocity;
 
            double DjointTorque_DactiveTorqueAngleBlendingVariable;
            double DjointTorque_DpassiveTorqueAngleBlendingVariable;
            double DjointTorque_DtorqueAngularVelocityBlendingVariable;
            double DjointTorque_DmaximumIsometricTorque;
            double DjointTorque_DpassiveTorqueAngleCurveAngleOffset;
 
            double DjointTorque_DactiveTorqueAngleAngleScaling;
            double DjointTorque_DmaximumAngularVelocity;
 
 
            RigidBodyDynamics::Math::VectorNd fittingInfo;
 
            TorqueMuscleInfo():
              jointAngle(nan("1")),
              jointAngularVelocity(nan("1")),
              fiberAngle(nan("1")),
              fiberAngularVelocity(nan("1")),
              fiberPassiveTorqueAngleMultiplier(nan("1")),
              DfiberPassiveTorqueAngleMultiplier_DblendingVariable(nan("1")),
              DfiberPassiveTorqueAngleMultiplier_DangleOffset(nan("1")),
              fiberActiveTorqueAngleMultiplier(nan("1")),
              DfiberActiveTorqueAngleMultiplier_DblendingVariable(nan("1")),
              fiberTorqueAngularVelocityMultiplier(nan("1")),
              DfiberTorqueAngularVelocityMultiplier_DblendingVariable(nan("1")),
              activation(nan("1")),
              fiberActiveTorque(nan("1")),
              fiberPassiveTorque(nan("1")),
              fiberPassiveElasticTorque(nan("1")),
              fiberDampingTorque(nan("1")),
              fiberNormDampingTorque(nan("1")),
              fiberTorque(nan("1")),
              jointTorque(nan("1")),
              fiberStiffness(nan("1")),
              jointStiffness(nan("1")),
              fiberActivePower(nan("1")),
              fiberPassivePower(nan("1")),
              fiberPower(nan("1")),
              jointPower(nan("1")),
              DjointTorque_Dactivation(nan("1")),
              DjointTorque_DjointAngle(nan("1")),
              DjointTorque_DjointAngularVelocity(nan("1")),
              DjointTorque_DactiveTorqueAngleBlendingVariable(nan("1")),
              DjointTorque_DpassiveTorqueAngleBlendingVariable(nan("1")),
              DjointTorque_DtorqueAngularVelocityBlendingVariable(nan("1")),
              DjointTorque_DmaximumIsometricTorque(nan("1")),
              DjointTorque_DpassiveTorqueAngleCurveAngleOffset(nan("1")),
              DjointTorque_DactiveTorqueAngleAngleScaling(nan("1")),
              DjointTorque_DmaximumAngularVelocity(nan("1"))
            {}
 
        };
 
 
        struct TorqueMuscleParameterFittingData {
 
           unsigned int indexAtMaximumActivation;
           unsigned int indexAtMinimumActivation;
           unsigned int indexAtMaxPassiveTorqueAngleMultiplier;
 
           bool isTorqueMuscleActive;
 
           double activeTorqueAngleBlendingVariable;
           double passiveTorqueAngleBlendingVariable;
           double torqueVelocityBlendingVariable;
           double passiveTorqueAngleCurveOffset;
           double maximumActiveIsometricTorque;
 
           double activeTorqueAngleAngleScaling;
           double maximumAngularVelocity;
 
           //double objectiveValue;
           //double constraintError;
           bool fittingConverged;
 
           TorqueMuscleSummary summaryDataAtMinimumActivation;
           TorqueMuscleSummary summaryDataAtMaximumActivation;
           TorqueMuscleSummary summaryDataAtMaximumPassiveTorqueAngleMultiplier;
 
 
           TorqueMuscleParameterFittingData():
             indexAtMaximumActivation(std::numeric_limits<unsigned int>::infinity()),
             indexAtMinimumActivation(std::numeric_limits<unsigned int>::infinity()),
             indexAtMaxPassiveTorqueAngleMultiplier(std::numeric_limits<unsigned int>::infinity()),
             isTorqueMuscleActive(true),
             activeTorqueAngleBlendingVariable(nan("1")),
             passiveTorqueAngleBlendingVariable(nan("1")),
             torqueVelocityBlendingVariable(nan("1")),
             passiveTorqueAngleCurveOffset(nan("1")),
             maximumActiveIsometricTorque(nan("1")),
             activeTorqueAngleAngleScaling(nan("1")),
             maximumAngularVelocity(nan("1")),
             fittingConverged(false),
             summaryDataAtMinimumActivation(),
             summaryDataAtMaximumActivation(),
             summaryDataAtMaximumPassiveTorqueAngleMultiplier(){}
        };
 
        struct TorqueMuscleDataFeatures{
          unsigned int indexOfMaxActivation;
          unsigned int indexOfMinActivation;
          unsigned int indexOfMaxPassiveTorqueAngleMultiplier;
 
          bool isInactive;
 
          TorqueMuscleSummary summaryAtMaxActivation;
          TorqueMuscleSummary summaryAtMinActivation;
          TorqueMuscleSummary summaryAtMaxPassiveTorqueAngleMultiplier;
        };
 
        class Millard2016TorqueMuscle {
#ifdef RBDL_BUILD_ADDON_MUSCLE_FITTING
          friend class TorqueMuscleFittingToolkit;
          friend class FitTorqueMuscleParameters;
#endif
 
            public:
                Millard2016TorqueMuscle();
 
 
                Millard2016TorqueMuscle(
                    DataSet::item   dataSet,
                    const SubjectInformation &subjectInfo,
                    int jointTorque,
                    double  jointAngleOffsetRelativeToDoxygenFigures,
                    double  signOfJointAngleRelativeToDoxygenFigures,
                    double  signOfJointTorqueToDoxygenFigures,
                    const   std::string& name
                    );
 
 
                double calcJointTorque(                        
                        double jointAngle,
                        double jointAngularVelocity,
                        double activation) const;
 
 
                void calcActivation(double jointAngle,
                                    double jointAngularVelocity,
                                    double jointTorque,
                                    TorqueMuscleSummary
                                      &updTorqueMuscleSummaryStruct) const;
 
 
                double calcMaximumActiveIsometricTorqueScalingFactor(
                          double jointAngle,
                          double jointAngularVelocity,
                          double activation,
                          double jointTorque) const;
 
                void calcTorqueMuscleInfo(
                        double jointAngle,
                        double jointAngularVelocity,
                        double activation,
                        TorqueMuscleInfo& updTorqueMuscleInfoStruct) const;
 
                double getJointTorqueSign() const;
 
                double getJointAngleSign() const;
 
                double getJointAngleOffset() const;
 
 
                double  getMaximumActiveIsometricTorque() const; 
 
                double getJointAngleAtMaximumActiveIsometricTorque() const;
 
                double getActiveTorqueAngleCurveWidth() const;
 
                double getJointAngleAtOneNormalizedPassiveIsometricTorque() const;
 
                double getJointAngleAtSmallestNormalizedPassiveIsometricTorque() const;
 
 
                double getMaximumConcentricJointAngularVelocity() const;
 
                double  getPassiveTorqueScale() const;
 
                double getPassiveCurveAngleOffset() const;
 
                double getNormalizedDampingCoefficient() const;
 
                void setNormalizedDampingCoefficient(double beta);
                void  setPassiveTorqueScale(double passiveTorqueScale);
 
                void setPassiveCurveAngleOffset(
                  double passiveCurveAngleOffsetVal);
 
 
                double getTorqueVelocityMultiplierAtHalfOmegaMax() const;
                void setTorqueVelocityMultiplierAtHalfOmegaMax(double tvAtHalfOmegaMax);
 
                void fitPassiveTorqueScale(double jointAngle,
                                           double passiveFiberTorque);
 
                void fitPassiveCurveAngleOffset(double jointAngle,
                                           double passiveFiberTorque);
 
                void setMaximumActiveIsometricTorque(
                            double maxIsometricTorque);    
 
                void setMaximumConcentricJointAngularVelocity(
                          double maxAngularVelocity);
 
                const RigidBodyDynamics::Addons::Geometry::
                SmoothSegmentedFunction& getActiveTorqueAngleCurve() const;
 
                const RigidBodyDynamics::Addons::Geometry::
                SmoothSegmentedFunction& getPassiveTorqueAngleCurve() const;
 
                const RigidBodyDynamics::Addons::Geometry::
                SmoothSegmentedFunction& getTorqueAngularVelocityCurve() const;
 
 
                double getActiveTorqueAngleCurveBlendingVariable() const;
 
                double getPassiveTorqueAngleCurveBlendingVariable() const;
 
                double getTorqueAngularVelocityCurveBlendingVariable() const;
 
                void setActiveTorqueAngleCurveBlendingVariable(
                      double blendingVariable);
 
                void setPassiveTorqueAngleCurveBlendingVariable(
                      double blendingVariable);
 
                void setTorqueAngularVelocityCurveBlendingVariable(
                      double blendingVariable);
 
                double getActiveTorqueAngleCurveAngleScaling() const;
 
                void setActiveTorqueAngleCurveAngleScaling(double angleScaling);
 
 
                void setFittedParameters (
                    const TorqueMuscleParameterFittingData &fittedParameters);
 
 
                void printJointTorqueProfileToFile(
                        const std::string& path,
                        const std::string& fileNameWithoutExtension,
                        int numberOfSamplePoints);
 
                std::string getName();
                void setName(std::string& name);
 
                DataSet::item getDataSet();
                GenderSet::item getGender();
                AgeGroupSet::item getAgeGroup();
                JointTorqueSet::item getJointTorque();
                double getSubjectMass();
                double getSubjectHeight();
 
            private:
 
              bool mMuscleCurvesAreDirty;
              void updateTorqueMuscleCurves();
              TorqueMuscleInfo mTmInfo;
              TorqueMuscleSummary mTmSummary;
 
              RigidBodyDynamics::Addons::Geometry::
                SmoothSegmentedFunction mTaCurve;
              double mTaLambda;
              static const double mTaLambdaMax;// = 1.0 -> defined in the cc file
              RigidBodyDynamics::Addons::Geometry::
                SmoothSegmentedFunction mTpCurve;
              double mTpLambda;
              static const double mTpLambdaMax;// = 0.0 -> defined in the cc file
              RigidBodyDynamics::Addons::Geometry::
                SmoothSegmentedFunction mTvCurve;
              double mTvLambda;
 
              double mTvLambdaMax;
 
 
              RigidBodyDynamics::Math::VectorNd mAnderson2007c1c2c3c4c5c6;
              RigidBodyDynamics::Math::VectorNd mAnderson2007b1k1b2k2;
              RigidBodyDynamics::Math::VectorNd mGymnastParams;
 
              DataSet::item mDataSet;
              GenderSet::item mGender;
              AgeGroupSet::item mAgeGroup;
              JointTorqueSet::item mJointTorque;
 
              bool mUseTabularOmegaMax;
              bool mUseTabularMaxActiveIsometricTorque;
              bool mUseTabularTorqueVelocityMultiplierAtHalfOmegaMax;
 
              double mTorqueVelocityMultiplierAtHalfOmegaMax;
 
              double mMaxActiveIsometricTorque;
              double mAngleAtOneNormActiveTorque;
              double mTaAngleScaling;
              double mOmegaMax;
              double mAngleAtOneNormPassiveTorque;
              double mAngleAtSmallestNormPassiveTorque;
              double mPassiveTorqueScale;
              double mPassiveCurveAngleOffset;
 
              double mBetaMax; //passive damping coefficient
 
              double mSubjectHeightInMeters;
              double mSubjectMassInKg;
              double mScaleFactorAnderson2007;
 
              double mSignOfJointAngle;
              double mSignOfConcentricAnglularVelocity;
              double mSignOfJointTorque;
              double mAngleOffset;
 
              std::string mMuscleName;
 
              double calcJointAngle(double fiberAngle) const;
              double calcFiberAngle(double jointAngle) const;
              double calcFiberAngularVelocity(
                double jointAngularVelocity) const;
              double calcJointAngularVelocity(
                double fiberAngularVelocity) const;
 
              //const static RigidBodyDynamics::Math::MatrixNd& 
              //getAnderson2007ParameterMatrix();
              static double const Anderson2007Table3Mean[36][14];
              static double const Anderson2007Table3Std[36][14];
              static double const GymnastWholeBody[24][12];
 
 
              void calcTorqueMuscleDataFeatures(
                  RigidBodyDynamics::Math::VectorNd const &jointTorque,
                  RigidBodyDynamics::Math::VectorNd const &jointAngle,
                  RigidBodyDynamics::Math::VectorNd const &jointAangularVelocity,
                  double activeTorqueAngleBlendingVariable,
                  double passiveTorqueAngleBlendingVariable,
                  double torqueVelocityBlendingVariable,
                  double activeTorqueAngleAngleScaling,
                  double activeTorqueAngleAtOneNormTorque,
                  double passiveTorqueAngleCurveOffset,
                  double maxAngularVelocity,
                  double maxActiveIsometricTorque,
                  TorqueMuscleDataFeatures &tmf) const;
 
              double calcFiberAngleGivenNormalizedPassiveTorque(
                  double normPassiveFiberTorque,
                  double blendingVariable,
                  double passiveTorqueAngleCurveOffset) const;
 
              double calcBlendedCurveDerivative(
                  double curveArgument,
                  double blendingVariable,
                  double maximumBlendingValue,
                  unsigned int derivativeOrderArgument,
                  unsigned int derivativeOrderBlendingVariable,
                  RigidBodyDynamics::Addons::Geometry::SmoothSegmentedFunction
                    const &curve) const;
 
 
              double calcInverseBlendedCurveValue(
                  double blendedCurveValue,
                  double argGuess,
                  double blendingVariable,
                  double maximumBlendingValue,
                  RigidBodyDynamics::Addons::Geometry::SmoothSegmentedFunction
                    const &curve) const;
 
              void updTorqueMuscleSummary(
                    double activation,
                    double jointAngle,
                    double jointAngularVelocity,
                    double activeTorqueAngleBlendingVariable,
                    double passiveTorqueAngleBlendingVariable,
                    double activeTorqueAngularVelocityBlendingVariable,
                    double activeTorqueAngleAngleScaling,
                    double activeTorqueAngleAtOneNormTorque,
                    double passiveTorqueAngleCurveOffset,
                    double maxAngularVelocity,
                    double maxActiveIsometricTorque,
                    TorqueMuscleSummary &updTms) const;
              void updTorqueMuscleSummaryCurveValues(
                    double fiberAngle,
                    double normFiberAngularVelocity,
                    double activeTorqueAngleBlendingVariable,
                    double passiveTorqueAngleBlendingVariable,
                    double activeTorqueAngularVelocityBlendingVariable,
                    double activeTorqueAngleAngleScaling,
                    double activeTorqueAngleAtOneNormTorque,
                    double passiveTorqueAngleCurveOffset,
                    TorqueMuscleSummary &updTms) const;
 
              void updTorqueMuscleInfo(
                    double activation,
                    double jointAngle,
                    double jointAngularVelocity,
                    double activeTorqueAngleBlendingVariable,
                    double passiveTorqueAngleBlendingVariable,
                    double activeTorqueAngularVelocityBlendingVariable,
                    double activeTorqueAngleAngleScaling,
                    double activeTorqueAngleAtOneNormTorque,
                    double passiveTorqueAngleCurveOffset,
                    double maxAngularVelocity,
                    double maxActiveIsometricTorque,
                    TorqueMuscleInfo &updTmi) const;
 
              void updInvertTorqueMuscleSummary(
                    double jointTorque,
                    double jointAngle,
                    double jointAngularVelocity,
                    double activeTorqueAngleBlendingVariable,
                    double passiveTorqueAngleBlendingVariable,
                    double activeTorqueAngularVelocityBlendingVariable,
                    double activeTorqueAngleAngleScaling,                    
                    double activeTorqueAngleAtOneNormTorque,
                    double passiveTorqueAngleCurveOffset,
                    double maxAngularVelocity,
                    double maxActiveIsometricTorque,
                    TorqueMuscleSummary &updTms) const;
 
 
 
};
 
 
 
 
}
}
}
 
 
 
#endif