int main() {
SimTK::Array_<std::string> failures;
try {testSingleRigidTendonMuscle();}
catch (const std::exception& e)
{ cout << e.what() <<endl; failures.push_back("testSingleRigidTendonMuscle"); }
// redo with the Millard2012EquilibriumMuscle
Object::renameType("Thelen2003Muscle", "Millard2012EquilibriumMuscle");
try {testSingleMillardRigidTendonMuscle();}
catch (const std::exception& e)
{ cout << e.what() <<endl;
failures.push_back("testSingleMillardRigidTendonMuscle"); }
if (!failures.empty()) {
cout << "Done, with failure(s): " << failures << endl;
return 1;
}
cout << "Done" << endl;
return 0;
}
int main()
{
SimTK::Array_<std::string> failures;
try { testTorqueActuator(); }
catch (const std::exception& e){
cout << e.what() <<endl; failures.push_back("testTorqueActuator");
}
try { testClutchedPathSpring(); }
catch (const std::exception& e){
cout << e.what() <<endl; failures.push_back("testClutchedPathSpring");
}
try { testMcKibbenActuator(); }
catch (const std::exception& e) {
cout << e.what() << endl; failures.push_back("testMcKibbenActuator");
}
try { testBodyActuator(); }
catch (const std::exception& e) {
cout << e.what() << endl; failures.push_back("testBodyActuator");
}
try { testActuatorsCombination(); }
catch (const std::exception& e) {
cout << e.what() << endl; failures.push_back("testActuatorsCombination");
}
if (!failures.empty()) {
cout << "Done, with failure(s): " << failures << endl;
return 1;
}
cout << "Done, testActuators passed." << endl;
}
int main()
{
Array<string> muscleModelNames;
muscleModelNames.append("Thelen2003Muscle_Deprecated");
muscleModelNames.append("Thelen2003Muscle");
muscleModelNames.append("Millard2012EquilibriumMuscle");
muscleModelNames.append("Millard2012AccelerationMuscle");
// Tolerances for the differences between the current models
// and the 'standard' solution, which was closest to using
// Thelen2003Muscle_Deprecated musle formulation.
double actTols[4] = {0.005, 0.025, 0.04, 0.04};
double forceTols[4] = {0.5, 4, 5, 6};
SimTK::Array_<std::string> failures;
for(int i=0; i< muscleModelNames.getSize(); ++i){
try { // regression test for the Thelen deprecate muscle
// otherwise verify that SO runs with the new models
testArm26(muscleModelNames[i], actTols[i], forceTols[i]);
}
catch (const std::exception& e) {
cout << e.what() <<endl;
failures.push_back("testArm26_"+muscleModelNames[i]);
}
}
if (!failures.empty()) {
cout << "Done, with failure(s): " << failures << endl;
return 1;
}
cout << "Done" << endl;
return 0;
}
int main()
{
SimTK::Array_<std::string> failures;
try {
Millard2012EquilibriumMuscle muscle("muscle",
MaxIsometricForce0,
OptimalFiberLength0,
TendonSlackLength0,
PennationAngle0);
MuscleFirstOrderActivationDynamicModel actMdl = muscle.getFirstOrderActivationModel();
actMdl.setActivationTimeConstant(Activation0);
actMdl.setDeactivationTimeConstant(Deactivation0);
muscle.setFirstOrderActivationModel(actMdl);
double x0 = 0;
double act0 = 0.2;
Constant control(0.5);
Sine motion(0.1, SimTK::Pi, 0);
simulateMuscle(muscle,
x0,
act0,
&motion,
&control,
IntegrationAccuracy,
CorrectnessTest,
CorrectnessTestTolerance,
true);
cout << "Probes test passed" << endl;
}
catch (const Exception& e) {
e.print(cerr);
failures.push_back("testProbes");
}
printf("\n\n");
cout <<"************************************************************"<<endl;
cout <<"************************************************************"<<endl;
if (!failures.empty()) {
cout << "Done, with failure(s): " << failures << endl;
return 1;
}
cout << "testProbes Done" << endl;
return 0;
}
int main()
{
SimTK::Array_<std::string> failures;
try { testBody(); }
catch (const std::exception& e){
cout << e.what() <<endl; failures.push_back("testBody");
}
try { testPhysicalOffsetFrameOnBody(); }
catch (const std::exception& e){
cout << e.what() <<endl;
failures.push_back("testPhysicalOffsetFrameOnBody");
}
try { testPhysicalOffsetFrameOnBodySerialize(); }
catch (const std::exception& e){
cout << e.what() << endl;
failures.push_back("testPhysicalOffsetFrameOnBodySerialize");
}
try { testPhysicalOffsetFrameOnPhysicalOffsetFrame(); }
catch (const std::exception& e){
cout << e.what() << endl;
failures.push_back("testPhysicalOffsetFrameOnPhysicalOffsetFrame");
}
try { testPhysicalOffsetFrameOnPhysicalOffsetFrameOrder(); }
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testPhysicalOffsetFrameOnPhysicalOffsetFrameOrder");
}
try { testFilterByFrameType(); }
catch (const std::exception& e){
cout << e.what() << endl;
failures.push_back("testFilterByFrameType");
}
try { testVelocityAndAccelerationMethods(); }
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testVelocityAndAccelerationMethods");
}
if (!failures.empty()) {
cout << "Done, with failure(s): " << failures << endl;
return 1;
}
cout << "Done. All cases passed." << endl;
return 0;
}
int main()
{
SimTK::Array_<std::string> failures;
// get all registered Components
SimTK::Array_<Component*> availableComponents;
// starting with type Frame
ArrayPtrs<Frame> availableFrames;
Object::getRegisteredObjectsOfGivenType(availableFrames);
for (int i = 0; i < availableFrames.size(); ++i) {
availableComponents.push_back(availableFrames[i]);
}
// then type Joint
ArrayPtrs<Joint> availableJoints;
Object::getRegisteredObjectsOfGivenType(availableJoints);
for (int i = 0; i < availableJoints.size(); ++i) {
availableComponents.push_back(availableJoints[i]);
}
// continue with Constraint, Actuator, Frame, ...
//Example of an updated force that passes
ArrayPtrs<PointToPointSpring> availablePointToPointSpring;
Object::getRegisteredObjectsOfGivenType(availablePointToPointSpring);
availableComponents.push_back(availablePointToPointSpring[0]);
for (unsigned int i = 0; i < availableComponents.size(); i++) {
try {
testComponent(*availableComponents[i]);
}
catch (const std::exception& e) {
cout << "*******************************************************\n";
cout<< "FAILURE: " << availableComponents[i]->getConcreteClassName() << endl;
cout<< e.what() << endl;
failures.push_back(availableComponents[i]->getConcreteClassName());
}
}
if (!failures.empty()) {
cout << "*******************************************************\n";
cout << "Done, with failure(s): " << failures << endl;
cout << failures.size() << "/" << availableComponents.size()
<< " components failed test." << endl;
cout << 100 * (availableComponents.size() - failures.size()) / availableComponents.size()
<< "% components passed." << endl;
cout << "*******************************************************\n" << endl;
return 1;
}
cout << "\ntestComponents PASSED. " << availableComponents.size()
<< " components were tested." << endl;
}
int main()
{
SimTK::Array_<std::string> failures;
try { testMarkersReference(); }
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testMarkersReference");
}
try { testOrientationsReference(); }
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testOrientationsReference");
}
try { testAccuracy(); }
catch (const std::exception& e) {
cout << e.what() << endl; failures.push_back("testAccuracy");
}
try { testUpdateMarkerWeights(); }
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testUpdateMarkerWeights");
}
try { testTrackWithUpdateMarkerWeights(); }
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testTrackWithUpdateMarkerWeights");
}
try { testNumberOfMarkersMismatch(); }
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testNumberOfMarkersMismatch");
}
try { testNumberOfOrientationsMismatch(); }
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testNumberOfOrientationsMismatch");
}
if (!failures.empty()) {
cout << "Done, with failure(s): " << failures << endl;
return 1;
}
cout << "Done. All cases passed." << endl;
return 0;
}
int main() {
Object::renameType("Thelen2003Muscle", "Thelen2003Muscle_Deprecated");
SimTK::Array_<std::string> failures;
// test manager/integration process
try { testPendulum(); cout << "\nPendulum test PASSED " << endl; }
catch (const std::exception& e)
{ cout << e.what() <<endl; failures.push_back("testPendulum"); }
// test application of external loads
try { testPendulumExternalLoad();
cout << "\nPendulum with external load test PASSED " << endl; }
catch (const std::exception& e)
{ cout << e.what() <<endl; failures.push_back("testPendulumExternalLoad"); }
// test application of external loads
try { testPendulumExternalLoadWithPointInGround();
cout << "\nPendulum with external load and point in ground PASSED " << endl; }
catch (const std::exception& e)
{ cout << e.what() <<endl; failures.push_back("testPendulumExternalLoadWithPointInGround"); }
// now add computation of controls and generation of muscle forces
try { testArm26();
cout << "\narm26 test PASSED " << endl; }
catch (const std::exception& e)
{ cout << e.what() <<endl; failures.push_back("testArm26"); }
// include applied ground reactions forces
try { testGait2354();
cout << "\ngait2354 test PASSED " << endl; }
catch (const std::exception& e)
{ cout << e.what() <<endl; failures.push_back("testGait2354"); }
// finally include a controller
try { testGait2354WithController();
cout << "\ngait2354 with correction controller test PASSED " << endl; }
catch (const std::exception& e)
{ cout << e.what() <<endl; failures.push_back("testGait2354WithController"); }
if (!failures.empty()) {
cout << "Done, with failure(s): " << failures << endl;
return 1;
}
cout << "Done" << endl;
return 0;
}
int main()
{
Array<string> muscleModelNames;
muscleModelNames.append("Thelen2003Muscle_Deprecated");
muscleModelNames.append("Thelen2003Muscle");
muscleModelNames.append("Millard2012EquilibriumMuscle");
muscleModelNames.append("Millard2012AccelerationMuscle");
cout << "=========================================================" << endl;
cout << " WARNING " << endl;
cout << "Athough this file says it testsStaticOptimization, it is" << endl;
cout << "not a valid test. It merely checks to see if the current" << endl;
cout << "static results agree with past static results. " << endl;
cout << endl;
cout << " This is not a test " << endl;
cout << endl;
cout << "A valid test might be done by instead checking that " <<endl;
cout << "1. IPOPT can correctly solve a quadradic problem " <<endl;
cout << "2. That the muscle forces provided to static are in fact "<<endl;
cout << " linear with activation, as is assumed in a static " << endl;
cout << " optimization. M.Millard 2012" << endl;
cout << "=========================================================" << endl;
SimTK::Array_<std::string> failures;
for(int i=0; i< muscleModelNames.getSize(); ++i){
try { // regression test for the Thelen deprecate muscle
// otherwise verify that SO runs with the new models
testArm26(muscleModelNames[i], i<1);
}
catch (const std::exception& e) {
cout << e.what() <<endl;
failures.push_back("testArm26_"+muscleModelNames[i]);
}
}
if (!failures.empty()) {
cout << "Done, with failure(s): " << failures << endl;
return 1;
}
cout << "Done" << endl;
return 0;
}
int main() {
SimTK::Array_<std::string> failures;
try{
testCMCEMGDrivenArm();
} catch(const std::exception& e) {
cout << e.what() <<endl; failures.push_back("testCMCEMGDrivenArm");
}
if (!failures.empty()) {
cout << "Done, with failure(s): " << failures << endl;
return 1;
}
cout << "Done" << endl;
return 0;
}
int main() {
Object::renameType("Thelen2003Muscle", "Thelen2003Muscle_Deprecated");
//Object::renameType("Thelen2003Muscle", "Millard2012AccelerationMuscle");
//Object::renameType("Thelen2003Muscle", "Millard2012EquilibriumMuscle");
SimTK::Array_<std::string> failures;
try {testGait2354();}
catch (const std::exception& e)
{ cout << e.what() <<endl; failures.push_back("testGait2354"); }
if (!failures.empty()) {
cout << "Done, with failure(s): " << failures << endl;
return 1;
}
cout << "Done" << endl;
return 0;
}
int main() {
SimTK::Array_<std::string> failures;
Object::renameType("Thelen2003Muscle", "Millard2012EquilibriumMuscle");
try{
testCMCEMGDrivenArm();
} catch (const std::exception& e) {
cout << e.what() <<endl; failures.push_back("testCMCEMGDrivenArm_Millard");
}
if (!failures.empty()) {
cout << "Done, with failure(s): " << failures << endl;
return 1;
}
cout << "Done" << endl;
return 0;
}
int main()
{
SimTK::Array_<std::string> failures;
try { testPendulumModelWithNestedJoints<Device>(); }
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testPendulumModelWithNestedJoints<Device>");
}
try { testPendulumModelWithNestedJoints<Model>(); }
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testPendulumModelWithNestedJoints<Model>");
}
if (!failures.empty()) {
cout << "Done, with failure(s): " << failures << endl;
return 1;
}
cout << "Done. All cases passed." << endl;
return 0;
}
int main()
{
SimTK::Array_<std::string> failures;
// get all registered Components
SimTK::Array_<Component*> availableComponents;
// starting with type Frame
ArrayPtrs<Frame> availableFrames;
Object::getRegisteredObjectsOfGivenType(availableFrames);
for (int i = 0; i < availableFrames.size(); ++i) {
availableComponents.push_back(availableFrames[i]);
}
// next with type Point
ArrayPtrs<Point> availablePoints;
Object::getRegisteredObjectsOfGivenType(availablePoints);
for (int i = 0; i < availablePoints.size(); ++i) {
availableComponents.push_back(availablePoints[i]);
}
// then type Joint
ArrayPtrs<Joint> availableJoints;
Object::getRegisteredObjectsOfGivenType(availableJoints);
for (int i = 0; i < availableJoints.size(); ++i) {
availableComponents.push_back(availableJoints[i]);
}
// then type TwoFrameLinker<Constraint>
ArrayPtrs<TwoFrameLinker<Constraint, PhysicalFrame> > availableLink2Constraints;
Object::getRegisteredObjectsOfGivenType(availableLink2Constraints);
for (int i = 0; i < availableLink2Constraints.size(); ++i) {
availableComponents.push_back(availableLink2Constraints[i]);
}
// then type TwoFrameLinker<Force> which are all the BushingForces
ArrayPtrs<TwoFrameLinker<Force, PhysicalFrame> > availableBushingForces;
Object::getRegisteredObjectsOfGivenType(availableBushingForces);
for (int i = 0; i < availableBushingForces.size(); ++i) {
availableComponents.push_back(availableBushingForces[i]);
}
// Test PrescribedForce
std::unique_ptr<PrescribedForce> f(new PrescribedForce());
availableComponents.push_back(f.get());
// continue with other Constraints, Forces, Actuators, ...
//Examples of updated forces that pass
ArrayPtrs<PointToPointSpring> availablePointToPointSpring;
Object::getRegisteredObjectsOfGivenType(availablePointToPointSpring);
availableComponents.push_back(availablePointToPointSpring[0]);
/** //Uncomment when dependencies of CoordinateCouplerConstraints are
// specified as Connectors
ArrayPtrs<Constraint> availableConstraints;
Object::getRegisteredObjectsOfGivenType(availableConstraints);
for (int i = 0; i < availableConstraints.size(); ++i) {
availableComponents.push_back(availableConstraints[i]);
}
*/
for (unsigned int i = 0; i < availableComponents.size(); i++) {
try {
testComponent(*availableComponents[i]);
}
catch (const std::exception& e) {
cout << "*******************************************************\n";
cout<< "FAILURE: " << availableComponents[i]->getConcreteClassName() << endl;
cout<< e.what() << endl;
failures.push_back(availableComponents[i]->getConcreteClassName());
}
}
if (!failures.empty()) {
cout << "*******************************************************\n";
cout << "Done, with failure(s): " << failures << endl;
cout << failures.size() << "/" << availableComponents.size()
<< " components failed test." << endl;
cout << 100 * (availableComponents.size() - failures.size()) / availableComponents.size()
<< "% components passed." << endl;
cout << "*******************************************************\n" << endl;
return 1;
}
cout << "\ntestComponents PASSED. " << availableComponents.size()
<< " components were tested." << endl;
}
int main()
{
int itc = 0;
SimTK::Array_<std::string> failures;
try { ++itc;
testInverseKinematicsSolverWithOrientations();
}
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testInverseKinematicsSolverWithOrientations");
}
try {
++itc;
testInverseKinematicsSolverWithEulerAnglesFromFile();
}
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testInverseKinematicsSolverWithEulerAnglesFromFile");
}
try {
++itc;
testMarkerWeightAssignments("subject01_Setup_InverseKinematics.xml");
}
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testMarkerWeightAssignments");
}
Storage standard("std_subject01_walk1_ik.mot");
try {
InverseKinematicsTool ik1("subject01_Setup_InverseKinematics.xml");
ik1.run();
Storage result1(ik1.getOutputMotionFileName());
CHECK_STORAGE_AGAINST_STANDARD(result1, standard,
std::vector<double>(24, 0.2), __FILE__, __LINE__,
"testInverseKinematicsGait2354 failed");
cout << "testInverseKinematicsGait2354 passed" << endl;
}
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testInverseKinematicsGait2354");
}
try {
InverseKinematicsTool ik2("subject01_Setup_InverseKinematics_NoModel.xml");
Model mdl("subject01_simbody.osim");
mdl.initSystem();
ik2.setModel(mdl);
ik2.run();
Storage result2(ik2.getOutputMotionFileName());
CHECK_STORAGE_AGAINST_STANDARD(result2, standard,
std::vector<double>(24, 0.2), __FILE__, __LINE__,
"testInverseKinematicsGait2354 GUI workflow failed");
cout << "testInverseKinematicsGait2354 GUI workflow passed" << endl;
}
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testInverseKinematicsGait2354_GUI_workflow");
}
try {
InverseKinematicsTool ik3("constraintTest_setup_ik.xml");
ik3.run();
cout << "testInverseKinematicsConstraintTest passed" << endl;
}
catch (const std::exception& e) {
cout << e.what() << endl;
failures.push_back("testInverseKinematicsConstraintTest");
}
if (!failures.empty()) {
cout << "Done, with " << failures.size() << " failure(s) out of ";
cout << itc << " test cases." << endl;
cout << "Failure(s): " << failures << endl;
return 1;
}
cout << "Done. All cases passed." << endl;
return 0;
}
int main()
{
SimTK::Array_<std::string> failures;
try { testPathSpring(); }
catch (const std::exception& e){
cout << e.what() <<endl; failures.push_back("testPathSpring");
}
try { testExternalForce(); }
catch (const std::exception& e){
cout << e.what() <<endl; failures.push_back("testExternalForce");
}
try { testSpringMass(); }
catch (const std::exception& e){
cout << e.what() <<endl; failures.push_back("testP2PSpringMass");
}
try { testBushingForce(); }
catch (const std::exception& e){
cout << e.what() <<endl; failures.push_back("testBushingForce");
}
try { testFunctionBasedBushingForce(); }
catch (const std::exception& e){
cout << e.what() <<endl;
failures.push_back("testFunctionBasedBushingForce");
}
try { testElasticFoundation(); }
catch (const std::exception& e){
cout << e.what() <<endl; failures.push_back("testElasticFoundation");
}
try { testHuntCrossleyForce(); }
catch (const std::exception& e){
cout << e.what() <<endl; failures.push_back("testHuntCrossleyForce");
}
try { testCoordinateLimitForce(); }
catch (const std::exception& e){
cout << e.what() <<endl; failures.push_back("testCoordinateLimitForce");
}
try { testCoordinateLimitForceRotational(); }
catch (const std::exception& e){
cout << e.what() <<endl;
failures.push_back("testCoordinateLimitForceRotational");
}
try { testExpressionBasedPointToPointForce(); }
catch (const std::exception& e){
cout << e.what() <<endl;
failures.push_back("testExpressionBasedPointToPointForce");
}
try { testExpressionBasedCoordinateForce(); }
catch (const std::exception& e){
cout << e.what() <<endl;
failures.push_back("testExpressionBasedCoordinateForce");
}
if (!failures.empty()) {
cout << "Done, with failure(s): " << failures << endl;
return 1;
}
cout << "Done. All cases passed." << endl;
return 0;
}