body_vm.cc File Reference

#include "mbconfig.h"
#include <limits>
#include "body_vm.h"
#include "dataman.h"

Include dependency graph for body_vm.cc:

Go to the source code of this file.

Functions
Elem *	ReadVariableBody (DataManager *pDM, MBDynParser &HP, unsigned int uLabel, const StructNode *pStrNode)

Function Documentation

Elem* ReadVariableBody	(	DataManager *	pDM,
		MBDynParser &	HP,
		unsigned int	uLabel,
		const StructNode *	pStrNode
	)

Definition at line 1022 of file body_vm.cc.

References TplDriveCaller< T >::bIsDifferentiable(), DriveCaller::bIsDifferentiable(), DataManager::bIsInverseDynamics(), DataManager::bIsStaticModel(), Elem::BODY, DEBUGCOUTFNAME, DriveCaller::dGet(), StructNode::DYNAMIC, DataManager::fReadOutput(), TplDriveCaller< T >::Get(), MBDynParser::GetDriveCaller(), WithLabel::GetLabel(), IncludeParser::GetLineData(), DataManager::GetLogFile(), DynamicStructNode::GetStructNodeType(), StaticStructNode::GetStructNodeType(), MBDynParser::GetTplDriveCaller(), HighParser::IsArg(), MBDYN_EXCEPT_ARGS, MBDynParser::RF, SAFENEWWITHCONSTRUCTOR, and StructNode::STATIC.

Referenced by ReadBody().

{
        DEBUGCOUTFNAME("ReadVariableBody");

        /* may be determined by a special DataManager parameter... */
        bool bStaticModel = pDM->bIsStaticModel();
        bool bInverseDynamics = pDM->bIsInverseDynamics();

        ReferenceFrame RF(pStrNode);

        const DriveCaller *pDCMass = HP.GetDriveCaller();
        if (!pDCMass->bIsDifferentiable()) {
                silent_cerr("VariableBody(" << uLabel << "): "
                        "mass drive caller must be differentiable "
                        "at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        const TplDriveCaller<Vec3> *pDCXgc = HP.GetTplDriveCaller<Vec3>();
        if (!pDCXgc->bIsDifferentiable()) {
                silent_cerr("VariableBody(" << uLabel << "): "
                        "center of mass drive caller must be differentiable "
                        "at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        const TplDriveCaller<Mat3x3> *pDCJgc_vm = HP.GetTplDriveCaller<Mat3x3>();
        if (!pDCJgc_vm->bIsDifferentiable()) {
                silent_cerr("VariableBody(" << uLabel << "): "
                        "mass-related inertia matrix drive caller must be differentiable "
                        "at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        const TplDriveCaller<Mat3x3> *pDCJgc_vg = HP.GetTplDriveCaller<Mat3x3>();
        if (!pDCJgc_vg->bIsDifferentiable()) {
                silent_cerr("VariableBody(" << uLabel << "): "
                        "geometry-related inertia matrix drive caller must be differentiable "
                        "at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        const DynamicStructNode* pDynamicNode = 0;
        const StaticStructNode* pStaticNode = 0;

        if (bStaticModel || bInverseDynamics) {
                /* static */
                pStaticNode = dynamic_cast<const StaticStructNode *>(pStrNode);
                if (pStaticNode == 0 || pStaticNode->GetStructNodeType() != StructNode::STATIC) {
                        silent_cerr("VariableBody(" << uLabel << "): "
                                "illegal structural node type "
                                "for StructNode(" << pStrNode->GetLabel() << ") "
                                "in " << (bStaticModel ? "static model" : "inverse dynamics") << " analysis "
                                "at line " << HP.GetLineData() << std::endl);
                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

        } else {
                pDynamicNode = dynamic_cast<const DynamicStructNode*>(pStrNode);
                if (pDynamicNode == 0 || pDynamicNode->GetStructNodeType() != StructNode::DYNAMIC) {
                        silent_cerr("VariableBody(" << uLabel << "): "
                                "illegal structural node type "
                                "for StructNode(" << pStrNode->GetLabel() << ") "
                                "at line " << HP.GetLineData() << std::endl);
                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                }
        }

        flag fOut = pDM->fReadOutput(HP, Elem::BODY);

        /* Allocazione e costruzione */
        Elem *pEl = 0;
        if (bStaticModel || bInverseDynamics) {
                /* static */
                SAFENEWWITHCONSTRUCTOR(pEl, StaticVariableBody,
                        StaticVariableBody(uLabel, pStaticNode,
                                pDCMass, pDCXgc, pDCJgc_vm, pDCJgc_vg, fOut));

        } else {
                SAFENEWWITHCONSTRUCTOR(pEl, DynamicVariableBody,
                        DynamicVariableBody(uLabel, pDynamicNode,
                                pDCMass, pDCXgc, pDCJgc_vm, pDCJgc_vg, fOut));
        }

        pDM->GetLogFile()
                << "variable body: " << uLabel
                << ' ' << pStrNode->GetLabel()
                << ' ' << pDCMass->dGet()
                << ' ' << pDCXgc->Get()
                << ' ' << pDCJgc_vm->Get()
                << ' ' << pDCJgc_vg->Get()
                << std::endl;

        /* Se non c'e' il punto e virgola finale */
        if (HP.IsArg()) {
                silent_cerr("VariableBody(" << uLabel << "): semicolon expected "
                        "at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        return pEl;
} /* End of ReadVariableBody() */

Here is the call graph for this function: