SExp* Eval::addPairs(SExp* p, SExp* x,SExp* a)
{
char sStr[1000];
memset(sStr,0,1000);
if (x->isNIL()==1 && p->isNIL()==1)
return a;
if (x->isNIL()==1)
{
x->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::USER_ARG_NO_MATCH,sStr);
}
if (p->isNIL()==1)
{
p->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::USER_ARG_NO_MATCH,sStr);
}
SExp* s=new SExp();
s->car=p->car;
s->cdr=x->car;
return addPairs(p->cdr,x->cdr,cons(s,a));
}
void NestedBoxTestModel::setup(tgWorld& world)
{
const double edge = 30.0;
const double height = tgUtil::round(std::sqrt(3.0)/2 * edge);
std::cout << "edge: " << edge << "; height: " << height << std::endl;
// Create the tetrahedra
tgStructure tetra;
addNodes(tetra, edge, height);
addPairs(tetra);
// Move the first one so we can create a longer snake.
// Or you could move the snake at the end, up to you.
tetra.move(btVector3(0.0, 2.0, 100.0));
// Create our snake segments
tgStructure snake;
addSegments(snake, tetra, edge, m_segments);
addMuscles(snake);
// Create the build spec that uses tags to turn the structure into a real model
// Note: This needs to be high enough or things fly apart...
const double density = 4.2 / 3000.0; // kg / length^3 - see app for length
const double radius = 0.5;
const double h = 0.5;
const tgBox::Config rodConfig(radius, density);
tgBuildSpec spec;
spec.addBuilder("rod", new tgBoxInfo(rodConfig));
tgSpringCableActuator::Config muscleConfig(1000, 10);
//spec.addBuilder("muscle", new tgBasicActuatorInfo(muscleConfig));
const tgSphere::Config sphereConfig(0.5, 0.5);
spec.addBuilder("light", new tgSphereInfo(sphereConfig));
const tgSphere::Config sphereConfig2(0.5, 2.5);
spec.addBuilder("light", new tgSphereInfo(sphereConfig2));
// Create your structureInfo
tgStructureInfo structureInfo(snake, spec);
// Use the structureInfo to build ourselves
structureInfo.buildInto(*this, world);
// We could now use tgCast::filter or similar to pull out the models (e.g. muscles)
// that we want to control.
allMuscles = tgCast::filter<tgModel, tgSpringCableActuator> (getDescendants());
mapMuscles(muscleMap, *this);
trace(structureInfo, *this);
// Actually setup the children
tgModel::setup(world);
}
// This is basically a manual setup of a model.
// There are things that do this for us (@todo: reference the things that do this for us)
void TetraSpineGoal::setup(tgWorld& world)
{
const double edge = 3.8 * scaleFactor;
const double height = tgUtil::round(std::sqrt(3.0)/2 * edge);
std::cout << "edge: " << edge << "; height: " << height << std::endl;
// Create the tetrahedra
tgStructure tetra;
addNodes(tetra, edge, height, scaleFactor);
addPairs(tetra);
// Move the first one so we can create a longer snake.
// Or you could move the snake at the end, up to you.
tetra.move(btVector3(0.0, 8.0, 10.0));
// Create our snake segments
tgStructure snake;
addSegments(snake, tetra, -2.30 * scaleFactor, m_segments);
addMuscles(snake);
// Create the build spec that uses tags to turn the structure into a real model
// Note: This needs to be high enough or things fly apart...
// Params for In Won
const double radius = 0.635 * scaleFactor / 10.0;
const double sphereRadius = 0.635 * scaleFactor / (10.0);
const double density = 2.0 *.0201 / (pow(radius, 2) * M_PI * edge); // Mass divided by volume... should there be a way to set this automatically??
const double friction = 0.5;
const tgRod::Config rodConfig(radius, density, friction);
tgBuildSpec spec;
spec.addBuilder("rod", new tgRodInfo(rodConfig));
// 1000 is so the units below can be in grams
const double sphereVolume1 = 1000.0 * 4.0 / 3.0 * M_PI * pow(sphereRadius, 3);
const double sphereVolume2 = 1000.0 * 4.0 / 3.0 * M_PI * pow(sphereRadius, 3);
const double baseCornerMidD = 180.0 / sphereVolume1;
const tgSphere::Config baseCornerMidConfig(sphereRadius, baseCornerMidD, friction);
spec.addBuilder("base", new tgSphereInfo(baseCornerMidConfig));
const double tipCornerMidD = 120.0 / sphereVolume1;
const tgSphere::Config tipCornerMidConfig(sphereRadius, tipCornerMidD, friction);
spec.addBuilder("tip", new tgSphereInfo(tipCornerMidConfig));
const double PCBD = 70.0 / sphereVolume2;
const tgSphere::Config PCB_1_Config(radius, PCBD, friction);
spec.addBuilder("PCB", new tgSphereInfo(PCB_1_Config));
const double elasticity = 1000.0;
const double damping = 10.0;
const double pretension = 0.0;
const bool history = false;
const double maxTens = 7000.0;
const double maxSpeed = 12.0;
const double mRad = 1.0;
const double motorFriction = 10.0;
const double motorInertia = 1.0;
const bool backDrivable = false;
tgKinematicActuator::Config motorConfig(elasticity, damping, pretension,
mRad, motorFriction, motorInertia, backDrivable,
history, maxTens, maxSpeed);
spec.addBuilder("muscle", new tgKinematicContactCableInfo(motorConfig));
// Create your structureInfo
tgStructureInfo structureInfo(snake, spec);
// Use the structureInfo to build ourselves
structureInfo.buildInto(*this, world);
// We could now use tgCast::filter or similar to pull out the models (e.g. muscles)
// that we want to control.
m_allMuscles = this->find<tgSpringCableActuator> ("muscle");
m_allSegments = this->find<tgModel> ("segment");
mapMuscles(m_muscleMap, *this);
//addMarkers(snake, *this);
#if (0)
trace(structureInfo, *this);
#endif
// Actually setup the children
BaseSpineModelGoal::setup(world);
}
void RibModelMixedContact::setup(tgWorld& world)
{
double v_size = 3.0;
// Create the spinal processes
tgStructure vertebrae;
addNodes(vertebrae, v_size);
addPairs(vertebrae);
// Move the first one so we can create a longer snake.
// Or you could move the snake at the end, up to you.
vertebrae.move(btVector3(0.0, 2 * v_size, v_size * m_segments));
// Create ribs and add them to the vertebrae
double majorAxis = 6.0;
double minorAxis = 4.0;
double startTheta = M_PI / 2.0;
double endTheta = 5.0 * M_PI / 4.0;
size_t segs = 15;
tgStructure ribs;
ellipseNodes(ribs, majorAxis, minorAxis, startTheta, endTheta, segs);
makePairs(ribs);
#if (0) // Attempt at compliant rib attachments
ribs.move(btVector3(v_size / 3.0, 2 * v_size - minorAxis, v_size * m_segments));
#else
ribs.move(btVector3(0.0, 2 * v_size - minorAxis -.3, v_size * m_segments));
#endif
// Create our snake segments
tgStructure snake;
addSegments(snake, vertebrae, ribs, v_size, m_segments);
snake.move(btVector3(0.0, majorAxis, 0.0));
addMuscles(snake);
// Create the build spec that uses tags to turn the structure into a real model
// Note: This needs to be high enough or things fly apart...
const double density = 4.2 / 300.0;
const double radius = 0.5;
const double friction = 0.5; // Default is 0.5
const double rollFriction = 0.5; // Default is 0.0
const double restitution = 0.0; // Default
const tgRod::Config rodConfig(radius, density, friction, rollFriction, restitution);
tgBuildSpec spec;
spec.addBuilder("rod", new tgRodInfo(rodConfig));
const double elasticity = 500.0;
const double elasticityAct = 1000.0;
const double damping = 5.0;
const double dampingAct = 10.0;
const double pretension = 0.0;
const bool history = true;
const double maxTens = 1000.0;
const double maxTensAct = 7000.0;
const double maxSpeed = 100.0;
const double maxSpeedAct = 24.0;
const double mRad = 1.0;
const double motorFriction = 10.0;
const double motorInertia = 1.0;
const bool backDrivable = false;
#if (0) //Replacing with tgKinematicActuator, leaving option to turn it off. 9/9/15.
tgKinematicActuator::Config muscleConfig(elasticity, damping, pretension,
mRad, motorFriction, motorInertia, backDrivable,
history, maxTens, maxSpeed);
spec.addBuilder("muscle", new tgKinematicContactCableInfo(muscleConfig));
tgKinematicActuator::Config muscleConfigAct(elasticityAct, dampingAct, pretension,
mRad, motorFriction, motorInertia, backDrivable,
history, maxTensAct, maxSpeedAct);
spec.addBuilder("muscleAct", new tgKinematicContactCableInfo(muscleConfigAct));
#else
tgSpringCableActuator::Config muscleConfig(elasticity, damping, pretension, history);
spec.addBuilder("muscle", new tgBasicContactCableInfo(muscleConfig));
/// @todo acceleration constraint was removed on 12/10/14 Replace with tgKinematicActuator as appropreate
tgSpringCableActuator::Config muscleConfigAct(elasticityAct, dampingAct, pretension, history, 7000, 24);
spec.addBuilder("muscleAct", new tgBasicContactCableInfo(muscleConfigAct));
#endif
#if (0) // Compliant Rib Attachments
const double stiffness = 1000;
const double damping = .01 * stiffness;
tgSpringCableActuator::Config muscleConfig1(stiffness, damping, -M_PI / 2.0);
tgSpringCableActuator::Config muscleConfig2(stiffness, damping, M_PI / 2.0);
tgSpringCableActuator::Config muscleConfig3(stiffness, damping, M_PI);
tgSpringCableActuator::Config muscleConfig4(stiffness, damping, 0);
spec.addBuilder("multiMuscle", new tgBasicActuatorInfo(muscleConfig1));
spec.addBuilder("multiMuscle", new tgBasicActuatorInfo(muscleConfig2));
spec.addBuilder("multiMuscle", new tgBasicActuatorInfo(muscleConfig3));
spec.addBuilder("multiMuscle", new tgBasicActuatorInfo(muscleConfig4));
#endif
// Create your structureInfo
tgStructureInfo structureInfo(snake, spec);
// Use the structureInfo to build ourselves
structureInfo.buildInto(*this, world);
// We could now use tgCast::filter or similar to pull out the models (e.g. muscles)
// that we want to control.
m_allMuscles = find<tgSpringCableActuator> ("muscleAct");
m_allSegments = find<tgModel> ("segment");
#if (0)
trace(structureInfo, *this);
#endif
// Actually setup the children
BaseSpineModelLearning::setup(world);
}
int main(int argc, char *argv[])
{
struct hash *bacHash;
char line[1024];
int lineCount;
char *words[256];
int wordCount;
int fileIx;
char *fileName;
FILE *f;
if (argc < 2)
usage();
bacHash = newHash(16);
for (fileIx = 1; fileIx < argc; ++fileIx)
{
fileName = argv[fileIx];
uglyf("Processing %s\n", fileName);
f = mustOpen(fileName, "r");
lineCount = 0;
while (fgets(line, sizeof(line), f))
{
++lineCount;
wordCount = chopLine(line, words);
if (wordCount == ArraySize(words))
errAbort("Too many words line %d of %s\n", lineCount, fileName);
if (wordCount != 0)
{
char *bacName;
int cIx;
struct contigTrack *ctList = NULL, *ct;
struct bacTrack *bt;
struct hashEl *hel;
/* Check line syntax and parse it. */
if (!sameString(words[1], "glues"))
errAbort("Bad format line %d of %s\n", lineCount, fileName);
bacName = words[2];
for (cIx = 4; cIx < wordCount; cIx += 5)
{
char *parts[3];
int partCount;
AllocVar(ct);
ct->ix = atoi(words[cIx]);
ct->strand = words[cIx+1][0];
ct->dir = words[cIx+2][0];
partCount = chopString(words[cIx+3], "(-)", parts, ArraySize(parts));
if (partCount != 2)
errAbort("Bad format line %d of %s\n", lineCount, fileName);
ct->start = atoi(parts[0]);
ct->end = atoi(parts[1]);
ct->cookedScore = atof(words[cIx+4]);
slAddHead(&ctList, ct);
}
slSort(&ctList, cmpContigTrack);
/* Lookup bacTrack and make it if new. */
hel = hashLookup(bacHash, bacName);
if (hel == NULL)
{
AllocVar(bt);
hel = hashAdd(bacHash, bacName, bt);
bt->name = hel->name;
slAddHead(&bacList, bt);
}
else
{
bt = hel->val;
}
/* Process pairs into bacTrack. */
addPairs(bt, ctList);
slFreeList(&ctList);
}
}
fclose(f);
}
slSort(&bacList, cmpBacTrack);
printStats();
return 0;
}
// This is basically a manual setup of a model.
// There are things that do this for us (@todo: reference the things that do this for us)
void TetraSpineStaticModel_hf::setup(tgWorld& world)
{
const double edge = 38;
const double height = tgUtil::round(std::sqrt(3.0)/2 * edge);
std::cout << "edge: " << edge << "; height: " << height << std::endl;
// Create the tetrahedra
tgStructure tetra;
addNodes(tetra, edge, height);
addPairs(tetra);
// Move the first one so we can create a longer snake.
// Or you could move the snake at the end, up to you.
tetra.move(btVector3(0.0, 2.0, 100.0));
// Create our snake segments
tgStructure snake;
addSegments(snake, tetra, edge, m_segments);
addMuscles(snake);
// Create the build spec that uses tags to turn the structure into a real model
// Note: This needs to be high enough or things fly apart...
// Params for In Won
const double oldDensity = .00311;
const double radius = 0.635 / 2.0;
const double density = 0.0201 / (pow(radius, 2) * M_PI * edge); // Mass divided by volume... should there be a way to set this automatically??
const double friction = 0.15;
const tgRod::Config rodConfig(radius, density, friction);
tgBuildSpec spec;
spec.addBuilder("rod", new tgRodInfo(rodConfig));
// 1000 is so the units below can be in grams
const double sphereVolume = 1000.0 * 4.0 / 3.0 * M_PI * pow(radius, 3);
const double baseCornerFrontD = 140.0 / sphereVolume;
const tgSphere::Config baseCornerFrontConfig(radius, baseCornerFrontD, friction);
spec.addBuilder("num0 base", new tgSphereInfo(baseCornerFrontConfig));
const double baseCornerMidD = 180.0 / sphereVolume;
const tgSphere::Config baseCornerMidConfig(radius, baseCornerMidD, friction);
spec.addBuilder("num1 base", new tgSphereInfo(baseCornerMidConfig));
const double baseCornerRearD = 100.0 / sphereVolume;
const tgSphere::Config baseCornerRearConfig(radius, baseCornerRearD, friction);
spec.addBuilder("num2 base", new tgSphereInfo(baseCornerRearConfig));
const double tipCornerFrontD = 40.0 / sphereVolume;
const tgSphere::Config tipCornerFrontConfig(radius, tipCornerFrontD, friction);
spec.addBuilder("num0 tip", new tgSphereInfo(tipCornerFrontConfig));
const double tipCornerMidD = 120.0 / sphereVolume;
const tgSphere::Config tipCornerMidConfig(radius, tipCornerMidD, friction);
spec.addBuilder("num1 tip", new tgSphereInfo(tipCornerMidConfig));
spec.addBuilder("num2 tip", new tgSphereInfo(tipCornerMidConfig));
const double PCBD = 70.0 / sphereVolume;
const tgSphere::Config PCB_1_Config(radius, PCBD, friction);
spec.addBuilder("PCB num0", new tgSphereInfo(PCB_1_Config));
spec.addBuilder("PCB num1", new tgSphereInfo(PCB_1_Config));
const double PCB2D = 95.0 / sphereVolume;
const tgSphere::Config PCB_2_Config(radius, PCB2D, friction);
spec.addBuilder("PCB num2", new tgSphereInfo(PCB_2_Config));
// Two different string configs
/// @todo acceleration constraint was removed on 12/10/14 Replace with tgKinematicActuator as appropreate
tgSpringCableActuator::Config muscleConfig(229.16, 20, 2000.0, true, 5000, 7.0, 1.0, 1.0);
tgSpringCableActuator::Config muscleConfig2(229.16, 20, 700.0, true, 5000, 7.0, 1.0, 1.0);
spec.addBuilder("top muscle", new tgBasicActuatorInfo(muscleConfig));
spec.addBuilder("left muscle", new tgBasicActuatorInfo(muscleConfig2));
spec.addBuilder("right muscle", new tgBasicActuatorInfo(muscleConfig2));
// Create your structureInfo
tgStructureInfo structureInfo(snake, spec);
// Use the structureInfo to build ourselves
structureInfo.buildInto(*this, world);
// We could now use tgCast::filter or similar to pull out the models (e.g. muscles)
// that we want to control.
m_allMuscles = this->find<tgSpringCableActuator> ("muscle");
m_allSegments = this->find<tgModel> ("segment");
mapMuscles(m_muscleMap, *this);
addMarkers(snake, *this);
#if (0)
trace(structureInfo, *this);
#endif
// Actually setup the children
BaseSpineModelLearning::setup(world);
}
SExp* Eval::apply(SExp* f, SExp* x, SExp* a,Tree* d)
{
char sStr[1000];
memset(sStr,0,1000);
if(f->isAtom==0)
{
f->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::NON_ATOMIC_FUNC,sStr);
}
if(f->value[0]=='\0')
{
f->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::F_VALUE_NULL,sStr);
}
if(strcmp(f->value,"NULL")==0)
{
if(x->car==NULL)
{
x->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::ARGUMENT_NO_MATCH,sStr);
}
else
return isNull(x->car);
}
if(strcmp(f->value,"ATOM")==0)
{
if(x->car==NULL)
{
x->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::ARGUMENT_NO_MATCH,sStr);
}
else
return atom(x->car);
}
if(strcmp(f->value,"INT")==0)
{
if(x->car==NULL)
{
x->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::ARGUMENT_NO_MATCH,sStr);
}
else
return Int(x->car);
}
if(strcmp(f->value,"CAR")==0)
{
if(x->car==NULL)
{
x->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::ARGUMENT_NO_MATCH,sStr);
}
else
return car(x->car);
}
if(strcmp(f->value,"CDR")==0)
{
if(x->car==NULL)
{
x->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::ARGUMENT_NO_MATCH,sStr);
}
else
return cdr(x->car);
}
if(strcmp(f->value,"EQ")==0)
{
if(x->car==NULL || x->cdr->car==NULL)
{
x->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::ARGUMENT_NO_MATCH,sStr);
}
else
return eq(x->car,x->cdr->car);
}
if(strcmp(f->value,"CONS")==0)
{
if(x->car==NULL || x->cdr->car==NULL)
{
x->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::ARGUMENT_NO_MATCH,sStr);
}
else
return cons(x->car,x->cdr->car);
}
if(strcmp(f->value,"PLUS")==0)
{
if(x->car==NULL || x->cdr->car==NULL)
{
x->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::ARGUMENT_NO_MATCH,sStr);
}
else
return plus(x->car,x->cdr->car);
}
if(strcmp(f->value,"MINUS")==0)
{
if(x->car==NULL || x->cdr->car==NULL)
{
x->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::ARGUMENT_NO_MATCH,sStr);
}
else
return minus(x->car,x->cdr->car);
}
if(strcmp(f->value,"TIMES")==0)
{
if(x->car==NULL || x->cdr->car==NULL)
{
x->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::ARGUMENT_NO_MATCH,sStr);
}
else
return times(x->car,x->cdr->car);
}
if(strcmp(f->value,"QUOTIENT")==0)
{
if(x->car==NULL || x->cdr->car==NULL)
{
x->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::ARGUMENT_NO_MATCH,sStr);
}
else
return quotient(x->car,x->cdr->car);
}
if(strcmp(f->value,"REMAINDER")==0)
{
if(x->car==NULL || x->cdr->car==NULL)
{
x->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::ARGUMENT_NO_MATCH,sStr);
}
else
return remainder(x->car,x->cdr->car);
}
if(strcmp(f->value,"GREATER")==0)
{
if(x->car==NULL || x->cdr->car==NULL)
{
x->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::ARGUMENT_NO_MATCH,sStr);
}
else
return greater(x->car,x->cdr->car);
}
if(strcmp(f->value,"LESS")==0)
{
if(x->car==NULL || x->cdr->car==NULL)
{
x->convertString(sStr);
ErrorManager E;
E.buildRunTimeErrors(ErrorManager::ARGUMENT_NO_MATCH,sStr);
}
else
return less(x->car,x->cdr->car);
}
SExp* body = getFunc(f, d)->cdr;
if(body!=NULL){}
else
return NULL;
SExp* SE = addPairs(getFunc(f, d)->car, x, a);
if(SE!=NULL){
}else
return NULL;
return eval(body,SE,d);
}
/***************************************
* The primary functions., called from other classes.
**************************************/
void VerticalSpineModel::setup(tgWorld& world)
{
// debugging output: edge and height length
//std::cout << "edge: " << c.edge << "; height: " << c.height << std::endl;
// Create the first fixed snake segment
// @todo move these hard-coded parameters into config
tgStructure tetraB;
addNodes(tetraB, c.edge, c.height);
addPairsB(tetraB);
tetraB.move(btVector3(0.0, 2, 0));
// Create our snake segments
tgStructure snake;
// add 1st child to snake
tgStructure* const tB = new tgStructure(tetraB);
snake.addChild(tB);
tB->addTags(tgString("segment", 1));
// Create the first non-fixed tetrahedra
tgStructure tetra;
addNodes(tetra, c.edge, c.height);
addPairs(tetra);
// Move the first tetrahedra
// @todo move these hard-coded parameters into config
tetra.move(btVector3(0.0, -6, 0));
// add rest of segments using original tetra configuration
addSegments(snake, tetra, c.edge, m_segments);
addMuscles(snake);
// Create the build spec that uses tags to turn the structure into a real model
// Note: This needs to be high enough or things fly apart...
// length of inner strut = 12.25 cm
// m = 1 kg
// volume of 1 rod = 9.62 cm^3
// total volume = 38.48 cm^3
//const double density = 1/38.48; = 0.026 // kg / length^3 - see app for length
const tgRod::Config rodConfigA(c.radius, c.densityA, c.friction,
c.rollFriction, c.restitution);
const tgRod::Config rodConfigB(c.radius, c.densityB, c.friction,
c.rollFriction, c.restitution);
//holder
const tgRod::Config rodConfigHA(0.1, c.densityA, c.friction,
c.rollFriction, c.restitution);
const tgRod::Config rodConfigHB(0.1, c.densityB, c.friction,
c.rollFriction, c.restitution);
tgBuildSpec spec;
spec.addBuilder("rod", new tgRodInfo(rodConfigA));
spec.addBuilder("rodB", new tgRodInfo(rodConfigB));
// set muscle (string) parameters
// @todo replace acceleration constraint with tgKinematicActuator if needed...
tgSpringCableActuator::Config muscleConfig(c.stiffness, c.damping, c.pretension,
c.hist, c.maxTens, c.targetVelocity);
spec.addBuilder("muscle", new tgBasicActuatorInfo(muscleConfig));
// Create your structureInfo
tgStructureInfo structureInfo(snake, spec);
// Use the structureInfo to build ourselves
structureInfo.buildInto(*this, world);
// We could now use tgCast::filter or similar to pull out the models (e.g. muscles)
// that we want to control.
allMuscles = tgCast::filter<tgModel, tgSpringCableActuator> (getDescendants());
mapMuscles(muscleMap, *this, m_segments);
//trace(structureInfo, *this);
// Actually setup the children
notifySetup();
tgModel::setup(world);
}