def solveMocoInverse():
#Construct the MocoInverse tool.
inverse = osim.MocoInverse()
inverse.setName('inverseTorqueTracking')
#Construct a ModelProcessor and set it on the tool. The muscles are removed
#and reserve actuators added to generate a torque driven solution
modelProcessor = osim.ModelProcessor('scaledModelMuscle.osim')
modelProcessor.append(osim.ModOpAddExternalLoads('Jog05_grf.xml'))
modelProcessor.append(osim.ModOpRemoveMuscles())
modelProcessor.append(osim.ModOpAddReserves(300))
inverse.setModel(modelProcessor)
#Construct a TableProcessor of the coordinate data and pass it to the
#inverse tool. TableProcessors can be used in the same way as
#ModelProcessors by appending TableOperators to modify the base table.
#A TableProcessor with no operators, as we have here, simply returns the
#base table.
inverse.setKinematics(osim.TableProcessor('ikResults_states.sto'))
# Initial time, final time, and mesh interval.
inverse.set_initial_time(osim.Storage('ikResults_states.sto').getFirstTime())
inverse.set_final_time(osim.Storage('ikResults_states.sto').getLastTime())
inverse.set_mesh_interval(0.02)
# By default, Moco gives an error if the kinematics contains extra columns.
# Here, we tell Moco to allow (and ignore) those extra columns.
inverse.set_kinematics_allow_extra_columns(True)
# Solve the problem and write the solution to a Storage file.
solution = inverse.solve()
#Return the solution as an object that we can use
return solution
def create_inverse(self, root_dir, modelProcessor, mesh_interval):
coordinates = osim.TableProcessor(
os.path.join(root_dir, "resources/Rajagopal2016/coordinates.mot"))
coordinates.append(osim.TabOpLowPassFilter(6))
coordinates.append(osim.TabOpUseAbsoluteStateNames())
inverse = osim.MocoInverse()
inverse.setModel(modelProcessor)
inverse.setKinematics(coordinates)
inverse.set_initial_time(self.initial_time)
inverse.set_final_time(self.final_time)
inverse.set_mesh_interval(mesh_interval)
inverse.set_kinematics_allow_extra_columns(True)
inverse.set_convergence_tolerance(1e-2) # TODO
inverse.set_mesh_interval(mesh_interval)
return inverse
def solveMocoInverse():
# Construct the MocoInverse tool.
inverse = osim.MocoInverse()
# Construct a ModelProcessor and set it on the tool. The default
# muscles in the model are replaced with optimization-friendly
# DeGrooteFregly2016Muscles, and adjustments are made to the default muscle
# parameters.
modelProcessor = osim.ModelProcessor('subject_walk_armless.osim')
modelProcessor.append(osim.ModOpAddExternalLoads('grf_walk.xml'))
modelProcessor.append(osim.ModOpIgnoreTendonCompliance())
modelProcessor.append(osim.ModOpReplaceMusclesWithDeGrooteFregly2016())
# Only valid for DeGrooteFregly2016Muscles.
modelProcessor.append(osim.ModOpIgnorePassiveFiberForcesDGF())
# Only valid for DeGrooteFregly2016Muscles.
modelProcessor.append(osim.ModOpScaleActiveFiberForceCurveWidthDGF(1.5))
modelProcessor.append(osim.ModOpAddReserves(1.0))
inverse.setModel(modelProcessor)
# Construct a TableProcessor of the coordinate data and pass it to the
# inverse tool. TableProcessors can be used in the same way as
# ModelProcessors by appending TableOperators to modify the base table.
# A TableProcessor with no operators, as we have here, simply returns the
# base table.
inverse.setKinematics(osim.TableProcessor('coordinates.sto'))
# Initial time, final time, and mesh interval.
inverse.set_initial_time(0.81)
inverse.set_final_time(1.79)
inverse.set_mesh_interval(0.02)
# By default, Moco gives an error if the kinematics contains extra columns.
# Here, we tell Moco to allow (and ignore) those extra columns.
inverse.set_kinematics_allow_extra_columns(True)
# Solve the problem and write the solution to a Storage file.
solution = inverse.solve()
solution.getMocoSolution().write(
'example3DWalking_MocoInverse_solution.sto')
# Generate a PDF with plots for the solution trajectory.
model = modelProcessor.process()
report = osim.report.Report(model,
'example3DWalking_MocoInverse_solution.sto',
bilateral=True)
# The PDF is saved to the working directory.
report.generate()
def solveMocoInverseMuscle():
#Construct the MocoInverse tool.
inverse = osim.MocoInverse()
inverse.setName('inverseMuscleTracking')
#Construct a ModelProcessor and set it on the tool.
#Currently the coordinate actuators for the pelvis, along with the reserve
#actuators are fairly generally set, and not weighted at all in cost function.
#These actuators could be more carefully considered to generate an appropriate
#muscle driven simulation. For example, if they max and min control to 1 - the
#pelvis actuators may not produce enough torque.
modelProcessor = osim.ModelProcessor('scaledModelMuscle.osim')
modelProcessor.append(osim.ModOpAddExternalLoads('Jog05_grf.xml'))
modelProcessor.append(osim.ModOpIgnoreTendonCompliance())
modelProcessor.append(osim.ModOpReplaceMusclesWithDeGrooteFregly2016())
# Only valid for DeGrooteFregly2016Muscles.
# modelProcessor.append(osim.ModOpIgnorePassiveFiberForcesDGF())
# Only valid for DeGrooteFregly2016Muscles.
modelProcessor.append(osim.ModOpScaleActiveFiberForceCurveWidthDGF(1.5))
modelProcessor.append(osim.ModOpAddReserves(2))
inverse.setModel(modelProcessor)
#Construct a TableProcessor of the coordinate data and pass it to the
#inverse tool. TableProcessors can be used in the same way as
#ModelProcessors by appending TableOperators to modify the base table.
#A TableProcessor with no operators, as we have here, simply returns the
#base table.
inverse.setKinematics(osim.TableProcessor('ikResults_states.sto'))
#Initial time, final time, and mesh interval.
inverse.set_initial_time(osim.Storage('ikResults_states.sto').getFirstTime())
inverse.set_final_time(osim.Storage('ikResults_states.sto').getLastTime())
inverse.set_mesh_interval(0.02)
# By default, Moco gives an error if the kinematics contains extra columns.
# Here, we tell Moco to allow (and ignore) those extra columns.
inverse.set_kinematics_allow_extra_columns(True)
# Solve the problem and write the solution to a Storage file.
solution = inverse.solve()
#Return the solution as an object that we can use
return solution
def run_inverse_problem(self, root_dir):
modelProcessor = self.create_model_processor(root_dir,
for_inverse=True)
inverse = osim.MocoInverse()
inverse.setModel(modelProcessor)
tableProcessor = osim.TableProcessor(os.path.join(root_dir,
'resources/Rajagopal2016/coordinates.mot'))
tableProcessor.append(osim.TabOpLowPassFilter(6))
tableProcessor.append(osim.TabOpUseAbsoluteStateNames())
inverse.setKinematics(tableProcessor)
inverse.set_kinematics_allow_extra_columns(True)
inverse.set_initial_time(self.initial_time)
inverse.set_final_time(self.half_time)
inverse.set_mesh_interval(self.mesh_interval)
solution = inverse.solve()
solution.getMocoSolution().write(
os.path.join(root_dir, self.inverse_solution_relpath))
import os
import numpy as np
## Part 1: Muscle redundancy problem: effort minimization.
# Solve the muscle redundancy problem while minimizing muscle excitations
# squared using the MocoInverse tool.
# Part 1a: Load a 19 degree-of-freedom model with 18 lower-limb,
# sagittal-plane muscles and a torque-actuated torso. This includes a set of
# ground reaction forces applied to the model via ExternalLoads, which is
# necessary for the muscle redundancy problem. See the function definition
# at the bottom of this file to see how the model is loaded and constructed.
model = helpers.getWalkingModel()
# Part 1b: Create the MocoInverse tool and set the Model.
inverse = osim.MocoInverse()
inverse.setModel(model)
# Part 1c: Create a TableProcessor using the coordinates file from inverse
# kinematics.
coordinates = osim.TableProcessor('coordinates.mot')
coordinates.append(osim.TabOpLowPassFilter(6))
coordinates.append(osim.TabOpUseAbsoluteStateNames())
# Part 1d: Set the kinematics reference for MocoInverse using the
# TableProcessor we just created.
inverse.setKinematics(coordinates)
inverse.set_kinematics_allow_extra_columns(True)
# Part 1e: Provide the solver settings: initial and final time, the mesh
# interval, and the constraint and convergence tolerances.
def solveMocoInverseWithEMG():
# This initial block of code is identical to the code above.
inverse = osim.MocoInverse()
modelProcessor = osim.ModelProcessor('subject_walk_armless.osim')
modelProcessor.append(osim.ModOpAddExternalLoads('grf_walk.xml'))
modelProcessor.append(osim.ModOpIgnoreTendonCompliance())
modelProcessor.append(osim.ModOpReplaceMusclesWithDeGrooteFregly2016())
modelProcessor.append(osim.ModOpIgnorePassiveFiberForcesDGF())
modelProcessor.append(osim.ModOpScaleActiveFiberForceCurveWidthDGF(1.5))
modelProcessor.append(osim.ModOpAddReserves(1.0))
inverse.setModel(modelProcessor)
inverse.setKinematics(osim.TableProcessor('coordinates.sto'))
inverse.set_initial_time(0.81)
inverse.set_final_time(1.79)
inverse.set_mesh_interval(0.02)
inverse.set_kinematics_allow_extra_columns(True)
study = inverse.initialize()
problem = study.updProblem()
# Add electromyography tracking.
emgTracking = osim.MocoControlTrackingGoal('emg_tracking')
emgTracking.setWeight(50.0)
# Each column in electromyography.sto is normalized so the maximum value in
# each column is 1.0.
controlsRef = osim.TimeSeriesTable('electromyography.sto')
# Scale the tracked muscle activity based on peak levels from
# "Gait Analysis: Normal and Pathological Function" by
# Perry and Burnfield, 2010 (digitized by Carmichael Ong).
soleus = controlsRef.updDependentColumn('soleus')
gasmed = controlsRef.updDependentColumn('gastrocnemius')
tibant = controlsRef.updDependentColumn('tibialis_anterior')
for t in range(0, controlsRef.getNumRows()):
soleus[t] = 0.77 * soleus[t]
gasmed[t] = 0.87 * gasmed[t]
tibant[t] = 0.37 * tibant[t]
emgTracking.setReference(osim.TableProcessor(controlsRef))
# Associate actuators in the model with columns in electromyography.sto.
emgTracking.setReferenceLabel('/forceset/soleus_r', 'soleus')
emgTracking.setReferenceLabel('/forceset/gasmed_r', 'gastrocnemius')
emgTracking.setReferenceLabel('/forceset/gaslat_r', 'gastrocnemius')
emgTracking.setReferenceLabel('/forceset/tibant_r', 'tibialis_anterior')
problem.addGoal(emgTracking)
# Solve the problem and write the solution to a Storage file.
solution = study.solve()
solution.write('example3DWalking_MocoInverseWithEMG_solution.sto')
# Write the reference data in a way that's easy to compare to the solution.
controlsRef.removeColumn('medial_hamstrings')
controlsRef.removeColumn('biceps_femoris')
controlsRef.removeColumn('vastus_lateralis')
controlsRef.removeColumn('vastus_medius')
controlsRef.removeColumn('rectus_femoris')
controlsRef.removeColumn('gluteus_maximus')
controlsRef.removeColumn('gluteus_medius')
controlsRef.setColumnLabels(
['/forceset/soleus_r', '/forceset/gasmed_r', '/forceset/tibant_r'])
controlsRef.appendColumn('/forceset/gaslat_r', gasmed)
osim.STOFileAdapter.write(controlsRef, 'controls_reference.sto')
# Generate a report comparing MocoInverse solutions without and with EMG
# tracking.
model = modelProcessor.process()
output = 'example3DWalking_MocoInverseWithEMG_report.pdf'
ref_files = [
'example3DWalking_MocoInverseWithEMG_solution.sto',
'controls_reference.sto'
]
report = osim.report.Report(model,
'example3DWalking_MocoInverse_solution.sto',
output=output,
bilateral=True,
ref_files=ref_files)
# The PDF is saved to the working directory.
report.generate()