dataman3.cc File Reference

#include "mbconfig.h"
#include <limits>
#include <unistd.h>
#include <cfloat>
#include "dataman.h"
#include "dataman_.h"
#include "modules.h"
#include "readlinsol.h"
#include "drive.h"
#include "drive_.h"
#include "filedrv.h"
#include "presnode.h"
#include "j2p.h"
#include "sah.h"
#include "thermalnode.h"
#include "aeroelem.h"
#include "beam.h"
#include "rbk_impl.h"

Include dependency graph for dataman3.cc:

Go to the source code of this file.

Classes
class	NotAllowed

Functions
static int	GetDofOrder (MBDynParser &HP, Node *pNode, int iIndex)
ScalarDof	ReadScalarDof (const DataManager *pDM, MBDynParser &HP, bool bDof, bool bOrder)
OrientationDescription	ReadOrientationDescription (MBDynParser &HP)
OrientationDescription	ReadOptionalOrientationDescription (DataManager *pDM, MBDynParser &HP)

Function Documentation

static int GetDofOrder ( MBDynParser &  HP, Node *  pNode, int  iIndex  )

static

Definition at line 2360 of file dataman3.cc.

References StructDispNode::ComputeAccelerations(), DofOrder::DIFFERENTIAL, SimulationEntity::GetDofType(), HighParser::GetInt(), WithLabel::GetLabel(), IncludeParser::GetLineData(), Node::GetNodeType(), HighParser::IsKeyWord(), MBDYN_EXCEPT_ARGS, and psNodeNames.

Referenced by ReadScalarDof().

{
        /*
         * Ordine del grado di liberta' da considerare
         * (stato, oppure derivata se esiste)
         */
        int iOrder = 0;

        if (HP.IsKeyWord("differential")) {
                iOrder = 1;

        } else if (HP.IsKeyWord("order")) {
                iOrder = HP.GetInt();
                if (iOrder < 0 || iOrder > 2) {
                        silent_cerr(psNodeNames[pNode->GetNodeType()]
                                << "(" << pNode->GetLabel() << "): "
                                "illegal order " << iOrder
                                << " at line " << HP.GetLineData()
                                << std::endl);
                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);

                } else if (iOrder == 2) {
                        DynamicStructNode *pStrNode = dynamic_cast<DynamicStructNode *>(pNode);
                        if (pStrNode == 0) {
                                silent_cerr(psNodeNames[pNode->GetNodeType()]
                                        << "(" << pNode->GetLabel() << "): "
                                        "order " << iOrder << " not allowed "
                                        "at line " << HP.GetLineData()
                                        << std::endl);
                                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }
                        pStrNode->ComputeAccelerations(true);
                }
        }

        if (iOrder > 0) {
                if (pNode->GetDofType(iIndex-1) != DofOrder::DIFFERENTIAL) {
                        silent_cerr(psNodeNames[pNode->GetNodeType()]
                                << "(" << pNode->GetLabel()
                                << "): invalid order for index " << iIndex
                                << " variable at line " << HP.GetLineData()
                                << std::endl);
                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                }
                return iOrder;
        }

        if (HP.IsKeyWord("algebraic")) {
                return 0;
        } /* else */

        silent_cerr(psNodeNames[pNode->GetNodeType()]
                << "(" << pNode->GetLabel()
                << "): unknown or illegal order for index " << iIndex << std::endl
                << "(hint: you may need to specify "
                "\"differential\" or \"algebraic\" or \"order <n>\" when referencing " << std::endl
                << "a generic degree of freedom at line "
                << HP.GetLineData() << ")" << std::endl);

        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
}

Here is the call graph for this function:

OrientationDescription ReadOptionalOrientationDescription	(	DataManager *	pDM,
		MBDynParser &	HP
	)

Definition at line 2531 of file dataman3.cc.

References EULER_123, IncludeParser::GetLineData(), DataManager::GetOrientationDescription(), HighParser::IsKeyWord(), ReadOrientationDescription(), and UNKNOWN_ORIENTATION_DESCRIPTION.

Referenced by ReadAerodynamicCustomOutput(), ReadBeamCustomOutput(), ReadStructNode(), and MBDynParser::Reference_int().

{
        OrientationDescription dod = UNKNOWN_ORIENTATION_DESCRIPTION;

        if (HP.IsKeyWord("orientation" "description")) {
                dod = ReadOrientationDescription(HP);

        } else if (pDM != 0) {
                /* get a sane default */
                dod = pDM->GetOrientationDescription();

        } else {
                dod = EULER_123;
                silent_cerr("Warning, data manager not defined yet, "
                        "using default orientation (\"euler 123\") "
                        "at line " << HP.GetLineData() << std::endl);
        }

        return dod;
}

Here is the call graph for this function:

OrientationDescription ReadOrientationDescription

(

MBDynParser &

HP

)

Definition at line 2502 of file dataman3.cc.

