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()
{
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;
}
// See if we can find the given file. The rules are
// - if it is an absolute pathname, we only get one shot, else:
// - define "modelDir" to be the absolute pathname of the
// directory from which we read in the .osim model, if we did,
// otherwise modelDir="." (current directory).
// - look for the geometry file in modelDir
// - look for the geometry file in modelDir/Geometry
// - look for the geometry file in installDir/Geometry
bool ModelVisualizer::
findGeometryFile(const Model& aModel,
const std::string& geoFile,
bool& geoFileIsAbsolute,
SimTK::Array_<std::string>& attempts)
{
attempts.clear();
std::string geoDirectory, geoFileName, geoExtension;
SimTK::Pathname::deconstructPathname(geoFile,
geoFileIsAbsolute, geoDirectory, geoFileName, geoExtension);
bool foundIt = false;
if (geoFileIsAbsolute) {
attempts.push_back(geoFile);
foundIt = Pathname::fileExists(attempts.back());
} else {
const string geoDir = "Geometry" + Pathname::getPathSeparator();
string modelDir;
if (aModel.getInputFileName() == "Unassigned")
modelDir = Pathname::getCurrentWorkingDirectory();
else {
bool isAbsolutePath; string directory, fileName, extension;
SimTK::Pathname::deconstructPathname(
aModel.getInputFileName(),
isAbsolutePath, directory, fileName, extension);
modelDir = isAbsolutePath
? directory
: Pathname::getCurrentWorkingDirectory() + directory;
}
attempts.push_back(modelDir + geoFile);
foundIt = Pathname::fileExists(attempts.back());
if (!foundIt) {
attempts.push_back(modelDir + geoDir + geoFile);
foundIt = Pathname::fileExists(attempts.back());
}
if (!foundIt) {
const string installDir =
Pathname::getInstallDir("OPENSIM_HOME", "OpenSim");
attempts.push_back(installDir + geoDir + geoFile);
foundIt = Pathname::fileExists(attempts.back());
}
}
return foundIt;
}
void Cone::implementCreateDecorativeGeometry(SimTK::Array_<SimTK::DecorativeGeometry>& decoGeoms) const
{
const Vec3 netScale = get_scale_factors();
DecorativeCone deco(get_origin(), SimTK::UnitVec3(get_direction()), get_height(), get_base_radius());
deco.setScaleFactors(netScale);
decoGeoms.push_back(deco);
}
void Cylinder::implementCreateDecorativeGeometry(SimTK::Array_<SimTK::DecorativeGeometry>& decoGeoms) const
{
const Vec3 netScale = get_scale_factors();
DecorativeCylinder deco(get_radius(), get_half_height());
deco.setScaleFactors(netScale);
decoGeoms.push_back(deco);
}
void Ellipsoid::implementCreateDecorativeGeometry(SimTK::Array_<SimTK::DecorativeGeometry>& decoGeoms) const
{
const Vec3 netScale = get_scale_factors();
DecorativeEllipsoid deco(get_radii());
deco.setScaleFactors(netScale);
decoGeoms.push_back(deco);
}
void Brick::implementCreateDecorativeGeometry(SimTK::Array_<SimTK::DecorativeGeometry>& decoGeoms) const
{
const Vec3 netScale = get_scale_factors();
DecorativeBrick deco(get_half_lengths());
deco.setScaleFactors(netScale);
decoGeoms.push_back(deco);
}
void Mesh::implementCreateDecorativeGeometry(SimTK::Array_<SimTK::DecorativeGeometry>& decoGeoms) const
{
if (cachedMesh.get() != nullptr) {
cachedMesh->setScaleFactors(get_scale_factors());
decoGeoms.push_back(*cachedMesh);
}
}
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;
}
// Implement generateDecorations by WrapCylinder to replace the previous out of place implementation
// in ModelVisualizer
void WrapCylinder::generateDecorations(bool fixed, const ModelDisplayHints& hints, const SimTK::State& state,
SimTK::Array_<SimTK::DecorativeGeometry>& appendToThis) const
{
Super::generateDecorations(fixed, hints, state, appendToThis);
if (fixed) return;
if (hints.get_show_wrap_geometry()) {
const Appearance& defaultAppearance = get_Appearance();
if (!defaultAppearance.get_visible()) return;
const Vec3 color = defaultAppearance.get_color();
SimTK::Transform ztoy;
// Make transform that takes z axis to y axis due to different
// assumptions between DecorativeCylinder aligned with y and
// WrapCylinder aligned with z
ztoy.updR().setRotationFromAngleAboutX(SimTK_PI / 2);
const SimTK::Transform& X_GB = getFrame().getTransformInGround(state);
SimTK::Transform X_GW = X_GB*getTransform()*ztoy;
appendToThis.push_back(
SimTK::DecorativeCylinder(get_radius(),
get_length() / 2)
.setTransform(X_GW).setResolution(2.0)
.setColor(color).setOpacity(defaultAppearance.get_opacity())
.setScale(1).setRepresentation(defaultAppearance.get_representation()));
}
}
void LineGeometry::implementCreateDecorativeGeometry(SimTK::Array_<SimTK::DecorativeGeometry>& decoGeoms) const
{
const Vec3 netScale = get_scale_factors();
DecorativeLine deco(get_start_point(), get_end_point());
deco.setScaleFactors(netScale);
decoGeoms.push_back(deco);
}
void FrameGeometry::implementCreateDecorativeGeometry(SimTK::Array_<SimTK::DecorativeGeometry>& decoGeoms) const
{
const Vec3 netScale = get_scale_factors();
DecorativeFrame deco(1.0);
deco.setLineThickness(get_display_radius());
deco.setScaleFactors(netScale);
decoGeoms.push_back(deco);
}
void Arrow::implementCreateDecorativeGeometry(SimTK::Array_<SimTK::DecorativeGeometry>& decoGeoms) const
{
const Vec3 netScale = get_scale_factors();
SimTK::Vec3 endPt(get_length()*get_direction());
DecorativeArrow deco(SimTK::Vec3(0), endPt);
deco.setLineThickness(0.05);
deco.setScaleFactors(netScale);
decoGeoms.push_back(deco);
}
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;
}
void Geometry::generateDecorations(bool fixed, const ModelDisplayHints& hints, const SimTK::State& state,
SimTK::Array_<SimTK::DecorativeGeometry>& appendToThis) const
{
if (!fixed) return; // serialized Geometry is assumed fixed
SimTK::Array_<SimTK::DecorativeGeometry> decos;
implementCreateDecorativeGeometry(decos);
if (decos.size() == 0) return;
setDecorativeGeometryTransform(decos, state);
for (unsigned i = 0; i < decos.size(); i++){
setDecorativeGeometryAppearance(decos[i]);
appendToThis.push_back(decos[i]);
}
}
//------------------------------------------------------------------------------
// GENERATE DECORATIONS
//------------------------------------------------------------------------------
// The GeometryPath takes care of drawing itself here, using information it
// can extract from the supplied state, including position information and
// color information that may have been calculated as late as Stage::Dynamics.
// For example, muscles may want the color to reflect activation level and
// other path-using components might want to use forces (tension). We will
// ensure that the state has been realized to Stage::Dynamics before looking
// at it. (It is only guaranteed to be at Stage::Position here.)
void GeometryPath::
generateDecorations(bool fixed, const ModelDisplayHints& hints,
const SimTK::State& state,
SimTK::Array_<SimTK::DecorativeGeometry>& appendToThis) const
{
// There is no fixed geometry to generate here.
if (fixed) { return; }
// Ensure that the state has been realized to Stage::Dynamics to give
// clients of this path a chance to calculate meaningful color information.
this->getModel().getMultibodySystem().realize(state, SimTK::Stage::Dynamics);
this->updateDisplayPath(state);
// Even though these are Points which are Components they are completey
// orphaned and not part of any system since they are populated during
// a simulation. TODO we need another data structure to be a DecorativePath
// which simply an array of points in ground or on MBs.
// Trying to getLocationInGround(state) will faile due to no underlying system.
const Array<PathPoint*>& points = getCurrentDisplayPath(state);
if (points.getSize() == 0) { return; }
const PathPoint* lastPoint = points[0];
MobilizedBodyIndex mbix(0);
Vec3 lastPos = lastPoint->getLocationInGround(state);
if (hints.get_show_path_points())
DefaultGeometry::drawPathPoint(mbix, lastPos, getColor(state), appendToThis);
Vec3 pos;
for (int j = 1; j < points.getSize(); j++) {
const PathPoint* point = points[j];
// the body (PhysicalFrame) IS part of the actual Model and its system
// so we can ask it for its transform w.r.t. Ground
pos = point->getBody().getTransformInGround(state)*point->getLocation();
if (hints.get_show_path_points())
DefaultGeometry::drawPathPoint(mbix, pos, getColor(state), appendToThis);
// Line segments will be in ground frame
appendToThis.push_back(DecorativeLine(lastPos, pos)
.setLineThickness(4)
.setColor(getColor(state)).setBodyId(0).setIndexOnBody(j));
lastPos = pos;
}
}
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;
}
void EllipsoidJoint::generateDecorations
(bool fixed,
const ModelDisplayHints& hints,
const SimTK::State& state,
SimTK::Array_<SimTK::DecorativeGeometry>& geometryArray) const
{
// invoke parent class method, this draws 2 Frames
Super::generateDecorations(fixed,hints,state,geometryArray);
// Construct the visible Ellipsoid
SimTK::DecorativeEllipsoid ellipsoid(get_radii_x_y_z());
ellipsoid.setTransform(getParentFrame().getTransformInGround(state));
ellipsoid.setColor(Vec3(0.0, 1.0, 1.0));
geometryArray.push_back(ellipsoid);
}
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()
{
try {
Storage result("Arm26_optimized_states.sto"),
standard("std_Arm26_optimized_states.sto");
CHECK_STORAGE_AGAINST_STANDARD(result, standard, Array<double>(0.01, 16),
__FILE__, __LINE__, "Arm26 states failed comparison test");
cout << "Arm26 states comparison test passed\n";
// Ensure the optimization result acheived a velocity of at least
// REF_MAX_VEL, and that the control values are within either 20% of the
// reference values or 0.05 in absolute value.
ifstream resFile;
resFile.open("Arm26_optimization_result");
ASSERT(resFile.is_open(), __FILE__, __LINE__,
"Can't open optimization result file" );
SimTK::Array_<double> resVec;
for ( ; ; ) {
double tmp;
resFile >> tmp;
if (!resFile.good())
break;
resVec.push_back(tmp);
}
ASSERT(resVec.size() == ARM26_DESIGN_SPACE_DIM+1, __FILE__, __LINE__,
"Optimization result size mismatch" );
// Ensure the optimizer found a local minimum we expect.
for (int i = 0; i < ARM26_DESIGN_SPACE_DIM-1; ++i) {
ASSERT(fabs(resVec[i] - refControls[i])/refControls[i] < 0.2 ||
fabs(resVec[i] - refControls[i]) < 0.05, __FILE__, __LINE__,
"Control value does not match reference" );
}
ASSERT(resVec[ARM26_DESIGN_SPACE_DIM] > REF_MAX_VEL, __FILE__, __LINE__,
"Optimized velocity smaller than reference" );
cout << "Arm26 optimization results passed\n";
}
catch (const Exception& e) {
e.print(cerr);
return 1;
}
cout << "Done" << endl;
return 0;
}
void ConstantDistanceConstraint::generateDecorations(
bool fixed,
const ModelDisplayHints& hints,
const SimTK::State& state,
SimTK::Array_<SimTK::DecorativeGeometry>& appendToThis) const
{
Super::generateDecorations(fixed, hints, state, appendToThis);
if (fixed) return;
const Vec3 pink(1, .6, .8);
const OpenSim::PhysicalFrame& frame1 = getBody1();
const Vec3& p_B1 = frame1.getTransformInGround(state)*get_location_body_1();
const OpenSim::PhysicalFrame& frame2 = getBody2();
const Vec3& p_B2 = frame2.getTransformInGround(state)*get_location_body_2();
appendToThis.push_back(
SimTK::DecorativeLine(p_B1, p_B2).setBodyId(0)
.setColor(pink).setOpacity(1.0).setLineThickness(.05));
}
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;
}
void Marker::generateDecorations(bool fixed, const ModelDisplayHints& hints, const SimTK::State& state,
SimTK::Array_<SimTK::DecorativeGeometry>& appendToThis) const
{
Super::generateDecorations(fixed, hints, state, appendToThis);
if (!fixed) return;
if (hints.get_show_markers()) {
// @TODO default color, size, shape should be obtained from hints
const Vec3 pink(1, .6, .8);
const OpenSim::PhysicalFrame& frame = getReferenceFrame();
const Frame& bf = frame.findBaseFrame();
SimTK::Transform bTrans = frame.findTransformInBaseFrame();
const Vec3& p_BM = bTrans*get_location();
appendToThis.push_back(
SimTK::DecorativeSphere(.005).setBodyId(frame.getMobilizedBodyIndex())
.setColor(pink).setOpacity(1.0)
.setTransform(get_location()));
}
}
// Implement generateDecorations by WrapEllipsoid to replace the previous out of place implementation
// in ModelVisualizer
void WrapEllipsoid::generateDecorations(bool fixed, const ModelDisplayHints& hints, const SimTK::State& state,
SimTK::Array_<SimTK::DecorativeGeometry>& appendToThis) const
{
Super::generateDecorations(fixed, hints, state, appendToThis);
if (fixed) return;
if (hints.get_show_wrap_geometry()) {
const Vec3 color(SimTK::Cyan);
const SimTK::Transform& X_GB = getFrame().getTransformInGround(state);
SimTK::Transform X_GW = X_GB*getTransform();
appendToThis.push_back(
SimTK::DecorativeEllipsoid(getRadii())
.setTransform(X_GW).setResolution(2.0)
.setColor(color).setOpacity(0.5));
}
}
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;
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");
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() {
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;
}