modelns.cc File Reference

#include "mbconfig.h"
#include <limits>
#include <cfloat>
#include "modelns.h"
#include "strnode.h"
#include "matvecexp.h"
#include "Rot.hh"

Include dependency graph for modelns.cc:

Go to the source code of this file.

Enumerations
enum	IDX_t {   IDX1 = 1, IDX2 = 2, IDX3 = 3, NORM,   SQUARE }
enum	when_t { CURR = 0, PREV = 1 }

Functions
static const char *	IDX2str (IDX_t IDX)
static const char *	when2str (when_t when)
template<IDX_t IDX, when_t when>
static int	position (const MathParser::MathArgs &args)
template<IDX_t IDX, when_t when>
static int	distance (const MathParser::MathArgs &args)
template<IDX_t IDX, when_t when>
static int	unitvec (const MathParser::MathArgs &args)
template<IDX_t IDX, when_t when>
static int	angle (const MathParser::MathArgs &args)
template<IDX_t IDX, when_t when>
static int	anglerel (const MathParser::MathArgs &args)
template<IDX_t IDX, when_t when>
static int	velocity (const MathParser::MathArgs &args)
template<IDX_t IDX, when_t when>
static int	vrel (const MathParser::MathArgs &args)
template<IDX_t IDX, when_t when>
static int	angvel (const MathParser::MathArgs &args)
template<IDX_t IDX, when_t when>
static int	angvrel (const MathParser::MathArgs &args)
template<bool p>
static int	drive (const MathParser::MathArgs &args)
static int	model_sf (const MathParser::MathArgs &args)
static int	model_node (const MathParser::MathArgs &args)
template<bool unique>
static int	model_elem (const MathParser::MathArgs &args)
static int	model_curr (const MathParser::MathArgs &args)

Enumeration Type Documentation

enum IDX_t

Enumerator
IDX1
IDX2
IDX3
NORM
SQUARE

Definition at line 43 of file modelns.cc.

           {
        IDX1 = 1,
        IDX2 = 2,
        IDX3 = 3,
        NORM,
        SQUARE
};

enum when_t

Enumerator
CURR
PREV

Definition at line 74 of file modelns.cc.

            {
        CURR = 0,
        PREV = 1
};

Function Documentation

template<IDX_t IDX, when_t when>

static int angle ( const MathParser::MathArgs &  args )

static

Definition at line 313 of file modelns.cc.

References ASSERT, MathParser::AT_INT, MathParser::AT_PRIVATE, MathParser::AT_REAL, CURR, StructNode::GetRCurr(), StructNode::GetRPrev(), IDX2str(), MBDYN_EXCEPT_ARGS, NORM, Vec3::Norm(), PREV, RotManip::VecRot(), and when2str().