References EULER_123, EULER_313, EULER_321, IncludeParser::GetLineData(), HighParser::IsKeyWord(), MBDYN_EXCEPT_ARGS, ORIENTATION_MATRIX, ORIENTATION_VECTOR, and UNKNOWN_ORIENTATION_DESCRIPTION.

Referenced by Eu2PhiDCR::Read(), DataManager::ReadControl(), and ReadOptionalOrientationDescription().

{
        OrientationDescription dod = UNKNOWN_ORIENTATION_DESCRIPTION;

        if (HP.IsKeyWord("euler" "123")) {
                dod = EULER_123;

        } else if (HP.IsKeyWord("euler" "313")) {
                dod = EULER_313;

        } else if (HP.IsKeyWord("euler" "321")) {
                dod = EULER_321;

        } else if (HP.IsKeyWord("orientation" "vector")) {
                dod = ORIENTATION_VECTOR;

        } else if (HP.IsKeyWord("orientation" "matrix")) {
                dod = ORIENTATION_MATRIX;

        } else {
                silent_cerr("Unknown orientation description "
                        "at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        return dod;
}

Here is the call graph for this function:

ScalarDof ReadScalarDof	(	const DataManager *	pDM,
		MBDynParser &	HP,
		bool	bDof,
		bool	bOrder
	)

Definition at line 2423 of file dataman3.cc.

References DEBUGLCOUT, DofOrder::DIFFERENTIAL, GetDofOrder(), SimulationEntity::GetDofType(), HighParser::GetInt(), IncludeParser::GetLineData(), HighParser::GetWord(), SimulationEntity::iGetNumDof(), MBDYN_EXCEPT_ARGS, MYDEBUG_INPUT, DataManager::pFindNode(), psNodeNames, psReadNodesNodes, SAFENEWWITHCONSTRUCTOR, and Node::UNKNOWN.

Referenced by DofDCR::Read(), ReadBulk(), ReadElectric(), ReadForce(), ReadGenel(), DataManager::ReadNodes(), and ReadScalarValue().

{
        /* tabella delle parole chiave */
        KeyTable KDof(HP, psReadNodesNodes);

        /* Label del nodo */
        int iNode = HP.GetInt();
        if (iNode < 0) {
                silent_cerr("ReadScalarDof: invalid node label " << iNode
                        << " at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        unsigned uNode = unsigned(iNode);
        DEBUGLCOUT(MYDEBUG_INPUT, "Linked to Node " << uNode << std::endl);

        /* Tipo del nodo */
        Node::Type Type = Node::Type(HP.GetWord());
        if (Type == Node::UNKNOWN) {
                silent_cerr("ReadScalarDof: unknown node type "
                        "at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }
        DEBUGLCOUT(MYDEBUG_INPUT, "Node type: " << psNodeNames[Type] << std::endl);

        /* verifica di esistenza del nodo */
        Node* pNode = pDM->pFindNode(Type, uNode);
        if (pNode == 0) {
                silent_cerr(psNodeNames[Type] << "(" << uNode << ") not defined"
                        " at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        /* si procura il numero di dof del nodo */
        unsigned int iMaxIndex = pNode->iGetNumDof();
        DEBUGLCOUT(MYDEBUG_INPUT, "max index: " << iMaxIndex << std::endl);

        if (bDof && iMaxIndex == 0) {
                silent_cerr(psNodeNames[Type] << "(" << uNode << ") must have dofs "
                        "at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        /* se il nodo ha piu' di un dof, chiede quale dof si desidera */
        unsigned int iIndex = 1;
        if (iMaxIndex > 1) {
                iIndex = HP.GetInt();
                if (iIndex < 1 || iIndex > iMaxIndex) {
                        silent_cerr("Illegal index " << iIndex << ", "
                                << psNodeNames[Type] << "(" << uNode << ") "
                                "has only " << iMaxIndex << " dofs "
                                "at line " << HP.GetLineData() << std::endl);
                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                }
                DEBUGLCOUT(MYDEBUG_INPUT, "index: " << iIndex << std::endl);
        }

        /* se e' richiesto l'order del dof e se il dof e' differenziale ... */
        int iOrder = 0;
        if (bOrder && pNode->iGetNumDof() > 0
                && pNode->GetDofType(iIndex-1) == DofOrder::DIFFERENTIAL)
        {
                iOrder = GetDofOrder(HP, pNode, iIndex);
        }
        DEBUGLCOUT(MYDEBUG_INPUT, "order: " << iOrder << std::endl);

        /* se il nodo non e' scalare, alloca un Node2Scalar che lo wrappa */
        if (iMaxIndex > 1) {
                NodeDof nd(iIndex - 1, pNode);

                pNode = 0;
                /* Chi dealloca questa memoria? ci vorrebbe l'handle */
                SAFENEWWITHCONSTRUCTOR(pNode, Node2Scalar, Node2Scalar(nd));
        }

        return ScalarDof(dynamic_cast<ScalarNode *>(pNode), iOrder, iIndex);
}

Here is the call graph for this function: