//----------------------------------------------------------------------------//
void RenderedString::clearComponentList(ComponentList& list)
{
for (size_t i = 0; i < list.size(); ++i)
delete list[i];
list.clear();
}
//----------------------------------------------------------------------------//
void RenderedString::clearComponentList(ComponentList& list)
{
for (size_t i = 0; i < list.size(); ++i)
CEGUI_DELETE_AO list[i];
list.clear();
}
/**
* @param componentList 带参数构造函数.
*
* 通过一个组件列表来构造模型.
* 此时所有组件都是由外部创建,
* 所以置m_SelfOwn为false.
*/
Model::Model(ComponentList &componentList, ConnectorList &connectorList)
{
for (UINT32 i = 0; i < componentList.size(); ++i)
{
IComponent *component = componentList[i]->Clone();
m_ComponentList.push_back(component);
}
for (UINT32 i = 0; i < connectorList.size(); ++i)
{
Connector connector = connectorList[i], connectorClone;
for (UINT32 i = 0; i < componentList.size(); ++i)
{
if (connector.Source == componentList[i])
{
connectorClone.Source = m_ComponentList[i];
}
if (connector.Target == componentList[i])
{
connectorClone.Target = m_ComponentList[i];
}
}
if (connectorClone.Source != NULL && connectorClone.Target != NULL)
{
m_ConnectorList.push_back(connectorClone);
}
}
}
void testComponentList()
{
ComponentList a;
a.push_back(Component(MS_nanoelectrospray, 1));
a.push_back(Component(MS_quadrupole_ion_trap, 2));
a.push_back(Component(MS_electron_multiplier, 3));
testObject(a);
}
void removeComponents()
{
while ( ! components.empty() )
{
delete components.back();
components.pop_back();
}
focusComponent = 0;
}
void
LogComponentEnableAll (enum LogLevel level)
{
ComponentList *components = GetComponentList ();
for (ComponentListI i = components->begin ();
i != components->end ();
i++)
{
i->second->Enable (level);
}
}
Component::~Component()
{
reparent(0);
ComponentList childListCopy = childList; // need to work on a copy of the set due to iterator problems when deleting the children which attempt to remove themselves from the set..
// clear these two to make the below delete call (which ultimately calls
// reparent and childAdded()) peppier..
childList.clear();
childNameMap.clear();
for (ComponentList::iterator it = childListCopy.begin(); it != childListCopy.end(); ++it)
delete (*it);
idCompMap.erase(id());
NameMap::iterator it = nameCompMap.find(nam);
if (it != nameCompMap.end() && it->second == this) nameCompMap.erase(it);
}
void
LogComponentDisable (char const *name, enum LogLevel level)
{
ComponentList *components = GetComponentList ();
for (ComponentListI i = components->begin ();
i != components->end ();
i++)
{
if (i->first.compare (name) == 0)
{
i->second->Disable (level);
break;
}
}
}
//----------------------------------------------------------------------------//
void RenderedString::cloneComponentList(const ComponentList& list)
{
clearComponentList(d_components);
for (size_t i = 0; i < list.size(); ++i)
d_components.push_back(list[i]->clone());
}
LogComponent::LogComponent (char const * name)
: m_levels (0), m_name (name)
{
//EnvVarCheck (name);
ComponentList *components = GetComponentList ();
for (ComponentListI i = components->begin ();
i != components->end ();
i++)
{
if (i->first == name)
{
std::cerr << "Log component \""<<name<<"\" has already been registered once." << std::endl;
}
}
components->push_back (std::make_pair (name, this));
}
void PathWrap::extendConnectToModel(Model& model)
{
Super::extendConnectToModel(model);
_path = dynamic_cast<const GeometryPath*>(&getParent());
std::string msg = "PathWrap '" + getName()
+ "' must have a GeometryPath as its parent.";
OPENSIM_THROW_IF(_path == nullptr, Exception, msg);
ComponentList<const PhysicalFrame> bodiesList =
model.getComponentList<PhysicalFrame>();
for (ComponentList<PhysicalFrame>::const_iterator it = bodiesList.begin();
it != bodiesList.end(); ++it) {
const WrapObject* wo = it->getWrapObject(getWrapObjectName());
if (wo) {
_wrapObject = wo;
updWrapPoint1().setBody(wo->getFrame());
updWrapPoint1().setWrapObject(wo);
updWrapPoint2().setBody(wo->getFrame());
updWrapPoint2().setWrapObject(wo);
break;
}
}
if (get_method() == "hybrid" || get_method() == "Hybrid" || get_method() == "HYBRID")
_method = hybrid;
else if (get_method() == "midpoint" || get_method() == "Midpoint" || get_method() == "MIDPOINT")
_method = midpoint;
else if (get_method() == "axial" || get_method() == "Axial" || get_method() == "AXIAL")
_method = axial;
else if (get_method() == "Unassigned") { // method was not specified in wrap object definition; use default
_method = hybrid;
upd_method() = "hybrid";
} else { // method was specified incorrectly in wrap object definition; throw an exception
string errorMessage = "Error: wrapping method for wrap object " + getName() + " was either not specified, or specified incorrectly.";
throw Exception(errorMessage);
}
}
void EntityManager::GetAllComponentsFor(const Entity *entity, ComponentList &list) const
{
ASSERT(entity != NULL);
if (!IsValid(entity))
return;
for (ComponentStore::const_iterator i = m_components.begin(); i != m_components.end(); ++i)
{
const EntityComponentsMap &entitiesWithComponent = i->second;
EntityComponentsMap::const_iterator j = entitiesWithComponent.find(entity);
if (j != entitiesWithComponent.end())
list.push_back(j->second);
}
}
//---------------------------------------------------------------------------
void Avatar::fireWeaponGroup(int /*groupId*/)
{
// for now, fire everything
ComponentList list;
findComponents(EquipmentSlotComponent::getClassDef(), list);
for (ComponentList::iterator it = list.begin(); it != list.end(); ++it)
{
EquipmentSlotComponent* pSlot = static_cast<EquipmentSlotComponent*>(*it);
if (pSlot)
{
size_t numEquipment = pSlot->getNumEquipment();
for (size_t i=0; i<numEquipment; ++i)
{
Mountable* pMountable = pSlot->getEquipment(i);
if (pMountable && pMountable->isOfType(Weapon::getClassDef()))
{
Weapon* pWeapon = static_cast<Weapon*>(pMountable);
pWeapon->fire();
}
}
}
}
}
void
LogComponentEnable (char const *name, enum LogLevel level)
{
ComponentList *components = GetComponentList ();
ComponentListI i;
for (i = components->begin ();
i != components->end ();
i++)
{
if (i->first.compare (name) == 0)
{
i->second->Enable (level);
return;
}
}
if (i == components->end())
{
// nothing matched
LogComponentPrintList();
NS_FATAL_ERROR ("Logging component \"" << name <<
"\" not found. See above for a list of available log components");
}
}
void PathWrap::connectToModelAndPath(Model& aModel, GeometryPath& aPath)
{
_path = &aPath;
ComponentList<PhysicalFrame> bodiesList = aModel.getComponentList<PhysicalFrame>();
for (ComponentList<PhysicalFrame>::const_iterator it = bodiesList.begin();
it != bodiesList.end(); ++it) {
const WrapObject* wo = it->getWrapObject(getWrapObjectName());
if (wo) {
_wrapObject = wo;
updWrapPoint1().setBody(wo->getBody());
updWrapPoint1().setWrapObject(wo);
updWrapPoint2().setBody(wo->getBody());
updWrapPoint2().setWrapObject(wo);
break;
}
}
// connectToModelAndPath() must be called after setBody() because it requires
// that _bodyName already be assigned.
updWrapPoint1().connectToModelAndPath(aModel, aPath);
updWrapPoint2().connectToModelAndPath(aModel, aPath);
if (get_method() == "hybrid" || get_method() == "Hybrid" || get_method() == "HYBRID")
_method = hybrid;
else if (get_method() == "midpoint" || get_method() == "Midpoint" || get_method() == "MIDPOINT")
_method = midpoint;
else if (get_method() == "axial" || get_method() == "Axial" || get_method() == "AXIAL")
_method = axial;
else if (get_method() == "Unassigned") { // method was not specified in wrap object definition; use default
_method = hybrid;
upd_method() = "hybrid";
} else { // method was specified incorrectly in wrap object definition; throw an exception
string errorMessage = "Error: wrapping method for wrap object " + getName() + " was either not specified, or specified incorrectly.";
throw Exception(errorMessage);
}
}
void testComponentList()
{
if (os_) *os_ << "testComponentList()\n";
ComponentList componentList;
componentList.push_back(Component(ComponentType_Source, 1));
componentList.push_back(Component(ComponentType_Analyzer, 2));
componentList.push_back(Component(ComponentType_Detector, 3));
componentList.source(0).paramGroupPtrs.push_back(ParamGroupPtr(new ParamGroup("pg")));
componentList.analyzer(0).paramGroupPtrs.push_back(ParamGroupPtr(new ParamGroup("pg")));
componentList.detector(0).paramGroupPtrs.push_back(ParamGroupPtr(new ParamGroup("pg")));
MSData msd;
msd.paramGroupPtrs.push_back(ParamGroupPtr(new ParamGroup("pg")));
msd.paramGroupPtrs.back()->userParams.push_back(UserParam("user"));
References::resolve(componentList, msd);
unit_assert(!componentList.source(0).paramGroupPtrs[0]->userParams.empty());
unit_assert(!componentList.analyzer(0).paramGroupPtrs[0]->userParams.empty());
unit_assert(!componentList.detector(0).paramGroupPtrs[0]->userParams.empty());
}
bool addComponentCheck(AComponent * newCmp)
{
m_components.stage(newCmp);
return true;
}
int main()
{
try {
LoadOpenSimLibrary("osimActuators");
std::string filename = "arm26.osim";
Model model(filename);
model.dumpSubcomponents();
ComponentList<Component> componentsList = model.getComponentList();
std::cout << "list begin: " << componentsList.begin()->getName() << std::endl;
int numComponents = 0;
for (ComponentList<Component>::const_iterator it = componentsList.begin();
it != componentsList.end();
++it) {
std::cout << "Iterator is at: " << it->getFullPathName() << " <" << it->getConcreteClassName() << ">" << std::endl;
numComponents++;
}
ComponentList<OpenSim::Body> bodiesList = model.getComponentList<OpenSim::Body>();
int numBodies = 0;
std::cout << "Bodies list begin: " << bodiesList.begin()->getName() << std::endl;
for (ComponentList<OpenSim::Body>::const_iterator it = bodiesList.begin();
it != bodiesList.end();
++it) {
std::cout << "Iterator is at Body: " << it->getName() << std::endl;
numBodies++;
}
// Now we try the post increment variant of the iterator
std::cout << "Bodies list begin, using post increment: " << bodiesList.begin()->getName() << std::endl;
int numBodiesPost = 0;
for (ComponentList<OpenSim::Body>::const_iterator itPost = bodiesList.begin();
itPost != bodiesList.end();
itPost++) {
std::cout << "Iterator is at Body: " << itPost->getName() << std::endl;
numBodiesPost++;
}
int numMuscles = 0;
std::cout << "Using range-for loop over Muscles: " << std::endl;
ComponentList<Muscle> musclesList = model.getComponentList<Muscle>();
for (const Muscle& muscle : musclesList) {
std::cout << "Iterator is at muscle: " << muscle.getName() << std::endl;
numMuscles++;
}
int numGeomPaths = 0;
ComponentList<GeometryPath> geomPathList = model.getComponentList<GeometryPath>();
for (const GeometryPath& gpath : geomPathList) {
(void)gpath; // Suppress unused variable warning.
numGeomPaths++;
}
const OpenSim::Joint& shoulderJnt = model.getJointSet().get(0);
// cycle through components under shoulderJnt should return the Joint itself and the Coordinate
int numJntComponents = 0;
ComponentList<Component> jComponentsList = shoulderJnt.getComponentList();
std::cout << "Components/subComponents under Shoulder Joint:" << std::endl;
for (ComponentList<Component>::const_iterator it = jComponentsList.begin();
it != jComponentsList.end();
++it) {
std::cout << "Iterator is at: " << it->getConcreteClassName() << " " << it->getFullPathName() << std::endl;
numJntComponents++;
}
cout << "Num all components = " << numComponents << std::endl;
cout << "Num bodies = " << numBodies << std::endl;
cout << "Num Muscles = " << numMuscles << std::endl;
cout << "Num GeometryPath components = " << numGeomPaths << std::endl;
// Components = Model+3Body+3Marker+2(Joint+Coordinate)+6(Muscle+GeometryPath)
// Should test against 1+#Bodies+#Markers+#Joints+#Constraints+#Coordinates+#Forces+#ForcesWithPath+..
// Would that account for internal (split-bodies etc.?)
// To test states we must have added the components to the system
// which is done when the model creates and initializes the system
SimTK::State state = model.initSystem();
int numJointsWithStateVariables = 0;
ComponentList<Joint> jointsWithStates = model.getComponentList<Joint>();
ComponentWithStateVariables myFilter;
jointsWithStates.setFilter(myFilter);
for (const Joint& comp : jointsWithStates) {
cout << comp.getConcreteClassName() << ":" << comp.getFullPathName() << endl;
numJointsWithStateVariables++;
}
int numModelComponentsWithStateVariables = 0;
ComponentList<ModelComponent> comps = model.getComponentList<ModelComponent>();
comps.setFilter(myFilter);
for (const ModelComponent& comp : comps) {
cout << comp.getConcreteClassName() << ":" << comp.getFullPathName() << endl;
numModelComponentsWithStateVariables++;
}
//Now test a std::iterator method
ComponentList<Frame> allFrames = model.getComponentList<Frame>();
ComponentList<Frame>::const_iterator skipIter = allFrames.begin();
int countSkipFrames = 0;
while (skipIter != allFrames.end()){
cout << skipIter->getConcreteClassName() << ":" << skipIter->getFullPathName() << endl;
std::advance(skipIter, 2);
countSkipFrames++;
}
// TODO: Hard-coding these numbers is not ideal. As we introduce more components
// to recompose existing components, this will need continual updating. For example,
// Joint's often add PhysicalOffsetFrames to handle what used to be baked in location
// and orientation offsets.
ASSERT(numComponents == 130);
ASSERT(numBodies == model.getNumBodies());
ASSERT(numBodiesPost == numBodies);
ASSERT(numMuscles == model.getMuscles().getSize());
ASSERT(numJointsWithStateVariables == 2);
ASSERT(numModelComponentsWithStateVariables == 10);
// Below updated from 1 to 3 to account for offset frame and its geometry added to the Joint
ASSERT(numJntComponents == 3);
// Test using the iterator to skip over every other Component (Frame in this case)
// nf = 1 ground + 2 bodies + 2 joint offsets = 5, skipping - 2 = 3
ASSERT(countSkipFrames == 3);
}
catch (Exception &ex) {
ex.print(std::cout);
return 1;
}
cout << "Done" << endl;
return 0;
}
//---------------------------------------------------------------------------
bool Avatar::update(float deltaT)
{
if (_update(deltaT))
{
// we can't extract mount points from the derived avatar type
// until it's fully initialized, so we need to do this here in
// update() as opposed to in initialize()
// check components for an AnimationComponent
AnimationComponent* pAnim = 0;
if (findComponents(AnimationComponent::getClassDef(), (Component**)&pAnim))
{
// and then, if we have a valid animation blender...
AnimationBlender* pBlender = pAnim->getBlender();
if (pBlender)
{
// and then, if it has mounts but our mount data is empty...
size_t numMP = pBlender->getNumMountPoints();
if (numMP)
{
if (m_mountPoints.size() == 0)
{
// then we can fill in our data structure
for (size_t i=0; i<numMP; ++i)
{
const AnimationBlender::MountPointData* pData =
pBlender->getMountPoint(i);
MountPoint mp;
mp.m_index = i;
mp.m_boneIndex = pData->m_boneIndex;
mp.m_transform = pData->m_transform;
mp.m_pSlot = 0;
m_mountPoints[pData->m_name] = mp;
}
// now get a list of all of the EquipmentSlotComponents
// configured for us; we need to associate each component
// with a mount point
ComponentList list;
findComponents(EquipmentSlotComponent::getClassDef(), list);
for (ComponentList::iterator it=list.begin(); it != list.end(); ++it)
{
EquipmentSlotComponent* pSlot = static_cast<EquipmentSlotComponent*>(*it);
MountPoints::iterator mp = m_mountPoints.find(pSlot->getMountPoint());
if (mp != m_mountPoints.end())
mp->second.m_pSlot = pSlot;
else
{
// log a mismatch
String msg("Could not find mount point '");
msg += pSlot->getMountPoint();
msg += String("' in avatar: ");
msg += getName();
Environment::get().pLogger->logMessage(msg);
}
}
// and finally, clear up our mount backlog, if any
for (size_t i=0; i<m_delayedMounts.size(); ++i)
{
addToSlot(m_delayedMounts[i].pMountable, m_delayedMounts[i].slotId);
}
m_delayedMounts.clear();
}
else
{
// we can update our mount point transforms
for (size_t i=0; i<numMP; ++i)
{
const AnimationBlender::MountPointData* pData =
pBlender->getMountPoint(i);
MountPoints::iterator it = m_mountPoints.find(pData->m_name);
if (it != m_mountPoints.end())
{
it->second.m_transform = pData->m_transform;
it->second.m_pSlot->setTransform(pData->m_transform);
}
}
}
}
}
}
// update our mounted objects
for (MountPoints::iterator it = m_mountPoints.begin();
it != m_mountPoints.end(); ++it)
{
EquipmentSlotComponent* pComp = it->second.m_pSlot;
if (pComp)
{
size_t nEquip = pComp->getNumEquipment();
for (size_t j=0; j<nEquip; ++j)
{
Mountable* pMounted = pComp->getEquipment(j);
if (pMounted)
pMounted->update(deltaT);
}
}
}
// Avatars might have camera components too
CameraInterfaceComponent* pCamComp;
if (findComponents(
CameraInterfaceComponent::getClassDef(), (Component**)&pCamComp))
{
pCamComp->update(deltaT);
}
return ZoneObject::update(deltaT);
}
return false;
}
/**
* This method scales a model based on user-specified XYZ body scale factors
* and/or a set of marker-to-marker distance measurements.
*
* @param aModel the model to scale.
* @param aSubjectMass the final mass of the model after scaling.
* @return Whether the scaling process was successful or not.
*/
bool ModelScaler::processModel(Model* aModel, const string& aPathToSubject, double aSubjectMass)
{
if (!getApply()) return false;
int i;
ScaleSet theScaleSet;
Vec3 unity(1.0);
cout << endl << "Step 2: Scaling generic model" << endl;
ComponentList<PhysicalFrame> segments
= aModel->getComponentList<PhysicalFrame>();
ComponentList<PhysicalFrame>::const_iterator it = segments.begin();
/* Make a scale set with a Scale for each physical frame.
* Initialize all factors to 1.0.
*/
for (; it != segments.end(); ++it) {
Scale* segmentScale = new Scale();
segmentScale->setSegmentName(it->getName());
segmentScale->setScaleFactors(unity);
segmentScale->setApply(true);
theScaleSet.adoptAndAppend(segmentScale);
}
SimTK::State& s = aModel->initSystem();
aModel->getMultibodySystem().realize(s, SimTK::Stage::Position);
try
{
/* Make adjustments to theScaleSet, in the user-specified order. */
for (i = 0; i < _scalingOrder.getSize(); i++)
{
/* For measurements, measure the distance between a pair of markers
* in the model, and in the static pose. The latter divided by the
* former is the scale factor. Put that scale factor in theScaleSet,
* using the body/axis names specified in the measurement to
* determine in what place[s] to put the factor.
*/
if (_scalingOrder[i] == "measurements")
{
/* Load the static pose marker file, and convert units.
*/
MarkerData *markerData = 0;
if(!_markerFileName.empty() && _markerFileName!=PropertyStr::getDefaultStr()) {
markerData = new MarkerData(aPathToSubject + _markerFileName);
markerData->convertToUnits(aModel->getLengthUnits());
}
/* Now take and apply the measurements. */
for (int j = 0; j < _measurementSet.getSize(); j++)
{
if (_measurementSet.get(j).getApply())
{
if(!markerData)
throw Exception("ModelScaler.processModel: ERROR- "+_markerFileNameProp.getName()+
" not set but measurements are used",__FILE__,__LINE__);
double scaleFactor = computeMeasurementScaleFactor(s,*aModel, *markerData, _measurementSet.get(j));
if (!SimTK::isNaN(scaleFactor))
_measurementSet.get(j).applyScaleFactor(scaleFactor, theScaleSet);
else
cout << "___WARNING___: " << _measurementSet.get(j).getName() << " measurement not used to scale " << aModel->getName() << endl;
}
}
}
/* For manual scales, just copy the XYZ scale factors from
* the manual scale into theScaleSet.
*/
else if (_scalingOrder[i] == "manualScale")
{
for (int j = 0; j < _scaleSet.getSize(); j++)
{
if (_scaleSet[j].getApply())
{
const string& bodyName = _scaleSet[j].getSegmentName();
Vec3 factors(1.0);
_scaleSet[j].getScaleFactors(factors);
for (int k = 0; k < theScaleSet.getSize(); k++)
{
if (theScaleSet[k].getSegmentName() == bodyName)
theScaleSet[k].setScaleFactors(factors);
}
}
}
}
else
{
throw Exception("ModelScaler: ERR- Unrecognized string '"+_scalingOrder[i]+"' in "+_scalingOrderProp.getName()+" property (expecting 'measurements' or 'manualScale').",__FILE__,__LINE__);
}
}
/* Now scale the model. */
aModel->scale(s, theScaleSet, aSubjectMass, _preserveMassDist);
if(_printResultFiles) {
std::string savedCwd = IO::getCwd();
IO::chDir(aPathToSubject);
if (!_outputModelFileNameProp.getValueIsDefault())
{
if (aModel->print(_outputModelFileName))
cout << "Wrote model file " << _outputModelFileName << " from model " << aModel->getName() << endl;
}
if (!_outputScaleFileNameProp.getValueIsDefault())
{
if (theScaleSet.print(_outputScaleFileName))
cout << "Wrote scale file " << _outputScaleFileName << " for model " << aModel->getName() << endl;
}
IO::chDir(savedCwd);
}
}
catch (const Exception& x)
{
x.print(cout);
return false;
}
return true;
}
void scaleModelWithLigament()
{
// SET OUTPUT FORMATTING
IO::SetDigitsPad(4);
std::string setupFilePath("");
ScaleTool* scaleTool;
Model* model;
// Remove old model if any
FILE* file2Remove = IO::OpenFile(setupFilePath + "toyLigamentModelScaled.osim", "w");
fclose(file2Remove);
// Construct model and read parameters file
scaleTool = new ScaleTool("toyLigamentModel_Setup_Scale.xml");
// Keep track of the folder containing setup file, will be used to locate results to compare against
setupFilePath = scaleTool->getPathToSubject();
model = scaleTool->createModel();
if (!model) {
throw Exception("scale: ERROR- No model specified.",__FILE__,__LINE__);
//cout << "scale: ERROR- No model specified.";
}
SimTK::State& s = model->updWorkingState();
model->getMultibodySystem().realize(s, SimTK::Stage::Position);
ASSERT(!scaleTool->isDefaultModelScaler() && scaleTool->getModelScaler().getApply());
ModelScaler& scaler = scaleTool->getModelScaler();
ASSERT(scaler.processModel(model, setupFilePath, scaleTool->getSubjectMass()));
const std::string& scaledModelFile = scaler.getOutputModelFileName();
const std::string& std_scaledModelFile = "std_toyLigamentModelScaled.osim";
Model comp(scaledModelFile);
Model std(std_scaledModelFile);
std.print("std_toyLigamentModelScaled_latest.osim");
comp.print("comp_toyLigamentModelScaled_latest.osim");
// the latest model will not match the standard because the naming convention has
// been updated to store path names and connecting a model results in connectors
// storing relative paths so that collections of components are more portable.
// The models must be equivalent after being connected.
comp.setup();
std.setup();
ComponentList<Ligament> compLigs = comp.getComponentList<Ligament>();
ComponentList<Ligament> stdLigs = std.getComponentList<Ligament>();
ComponentList<Ligament>::const_iterator itc = compLigs.begin();
ComponentList<Ligament>::const_iterator its = stdLigs.begin();
for (; its != stdLigs.end() && itc != compLigs.end(); ++its, ++itc){
cout << "std:" << its->getName() << "==";
cout << "comp:" << itc->getName() << " : ";
cout << (*its == *itc) << endl;
ASSERT(*its == *itc, __FILE__, __LINE__,
"Scaled ligament " + its->getName() + " did not match standard.");
}
//Finally make sure we didn't incorrectly scale anything else in the model
ASSERT(std == comp);
delete model;
delete scaleTool;
}
//template <typename T>
void testComponent(const Component& instanceToTest)
{
// Empty model used to serve as the aggregate Component
Model model;
model.setName("TheModel");
// Make a copy so that we can modify the instance.
Component* instance = instanceToTest.clone();
const string& className = instance->getConcreteClassName();
cout << "\n**********************************************************\n";
cout << "* Testing " << className << endl;
cout << "**********************************************************" << endl;
// 1. Set properties to random values.
// -----------------------------------
cout << "Randomizing the component's properties." << endl;
randomize(instance);
// 2. Ensure that cloning produces an exact copy.
// ----------------------------------------------
// This will find missing calls to copyProperty_<name>().
testCloning(instance);
// 3. Serialize and de-serialize.
// ------------------------------
// This will find issues with de/serialization.
cout << "Serializing and deserializing component." << endl;
testSerialization(instance);
const size_t instanceSize = getCurrentRSS();
// 4. Verify Components structural attributes
// -------------------------------------------------------------------
cout << "Set up aggregate component." << endl;
// 5. Add this component to an aggregate component.
// ------------------------------------------------
addObjectAsComponentToModel(instance, model);
// 6. Connect up the aggregate; check that connections are correct.
// ----------------------------------------------------------------
// First make sure Connectors are satisfied.
Component* sub = instance;
ComponentList<Component> comps = instance->getComponentList<Component>();
ComponentList<Component>::const_iterator it = comps.begin();
while(sub) {
int nc = sub->getNumConnectors();
for (int i = 0; i < nc; ++i){
AbstractConnector& connector = sub->updConnector(i);
string dependencyTypeName = connector.getConnecteeTypeName();
cout << "Connector '" << connector.getName() <<
"' has dependency on: " << dependencyTypeName << endl;
Object* dependency =
Object::newInstanceOfType(dependencyTypeName);
if (dependency == nullptr){
// Get a concrete instance of a PhysicalFrame, which is a Body
if (dependencyTypeName == "PhysicalFrame"){
dependency = Object::newInstanceOfType("Body");
}
}
if (dependency) {
//give it some random values including a name
randomize(dependency);
connector.setConnecteeName(dependency->getName());
// add the dependency
addObjectAsComponentToModel(dependency, model);
}
}
const Component& next = *it;
//Now keep checking the subcomponents
sub = const_cast<Component *>(&next);
it++;
}
// This method calls connect().
cout << "Call Model::setup()." << endl;
try{
model.setup();
}
catch (const std::exception &x) {
cout << "testComponents::" << className << " unable to connect to model:" << endl;
cout << " '" << x.what() << "'" <<endl;
cout << "Error is likely due to " << className;
cout << " having structural dependencies that are not specified as Connectors.";
cout << endl;
}
// 7. Build the system.
// --------------------
SimTK::State initState;
try{
initState = model.initSystem();
}
catch (const std::exception &x) {
cout << "testComponents::" << className << " unable to initialize the system:" << endl;
cout << " '" << x.what() << "'" << endl;
cout << "Skipping ... " << endl;
}
// Outputs.
// --------
cout << "Invoking Output's." << endl;
for (auto it = instance->getOutputsBegin();
it != instance->getOutputsEnd(); ++it)
{
const std::string thisName = it->first;
const AbstractOutput* thisOutput = it->second.get();
cout << "Testing Output " << thisName << ", dependent on " <<
thisOutput->getDependsOnStage().getName() << endl;
// Start fresh.
SimTK::State state(initState);
// 8. Check that each output throws an exception if we're below its
// dependsOnStage. Model::initSystem() gives us a state that is already
// realized to Model.
if (thisOutput->getDependsOnStage() > SimTK::Stage::Model)
{
model.getSystem().realize(state,
thisOutput->getDependsOnStage().prev());
ASSERT_THROW(SimTK::Exception::StageTooLow,
thisOutput->getValueAsString(state);
);
}