{
        ASSERT(args.size() == 1 + 1 + 1);
        ASSERT(args[0]->Type() == MathParser::AT_REAL);
        ASSERT(args[1]->Type() == MathParser::AT_INT);
        ASSERT(args[2]->Type() == MathParser::AT_PRIVATE);

        MathParser::MathArgReal_t *out = dynamic_cast<MathParser::MathArgReal_t *>(args[0]);
        ASSERT(out != 0);

        MathParser::MathArgInt_t *arg1 = dynamic_cast<MathParser::MathArgInt_t *>(args[1]);
        ASSERT(arg1 != 0);
        ASSERT((*arg1)() >= 0);

        ModelNameSpace::MathArgDM *dm = dynamic_cast<ModelNameSpace::MathArgDM *>(args[2]);
        ASSERT(dm != 0);

        unsigned uLabel = unsigned((*arg1)());

        const StructNode *pNode = (*dm)()->pFindNode<const StructNode, Node::STRUCTURAL>(uLabel);
        if (pNode == 0) {
                silent_cerr("model::angle" << when2str(when) << IDX2str(IDX)
                                << "(" << uLabel << "): "
                                "unable to find StructNode(" << uLabel << ")"
                                << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        Vec3 phi;
        switch (when) {
        case CURR:
                phi = RotManip::VecRot(pNode->GetRCurr());
                break;

        case PREV:
                phi = RotManip::VecRot(pNode->GetRPrev());
                break;
        }

        switch (IDX) {
        case NORM:
                *out = phi.Norm();
                break;

        default:
                *out = phi(IDX);
                break;
        }

        return 0;
}

Here is the call graph for this function:

template<IDX_t IDX, when_t when>

static int anglerel ( const MathParser::MathArgs &  args )

static

Definition at line 370 of file modelns.cc.

References ASSERT, MathParser::AT_INT, MathParser::AT_PRIVATE, MathParser::AT_REAL, CURR, StructNode::GetRCurr(), StructNode::GetRPrev(), IDX2str(), MBDYN_EXCEPT_ARGS, Mat3x3::MulTM(), NORM, Vec3::Norm(), PREV, RotManip::VecRot(), and when2str().

{
        ASSERT(args.size() == 1 + 2 + 1);
        ASSERT(args[0]->Type() == MathParser::AT_REAL);
        ASSERT(args[1]->Type() == MathParser::AT_INT);
        ASSERT(args[2]->Type() == MathParser::AT_INT);
        ASSERT(args[3]->Type() == MathParser::AT_PRIVATE);

        MathParser::MathArgReal_t *out = dynamic_cast<MathParser::MathArgReal_t *>(args[0]);
        ASSERT(out != 0);

        MathParser::MathArgInt_t *arg1 = dynamic_cast<MathParser::MathArgInt_t *>(args[1]);
        ASSERT(arg1 != 0);
        ASSERT((*arg1)() >= 0);

        MathParser::MathArgInt_t *arg2 = dynamic_cast<MathParser::MathArgInt_t *>(args[2]);
        ASSERT(arg2 != 0);
        ASSERT((*arg2)() >= 0);

        ModelNameSpace::MathArgDM *dm = dynamic_cast<ModelNameSpace::MathArgDM *>(args[3]);
        ASSERT(dm != 0);

        unsigned uLabel1 = unsigned((*arg1)());
        unsigned uLabel2 = unsigned((*arg2)());

        const StructNode *pNode1 = (*dm)()->pFindNode<const StructNode, Node::STRUCTURAL>(uLabel1);
        if (pNode1 == 0) {
                silent_cerr("model::anglerel" << when2str(when) << IDX2str(IDX)
                                << "(" << uLabel1 << "," << uLabel2 << "): "
                                "unable to find StructNode(" << uLabel1 << ")"
                                << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        const StructNode *pNode2 = (*dm)()->pFindNode<const StructNode, Node::STRUCTURAL>(uLabel2);
        if (pNode2 == 0) {
                silent_cerr("model::anglerel" << when2str(when) << IDX2str(IDX)
                                << "(" << uLabel1 << "," << uLabel2 << "): "
                                "unable to find StructNode(" << uLabel2 << ")"
                                << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        Vec3 phi;
        switch (when) {
        case CURR:
                phi = RotManip::VecRot(pNode1->GetRCurr().MulTM(pNode2->GetRCurr()));
                break;

        case PREV:
                phi = RotManip::VecRot(pNode1->GetRPrev().MulTM(pNode2->GetRPrev()));
                break;
        }

        switch (IDX) {
        case NORM:
                *out = phi.Norm();
                break;

        default:
                *out = phi(IDX);
                break;
        }

        return 0;
}

Here is the call graph for this function:

template<IDX_t IDX, when_t when>

static int angvel ( const MathParser::MathArgs &  args )

static

Definition at line 579 of file modelns.cc.

References ASSERT, MathParser::AT_INT, MathParser::AT_PRIVATE, MathParser::AT_REAL, CURR, Vec3::Dot(), StructNode::GetWCurr(), StructNode::GetWPrev(), IDX2str(), MBDYN_EXCEPT_ARGS, NORM, Vec3::Norm(), PREV, SQUARE, and when2str().

{
        ASSERT(args.size() == 1 + 1 + 1);
        ASSERT(args[0]->Type() == MathParser::AT_REAL);
        ASSERT(args[1]->Type() == MathParser::AT_INT);
        ASSERT(args[2]->Type() == MathParser::AT_PRIVATE);

        MathParser::MathArgReal_t *out = dynamic_cast<MathParser::MathArgReal_t *>(args[0]);
        ASSERT(out != 0);

        MathParser::MathArgInt_t *arg1 = dynamic_cast<MathParser::MathArgInt_t *>(args[1]);
        ASSERT(arg1 != 0);
        ASSERT((*arg1)() >= 0);

        ModelNameSpace::MathArgDM *dm = dynamic_cast<ModelNameSpace::MathArgDM *>(args[2]);
        ASSERT(dm != 0);

        unsigned uLabel = unsigned((*arg1)());

        const StructNode *pNode = (*dm)()->pFindNode<const StructNode, Node::STRUCTURAL>(uLabel);
        if (pNode == 0) {
                silent_cerr("model::angvel" << when2str(when) << IDX2str(IDX)
                                << "(" << uLabel << "): "
                                "unable to find StructNode(" << uLabel << ")"
                                << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        Vec3 w;
        switch (when) {
        case CURR:
                w = pNode->GetWCurr();
                break;

        case PREV:
                w = pNode->GetWPrev();
                break;
        }

        switch (IDX) {
        case NORM:
                *out = w.Norm();
                break;

        case SQUARE:
                *out = w.Dot();
                break;

        default:
                *out = w(IDX);
                break;
        }

        return 0;
}

Here is the call graph for this function:

template<IDX_t IDX, when_t when>

static int angvrel ( const MathParser::MathArgs &  args )

static

Definition at line 640 of file modelns.cc.

References ASSERT, MathParser::AT_INT, MathParser::AT_PRIVATE, MathParser::AT_REAL, CURR, Vec3::Dot(), StructNode::GetWCurr(), StructNode::GetWPrev(), IDX2str(), MBDYN_EXCEPT_ARGS, NORM, Vec3::Norm(), PREV, SQUARE, and when2str().

{
        ASSERT(args.size() == 1 + 2 + 1);
        ASSERT(args[0]->Type() == MathParser::AT_REAL);
        ASSERT(args[1]->Type() == MathParser::AT_INT);
        ASSERT(args[2]->Type() == MathParser::AT_INT);
        ASSERT(args[3]->Type() == MathParser::AT_PRIVATE);

        MathParser::MathArgReal_t *out = dynamic_cast<MathParser::MathArgReal_t *>(args[0]);
        ASSERT(out != 0);

        MathParser::MathArgInt_t *arg1 = dynamic_cast<MathParser::MathArgInt_t *>(args[1]);
        ASSERT(arg1 != 0);
        ASSERT((*arg1)() >= 0);

        MathParser::MathArgInt_t *arg2 = dynamic_cast<MathParser::MathArgInt_t *>(args[2]);
        ASSERT(arg2 != 0);
        ASSERT((*arg2)() >= 0);

        ModelNameSpace::MathArgDM *dm = dynamic_cast<ModelNameSpace::MathArgDM *>(args[3]);
        ASSERT(dm != 0);

        unsigned uLabel1 = unsigned((*arg1)());
        unsigned uLabel2 = unsigned((*arg2)());

        const StructNode *pNode1 = (*dm)()->pFindNode<const StructNode, Node::STRUCTURAL>(uLabel1);
        if (pNode1 == 0) {
                silent_cerr("model::angvrel" << when2str(when) << IDX2str(IDX)
                                << "(" << uLabel1 << "," << uLabel2 << "): "
                                "unable to find StructNode(" << uLabel1 << ")"
                                << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        const StructNode *pNode2 = (*dm)()->pFindNode<const StructNode, Node::STRUCTURAL>(uLabel2);
        if (pNode2 == 0) {
                silent_cerr("model::angvrel" << when2str(when) << IDX2str(IDX)
                                << "(" << uLabel1 << "," << uLabel2 << "): "
                                "unable to find StructNode(" << uLabel2 << ")"
                                << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        Vec3 w;
        switch (when) {
        case CURR:
                w = pNode2->GetWCurr() - pNode1->GetWCurr();
                break;

        case PREV:
                w = pNode2->GetWPrev() - pNode1->GetWPrev();
                break;
        }

        switch (IDX) {
        case NORM:
                *out = w.Norm();
                break;

        case SQUARE:
                *out = w.Dot();
                break;

        default:
                *out = w(IDX);
                break;
        }

        return 0;
}

Here is the call graph for this function:

template<IDX_t IDX, when_t when>

static int distance ( const MathParser::MathArgs &  args )

static

Definition at line 160 of file modelns.cc.

References ASSERT, MathParser::AT_INT, MathParser::AT_PRIVATE, MathParser::AT_REAL, CURR, Vec3::Dot(), StructDispNode::GetXCurr(), StructDispNode::GetXPrev(), IDX2str(), MBDYN_EXCEPT_ARGS, NORM, Vec3::Norm(), PREV, SQUARE, and when2str().

{
        ASSERT(args.size() == 1 + 2 + 1);
        ASSERT(args[0]->Type() == MathParser::AT_REAL);
        ASSERT(args[1]->Type() == MathParser::AT_INT);
        ASSERT(args[2]->Type() == MathParser::AT_INT);
        ASSERT(args[3]->Type() == MathParser::AT_PRIVATE);

        MathParser::MathArgReal_t *out = dynamic_cast<MathParser::MathArgReal_t *>(args[0]);
        ASSERT(out != 0);

        MathParser::MathArgInt_t *arg1 = dynamic_cast<MathParser::MathArgInt_t *>(args[1]);
        ASSERT(arg1 != 0);
        ASSERT((*arg1)() >= 0);

        MathParser::MathArgInt_t *arg2 = dynamic_cast<MathParser::MathArgInt_t *>(args[2]);
        ASSERT(arg2 != 0);
        ASSERT((*arg2)() >= 0);

        ModelNameSpace::MathArgDM *dm = dynamic_cast<ModelNameSpace::MathArgDM *>(args[3]);
        ASSERT(dm != 0);

        unsigned uLabel1 = unsigned((*arg1)());
        unsigned uLabel2 = unsigned((*arg2)());

        const StructNode *pNode1 =  (*dm)()->pFindNode<const StructNode, Node::STRUCTURAL>(uLabel1);
        if (pNode1 == 0) {
                silent_cerr("model::distance" << when2str(when) << IDX2str(IDX)
                                << "(" << uLabel1 << "," << uLabel2 << "): "
                                "unable to find StructNode(" << uLabel1 << ")"
                                << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        const StructNode *pNode2 = (*dm)()->pFindNode<const StructNode, Node::STRUCTURAL>(uLabel2);
        if (pNode2 == 0) {
                silent_cerr("model::distance" << when2str(when) << IDX2str(IDX)
                                << "(" << uLabel1 << "," << uLabel2 << "): "
                                "unable to find StructNode(" << uLabel2 << ")"
                                << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        Vec3 d;
        switch (when) {
        case CURR:
                d = pNode2->GetXCurr() - pNode1->GetXCurr();
                break;

        case PREV:
                d = pNode2->GetXPrev() - pNode1->GetXPrev();
                break;
        }

        switch (IDX) {
        case NORM:
                *out = d.Norm();
                break;

        case SQUARE:
                *out = d.Dot();
                break;

        default:
                *out = d(IDX);
                break;
        }

        return 0;
}

Here is the call graph for this function:

template<bool p>

static int drive ( const MathParser::MathArgs &  args )

static

Definition at line 716 of file modelns.cc.

References MathParser::AF_CONST, ASSERT, MathParser::AT_INT, MathParser::AT_PRIVATE, MathParser::AT_REAL, DriveCaller::bIsDifferentiable(), DriveCaller::dGet(), DriveCaller::dGetP(), MathParser::MathArg_t::IsFlag(), and MBDYN_EXCEPT_ARGS.

{
        ASSERT(args.size() == 1 + 2 + 2);
        ASSERT(args[0]->Type() == MathParser::AT_REAL);
        ASSERT(args[1]->Type() == MathParser::AT_INT);
        ASSERT(args[2]->Type() == MathParser::AT_REAL);
        ASSERT(args[3]->Type() == MathParser::AT_PRIVATE);
        ASSERT(args[4]->Type() == MathParser::AT_PRIVATE);

        MathParser::MathArgReal_t *out = dynamic_cast<MathParser::MathArgReal_t *>(args[0]);
        ASSERT(out != 0);

        MathParser::MathArgReal_t *arg_val = dynamic_cast<MathParser::MathArgReal_t *>(args[2]);
        ASSERT(arg_val != 0);

        ModelNameSpace::MathArgDCPtr *arg_ptr = dynamic_cast<ModelNameSpace::MathArgDCPtr *>(args[3]);
        ASSERT(arg_ptr != 0);
        const DriveCaller *pDC = (*arg_ptr)();
        if (pDC == 0) {
                MathParser::MathArgInt_t *arg_label = dynamic_cast<MathParser::MathArgInt_t *>(args[1]);
                ASSERT(arg_label != 0);
                ASSERT((*arg_label)() >= 0);

                unsigned uLabel = unsigned((*arg_label)());

                ModelNameSpace::MathArgDM *arg_dm = dynamic_cast<ModelNameSpace::MathArgDM *>(args[4]);
                ASSERT(arg_dm != 0);

                pDC = (*arg_dm)()->GetMBDynParser().GetDrive(uLabel);
                if (pDC == 0) {
                        silent_cerr("model::drive(" << uLabel << ") not available"
                                << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

                if (p) {
                        if (!pDC->bIsDifferentiable()) {
                                silent_cerr("model::drivep(" << uLabel << ") not differentiable"
                                        << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }
                }

                if (arg_label->IsFlag(MathParser::AF_CONST)) {
                        (*arg_ptr)() = pDC;
                }
        }

        doublereal val = (*arg_val)();
        if (p) {
                ASSERT(pDC->bIsDifferentiable());

                *out = pDC->dGetP(val);

        } else {
                *out = pDC->dGet(val);
        }

        return 0;
}

Here is the call graph for this function:

static const char* IDX2str ( IDX_t  IDX )

static

Definition at line 52 of file modelns.cc.

References IDX1, IDX2, IDX3, MBDYN_EXCEPT_ARGS, NORM, and SQUARE.

Referenced by angle(), anglerel(), angvel(), angvrel(), distance(), position(), unitvec(), velocity(), and vrel().

{
        switch (IDX) {
        case NORM:
                return "";

        case SQUARE:
                return "2";

        case IDX1:
                return "<1>";

        case IDX2:
                return "<2>";

        case IDX3:
                return "<3>";
        }

        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
}

static int model_curr ( const MathParser::MathArgs &  args )

static

Definition at line 1061 of file modelns.cc.

References ASSERT, MathParser::AT_PRIVATE, MathParser::AT_REAL, MathParser::AT_STRING, ModelNameSpace::GetCurrData(), and MBDYN_EXCEPT_ARGS.

Referenced by ModelNameSpace::ModelNameSpace().

{
        ASSERT(args.size() == 1 + 1 + 2);

        ASSERT(args[0]->Type() == MathParser::AT_REAL);
        MathParser::MathArgReal_t *out = dynamic_cast<MathParser::MathArgReal_t *>(args[0]);
        ASSERT(out != 0);

        ASSERT(args[1]->Type() == MathParser::AT_STRING);
        MathParser::MathArgString_t *arg_name = dynamic_cast<MathParser::MathArgString_t *>(args[1]);
        ASSERT(arg_name != 0);
        const std::string& name = (*arg_name)();

        ASSERT(args[2]->Type() == MathParser::AT_PRIVATE);
        ModelNameSpace::MathArgMNS *arg_mns = dynamic_cast<ModelNameSpace::MathArgMNS *>(args[2]);
        ASSERT(arg_mns != 0);
        const ModelNameSpace *pMNS = (*arg_mns)();

        TypedValue value;
        if (!pMNS->GetCurrData(name, value)) {
                silent_cerr("model::current(" << name << ") not defined" << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        *out = value.GetReal();

        return 0;
}

Here is the call graph for this function:

template<bool unique>

static int model_elem ( const MathParser::MathArgs &  args )

static

Definition at line 934 of file modelns.cc.

References MathParser::AF_CONST, ASSERT, MathParser::AT_INT, MathParser::AT_PRIVATE, MathParser::AT_REAL, MathParser::AT_STRING, SimulationEntity::dGetPrivData(), SimulationEntity::iGetPrivDataIdx(), MathParser::MathArg_t::IsFlag(), MBDYN_EXCEPT_ARGS, MBDynParser::pDM, DataManager::pFindElem(), and psElemNames.

{
        ASSERT(args.size() == 1 + 2 - unique + 4);

        static const unsigned int out_idx = 0;
        static const unsigned int val_idx = 2 - (unique ? 1 : 0);
        static const unsigned int type_idx = 3 - (unique ? 1 : 0);
        static const unsigned int ptr_idx = 4 - (unique ? 1 : 0);
        static const unsigned int idx_idx = 5 - (unique ? 1 : 0);
        static const unsigned int dm_idx = 6 - (unique ? 1 : 0);

        ASSERT(args[out_idx]->Type() == MathParser::AT_REAL);
        MathParser::MathArgReal_t *out = dynamic_cast<MathParser::MathArgReal_t *>(args[out_idx]);
        ASSERT(out != 0);

        unsigned int idx = 0;
        ModelNameSpace::MathArgSEIdx *arg_idx = dynamic_cast<ModelNameSpace::MathArgSEIdx *>(args[idx_idx]);
        ASSERT(arg_idx != 0);

        ModelNameSpace::MathArgSEPtr *arg_ptr = dynamic_cast<ModelNameSpace::MathArgSEPtr *>(args[ptr_idx]);
        ASSERT(arg_ptr != 0);
        const SimulationEntity *pElem = (*arg_ptr)();

        if (pElem == 0) {
                unsigned uLabel(-1);
                bool bLabelConst(true);
                if (!unique) {
                        static const unsigned int label_idx = 1; // undefined if unique == true

                        ASSERT(args[label_idx]->Type() == MathParser::AT_INT);
                        MathParser::MathArgInt_t *arg_label = dynamic_cast<MathParser::MathArgInt_t *>(args[label_idx]);
                        ASSERT(arg_label != 0);
                        int iLabel = (*arg_label)();
                        if (iLabel < 0) {
                                silent_cerr("model::element: invalid element label " << iLabel << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }
                        uLabel = unsigned(iLabel);
                        bLabelConst = arg_label->IsFlag(MathParser::AF_CONST);
                }

                ASSERT(args[val_idx]->Type() == MathParser::AT_STRING);
                MathParser::MathArgString_t *arg_val = dynamic_cast<MathParser::MathArgString_t *>(args[val_idx]);
                ASSERT(arg_val != 0);
                std::string v = (*arg_val)();

                ASSERT(args[type_idx]->Type() == MathParser::AT_PRIVATE);
                ModelNameSpace::MathArgElem *arg_elem = dynamic_cast<ModelNameSpace::MathArgElem *>(args[type_idx]);
                ASSERT(arg_elem != 0);
                Elem::Type type = (*arg_elem)();

                ASSERT(args[dm_idx]->Type() == MathParser::AT_PRIVATE);
                ModelNameSpace::MathArgDM *arg_dm = dynamic_cast<ModelNameSpace::MathArgDM *>(args[dm_idx]);
                ASSERT(arg_dm != 0);
                const DataManager *pDM = (*arg_dm)();

                pElem = pDM->pFindElem(type, uLabel);
                if (pElem == 0) {
                        if (unique) {
                                silent_cerr("model::element: unable to find " << psElemNames[type] << std::endl);

                        } else {
                                silent_cerr("model::element: unable to find " << psElemNames[type] << "(" << uLabel << ")" << std::endl);
                        }
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

                idx = pElem->iGetPrivDataIdx(v.c_str());
                if (idx == 0) {
                        if (unique) {
                                silent_cerr("model::element: " << psElemNames[type] << ": invalid private data \"" << v << "\"" << std::endl);

                        } else {
                                silent_cerr("model::element: " << psElemNames[type] << "(" << dynamic_cast<const Elem *>(pElem)->GetLabel() << "): invalid private data \"" << v << "\"" << std::endl);
                        }
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

                if (unique || bLabelConst) {
                        (*arg_ptr)() = pElem;

                        /* NOTE: only set idx if element label is const,
                         * otherwise a different element could have a different idx
                         * for the same string */
                        if (arg_val->IsFlag(MathParser::AF_CONST)) {
                                (*arg_idx)() = idx;
                        }
                }

        } else {
                idx = (*arg_idx)();

                /* NOTE: pElem is saved, so we presume it was constant;
                 * apparently, idx was not constant, and we need to recompute it */
                if (idx == 0) {
                        ASSERT(!arg_idx->IsFlag(MathParser::AF_CONST));

                        MathParser::MathArgString_t *arg_val = dynamic_cast<MathParser::MathArgString_t *>(args[val_idx]);
                        ASSERT(arg_val != 0);
                        std::string v = (*arg_val)();

                        idx = pElem->iGetPrivDataIdx(v.c_str());
                        if (idx == 0) {
                                ModelNameSpace::MathArgElem *arg_type = dynamic_cast<ModelNameSpace::MathArgElem *>(args[type_idx]);
                                ASSERT(arg_type != 0);
                                Elem::Type type = (*arg_type)();

                                if (unique) {
                                        silent_cerr("model::element: " << psElemNames[type] << ": invalid private data \"" << v << "\"" << std::endl);
        
                                } else {
                                        silent_cerr("model::element: " << psElemNames[type] << "(" << dynamic_cast<const Elem *>(pElem)->GetLabel() << "): invalid private data \"" << v << "\"" << std::endl);
                                }
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }
                }
        }

        *out = pElem->dGetPrivData(idx);

        return 0;
}

Here is the call graph for this function:

static int model_node ( const MathParser::MathArgs &  args )

static

Definition at line 832 of file modelns.cc.

References MathParser::AF_CONST, ASSERT, MathParser::AT_INT, MathParser::AT_PRIVATE, MathParser::AT_REAL, MathParser::AT_STRING, SimulationEntity::dGetPrivData(), SimulationEntity::iGetPrivDataIdx(), MathParser::MathArg_t::IsFlag(), MBDYN_EXCEPT_ARGS, MBDynParser::pDM, DataManager::pFindNode(), and psNodeNames.

Referenced by ModelNameSpace::ModelNameSpace().

{
        ASSERT(args.size() == 1 + 2 + 4);
        ASSERT(args[0]->Type() == MathParser::AT_REAL);
        ASSERT(args[1]->Type() == MathParser::AT_INT);
        ASSERT(args[2]->Type() == MathParser::AT_STRING);
        ASSERT(args[3]->Type() == MathParser::AT_PRIVATE);
        ASSERT(args[4]->Type() == MathParser::AT_PRIVATE);
        ASSERT(args[5]->Type() == MathParser::AT_PRIVATE);
        ASSERT(args[6]->Type() == MathParser::AT_PRIVATE);

        MathParser::MathArgReal_t *out = dynamic_cast<MathParser::MathArgReal_t *>(args[0]);
        ASSERT(out != 0);

        unsigned int idx = 0;
        ModelNameSpace::MathArgSEIdx *arg_idx = dynamic_cast<ModelNameSpace::MathArgSEIdx *>(args[5]);
        ASSERT(arg_idx != 0);

        ModelNameSpace::MathArgSEPtr *arg_ptr = dynamic_cast<ModelNameSpace::MathArgSEPtr *>(args[4]);
        ASSERT(arg_ptr != 0);
        const SimulationEntity *pNode = (*arg_ptr)();

        if (pNode == 0) {
                MathParser::MathArgInt_t *arg_label = dynamic_cast<MathParser::MathArgInt_t *>(args[1]);
                ASSERT(arg_label != 0);
                int iLabel = (*arg_label)();

                MathParser::MathArgString_t *arg_val = dynamic_cast<MathParser::MathArgString_t *>(args[2]);
                ASSERT(arg_val != 0);
                std::string v = (*arg_val)();

                ModelNameSpace::MathArgNode *arg_type = dynamic_cast<ModelNameSpace::MathArgNode *>(args[3]);
                ASSERT(arg_type != 0);
                Node::Type type = (*arg_type)();

                ModelNameSpace::MathArgDM *arg_dm = dynamic_cast<ModelNameSpace::MathArgDM *>(args[6]);
                ASSERT(arg_dm != 0);
                const DataManager *pDM = (*arg_dm)();

                if (iLabel < 0) {
                        silent_cerr("model::node: invalid node label " << iLabel << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }
                unsigned uLabel = unsigned(iLabel);

                pNode = pDM->pFindNode(type, uLabel);
                if (pNode == 0) {
                        silent_cerr("model::node: unable to find " << psNodeNames[type] << "(" << uLabel << ")" << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

                idx = pNode->iGetPrivDataIdx(v.c_str());
                if (idx == 0) {
                        silent_cerr("model::node: " << psNodeNames[type] << "(" << dynamic_cast<const Node *>(pNode)->GetLabel() << "): invalid private data \"" << v << "\"" << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

                if (arg_label->IsFlag(MathParser::AF_CONST)) {
                        (*arg_ptr)() = pNode;

                        /* NOTE: only set idx if node label is const,
                         * otherwise a different node could have a different idx
                         * for the same string */
                        if (arg_val->IsFlag(MathParser::AF_CONST)) {
                                (*arg_idx)() = idx;
                        }
                }

        } else {
                idx = (*arg_idx)();

                /* NOTE: pNode is saved, so we presume it was constant;
                 * apparently, idx was not constant, and we need to recompute it */
                if (idx == 0) {
                        ASSERT(!arg_idx->IsFlag(MathParser::AF_CONST));

                        MathParser::MathArgString_t *arg_val = dynamic_cast<MathParser::MathArgString_t *>(args[2]);
                        ASSERT(arg_val != 0);
                        std::string v = (*arg_val)();

                        idx = pNode->iGetPrivDataIdx(v.c_str());
                        if (idx == 0) {
                                ModelNameSpace::MathArgNode *arg_type = dynamic_cast<ModelNameSpace::MathArgNode *>(args[3]);
                                ASSERT(arg_type != 0);
                                Node::Type type = (*arg_type)();

                                silent_cerr("model::node: " << psNodeNames[type] << "(" << dynamic_cast<const Node *>(pNode)->GetLabel() << "): invalid private data \"" << v << "\"" << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }
                }
        }

        *out = pNode->dGetPrivData(idx);

        return 0;
}

Here is the call graph for this function:

static int model_sf ( const MathParser::MathArgs &  args )

static

Definition at line 781 of file modelns.cc.

References ASSERT, MathParser::AT_INT, MathParser::AT_PRIVATE, MathParser::AT_REAL, DifferentiableScalarFunction::ComputeDiff(), MBDYN_EXCEPT_ARGS, and order.

Referenced by ModelNameSpace::ModelNameSpace().

{
        ASSERT(args.size() == 1 + 2 + 1);
        ASSERT(args[0]->Type() == MathParser::AT_REAL);
        ASSERT(args[1]->Type() == MathParser::AT_REAL);
        ASSERT(args[2]->Type() == MathParser::AT_INT);
        ASSERT(args[3]->Type() == MathParser::AT_PRIVATE);

        MathParser::MathArgReal_t *out = dynamic_cast<MathParser::MathArgReal_t *>(args[0]);
        ASSERT(out != 0);

        MathParser::MathArgReal_t *arg1 = dynamic_cast<MathParser::MathArgReal_t *>(args[1]);
        ASSERT(arg1 != 0);
        doublereal v = (*arg1)();

        MathParser::MathArgInt_t *arg2 = dynamic_cast<MathParser::MathArgInt_t *>(args[2]);
        ASSERT(arg2 != 0);
        int order = (*arg2)();
        ASSERT(order >= 0);

        ModelNameSpace::MathArgSF *sf = dynamic_cast<ModelNameSpace::MathArgSF *>(args[3]);
        ASSERT(sf != 0);

        if (order < 0 || order > 1) {
                silent_cerr("model::sf invalid derivative order " << order << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        if (order == 0) {
                *out = (*(*sf)())(v);

        } else {
                const DifferentiableScalarFunction *dsf = dynamic_cast<const DifferentiableScalarFunction *>((*sf)());
                if (dsf == 0) {
                        silent_cerr("model::sf "
                                "order=" << order << " only allowed "
                                "with differentiable scalar functions"
                                << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

                *out = dsf->ComputeDiff(v, order);
        }

        return 0;
}

Here is the call graph for this function:

template<IDX_t IDX, when_t when>

static int position ( const MathParser::MathArgs &  args )

static

Definition at line 99 of file modelns.cc.

References ASSERT, MathParser::AT_INT, MathParser::AT_PRIVATE, MathParser::AT_REAL, CURR, Vec3::Dot(), StructDispNode::GetXCurr(), StructDispNode::GetXPrev(), IDX2str(), MBDYN_EXCEPT_ARGS, NORM, Vec3::Norm(), PREV, SQUARE, and when2str().

{
        ASSERT(args.size() == 1 + 1 + 1);
        ASSERT(args[0]->Type() == MathParser::AT_REAL);
        ASSERT(args[1]->Type() == MathParser::AT_INT);
        ASSERT(args[2]->Type() == MathParser::AT_PRIVATE);

        MathParser::MathArgReal_t *out = dynamic_cast<MathParser::MathArgReal_t *>(args[0]);
        ASSERT(out != 0);

        MathParser::MathArgInt_t *arg1 = dynamic_cast<MathParser::MathArgInt_t *>(args[1]);
        ASSERT(arg1 != 0);
        ASSERT((*arg1)() >= 0);

        ModelNameSpace::MathArgDM *dm = dynamic_cast<ModelNameSpace::MathArgDM *>(args[2]);
        ASSERT(dm != 0);

        unsigned uLabel = unsigned((*arg1)());

        const StructNode *pNode = (*dm)()->pFindNode<const StructNode, Node::STRUCTURAL>(uLabel);
        if (pNode == 0) {
                silent_cerr("model::position" << when2str(when) << IDX2str(IDX)
                                << "(" << uLabel << "): "
                                "unable to find StructNode(" << uLabel << ")"
                                << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        Vec3 x;
        switch (when) {
        case CURR:
                x = pNode->GetXCurr();
                break;

        case PREV:
                x = pNode->GetXPrev();
                break;
        }

        switch (IDX) {
        case NORM:
                *out = x.Norm();
                break;

        case SQUARE:
                *out = x.Dot();
                break;

        default:
                *out = x(IDX);
                break;
        }

        return 0;
}

Here is the call graph for this function:

template<IDX_t IDX, when_t when>

static int unitvec ( const MathParser::MathArgs &  args )

static

Definition at line 236 of file modelns.cc.

References ASSERT, MathParser::AT_INT, MathParser::AT_PRIVATE, MathParser::AT_REAL, CURR, StructDispNode::GetXCurr(), StructDispNode::GetXPrev(), IDX2str(), MBDYN_EXCEPT_ARGS, Vec3::Norm(), PREV, and when2str().

{
        ASSERT(args.size() == 1 + 2 + 1);
        ASSERT(args[0]->Type() == MathParser::AT_REAL);
        ASSERT(args[1]->Type() == MathParser::AT_INT);
        ASSERT(args[2]->Type() == MathParser::AT_INT);
        ASSERT(args[3]->Type() == MathParser::AT_PRIVATE);

        MathParser::MathArgReal_t *out = dynamic_cast<MathParser::MathArgReal_t *>(args[0]);
        ASSERT(out != 0);

        MathParser::MathArgInt_t *arg1 = dynamic_cast<MathParser::MathArgInt_t *>(args[1]);
        ASSERT(arg1 != 0);
        ASSERT((*arg1)() >= 0);

        MathParser::MathArgInt_t *arg2 = dynamic_cast<MathParser::MathArgInt_t *>(args[2]);
        ASSERT(arg2 != 0);
        ASSERT((*arg2)() >= 0);

        ModelNameSpace::MathArgDM *dm = dynamic_cast<ModelNameSpace::MathArgDM *>(args[3]);
        ASSERT(dm != 0);

        unsigned uLabel1 = unsigned((*arg1)());
        unsigned uLabel2 = unsigned((*arg2)());

        const StructNode *pNode1 = (*dm)()->pFindNode<const StructNode, Node::STRUCTURAL>(uLabel1);
        if (pNode1 == 0) {
                silent_cerr("model::unitvec" << when2str(when) << IDX2str(IDX)
                                << "(" << uLabel1 << "," << uLabel2 << "): "
                                "unable to find StructNode(" << uLabel1 << ")"
                                << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        const StructNode *pNode2 = (*dm)()->pFindNode<const StructNode, Node::STRUCTURAL>(uLabel2);
        if (pNode2 == 0) {
                silent_cerr("model::unitvec" << when2str(when) << IDX2str(IDX)
                                << "(" << uLabel1 << "," << uLabel2 << "): "
                                "unable to find StructNode(" << uLabel2 << ")"
                                << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        Vec3 d;
        switch (when) {
        case CURR:
                d = pNode2->GetXCurr() - pNode1->GetXCurr();
                break;

        case PREV:
                d = pNode2->GetXPrev() - pNode1->GetXPrev();
                break;
        }

        doublereal dd = d.Norm();
        if (dd <= std::numeric_limits<doublereal>::epsilon()) {
                silent_cerr("model::unitvec" << when2str(when) << IDX2str(IDX)
                                << "(" << uLabel1 << "," << uLabel2 << "): "
                                "null distance"
                                << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        switch (IDX) {
        default:
                *out = d(IDX)/dd;
                break;
        }

        return 0;
}

Here is the call graph for this function:

template<IDX_t IDX, when_t when>

static int velocity ( const MathParser::MathArgs &  args )

static

Definition at line 442 of file modelns.cc.

References ASSERT, MathParser::AT_INT, MathParser::AT_PRIVATE, MathParser::AT_REAL, CURR, Vec3::Dot(), StructDispNode::GetVCurr(), StructDispNode::GetVPrev(), IDX2str(), MBDYN_EXCEPT_ARGS, NORM, Vec3::Norm(), PREV, SQUARE, and when2str().

{
        ASSERT(args.size() == 1 + 1 + 1);
        ASSERT(args[0]->Type() == MathParser::AT_REAL);
        ASSERT(args[1]->Type() == MathParser::AT_INT);
        ASSERT(args[2]->Type() == MathParser::AT_PRIVATE);

        MathParser::MathArgReal_t *out = dynamic_cast<MathParser::MathArgReal_t *>(args[0]);
        ASSERT(out != 0);

        MathParser::MathArgInt_t *arg1 = dynamic_cast<MathParser::MathArgInt_t *>(args[1]);
        ASSERT(arg1 != 0);
        ASSERT((*arg1)() >= 0);

        ModelNameSpace::MathArgDM *dm = dynamic_cast<ModelNameSpace::MathArgDM *>(args[2]);
        ASSERT(dm != 0);

        unsigned uLabel = unsigned((*arg1)());

        const StructNode *pNode = (*dm)()->pFindNode<const StructNode, Node::STRUCTURAL>(uLabel);
        if (pNode == 0) {
                silent_cerr("model::velocity" << when2str(when) << IDX2str(IDX)
                                << "(" << uLabel << "): "
                                "unable to find StructNode(" << uLabel << ")"
                                << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        Vec3 v;
        switch (when) {
        case CURR:
                v = pNode->GetVCurr();
                break;
        
        case PREV:
                v = pNode->GetVPrev();
                break;
        }
        
        switch (IDX) {
        case NORM:
                *out = v.Norm();
                break;

        case SQUARE:
                *out = v.Dot();
                break;

        default:
                *out = v(IDX);
                break;
        }

        return 0;
}

Here is the call graph for this function:

template<IDX_t IDX, when_t when>

static int vrel ( const MathParser::MathArgs &  args )

static

Definition at line 503 of file modelns.cc.

References ASSERT, MathParser::AT_INT, MathParser::AT_PRIVATE, MathParser::AT_REAL, CURR, Vec3::Dot(), StructDispNode::GetVCurr(), StructDispNode::GetVPrev(), IDX2str(), MBDYN_EXCEPT_ARGS, NORM, Vec3::Norm(), PREV, SQUARE, and when2str().

{
        ASSERT(args.size() == 1 + 2 + 1);
        ASSERT(args[0]->Type() == MathParser::AT_REAL);
        ASSERT(args[1]->Type() == MathParser::AT_INT);
        ASSERT(args[2]->Type() == MathParser::AT_INT);
        ASSERT(args[3]->Type() == MathParser::AT_PRIVATE);

        MathParser::MathArgReal_t *out = dynamic_cast<MathParser::MathArgReal_t *>(args[0]);
        ASSERT(out != 0);

        MathParser::MathArgInt_t *arg1 = dynamic_cast<MathParser::MathArgInt_t *>(args[1]);
        ASSERT(arg1 != 0);
        ASSERT((*arg1)() >= 0);

        MathParser::MathArgInt_t *arg2 = dynamic_cast<MathParser::MathArgInt_t *>(args[2]);
        ASSERT(arg2 != 0);
        ASSERT((*arg2)() >= 0);

        ModelNameSpace::MathArgDM *dm = dynamic_cast<ModelNameSpace::MathArgDM *>(args[3]);
        ASSERT(dm != 0);

        unsigned uLabel1 = unsigned((*arg1)());
        unsigned uLabel2 = unsigned((*arg2)());

        const StructNode *pNode1 = (*dm)()->pFindNode<const StructNode, Node::STRUCTURAL>(uLabel1);
        if (pNode1 == 0) {
                silent_cerr("model::vrel" << when2str(when) << IDX2str(IDX)
                                << "(" << uLabel1 << "," << uLabel2 << "): "
                                "unable to find StructNode(" << uLabel1 << ")"
                                << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        const StructNode *pNode2 = (*dm)()->pFindNode<const StructNode, Node::STRUCTURAL>(uLabel2);
        if (pNode2 == 0) {
                silent_cerr("model::vrel" << when2str(when) << IDX2str(IDX)
                                << "(" << uLabel1 << "," << uLabel2 << "): "
                                "unable to find StructNode(" << uLabel2 << ")"
                                << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        Vec3 v;
        switch (when) {
        case CURR:
                v = pNode2->GetVCurr() - pNode1->GetVCurr();
                break;

        case PREV:
                v = pNode2->GetVCurr() - pNode1->GetVPrev();
                break;
        }

        switch (IDX) {
        case NORM:
                *out = v.Norm();
                break;

        case SQUARE:
                *out = v.Dot();
                break;

        default:
                *out = v(IDX);
                break;
        }

        return 0;
}

Here is the call graph for this function:

static const char* when2str ( when_t  when )

static

Definition at line 80 of file modelns.cc.

References CURR, MBDYN_EXCEPT_ARGS, and PREV.

Referenced by angle(), anglerel(), angvel(), angvrel(), distance(), position(), unitvec(), velocity(), and vrel().

{
        switch (when) {
        case CURR:
                return "";

        case PREV:
                return "_prev";

        }

        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
}