modalext.h File Reference

#include <vector>
#include <string>
#include "extforce.h"
#include "modal.h"

Include dependency graph for modalext.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	ExtModalForceBase
class	ExtModalForce
class	ModalExt

Functions
Elem *	ReadModalExtForce (DataManager *pDM, MBDynParser &HP, unsigned int uLabel)

Function Documentation

Elem* ReadModalExtForce	(	DataManager *	pDM,
		MBDynParser &	HP,
		unsigned int	uLabel
	)

Definition at line 589 of file modalext.cc.

References ASSERT, ExtModalForceBase::EMF_ALL, ExtModalForceBase::EMF_MODAL, ExtModalForceBase::EMF_RIGID, Elem::FORCE, DataManager::fReadOutput(), IncludeParser::GetLineData(), HighParser::IsArg(), HighParser::IsKeyWord(), Elem::JOINT, MBDYN_EXCEPT_ARGS, Modal::pGetModalNode(), DataManager::ReadElem(), ReadExtForce(), DataManager::ReadNode(), SAFENEW, SAFENEWWITHCONSTRUCTOR, and Node::STRUCTURAL.

Referenced by ReadForce().

{
        ExtFileHandlerBase *pEFH;
        int iCoupling;

        bool bSendAfterPredict;
        ReadExtForce(pDM, HP, uLabel, pEFH, bSendAfterPredict, iCoupling);

        const StructNode *pNode = 0;
        const Modal *pModal = 0;
        if (HP.IsKeyWord("reference" "node")) {
                pNode = pDM->ReadNode<const StructNode, Node::STRUCTURAL>(HP);

        } else {
                pModal = pDM->ReadElem<const Modal, Elem::JOINT>(HP);
                pNode = pModal->pGetModalNode();
        }

        bool bOutputAccelerations(false);
        if (HP.IsKeyWord("accelerations")) {
                bOutputAccelerations = true;
        }

        // safe default: both rigid and modal, if possible
        ExtModalForceBase::BitMask bm = ExtModalForceBase::EMF_ALL;
        if (pNode == 0) {
                bm = ExtModalForceBase::EMF_MODAL;
                
        } else if (pModal == 0) {
                bm = ExtModalForceBase::EMF_RIGID;
        }

        if (HP.IsKeyWord("type")) {
                if (HP.IsKeyWord("rigid")) {
                        bm = ExtModalForceBase::EMF_RIGID;
                } else if (HP.IsKeyWord("modal")) {
                        bm = ExtModalForceBase::EMF_MODAL;
                } else if (HP.IsKeyWord("all")) {
                        bm = ExtModalForceBase::EMF_ALL;
                } else {
                        silent_cerr("ModalExt(" << uLabel << "): unknown ModalExt type "
                                " at line " << HP.GetLineData() << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }
        }

        if ((bm & ExtModalForceBase::EMF_RIGID) && pNode == 0) {
                silent_cerr("ModalExt(" << uLabel << "): \"rigid\" needs rigid body motion "
                        "at line " << HP.GetLineData() << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        if ((bm & ExtModalForceBase::EMF_MODAL) && pModal == 0) {
                silent_cerr("ModalExt(" << uLabel << "): \"modal\" needs modal joint "
                        "at line " << HP.GetLineData() << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        ExtModalForceBase *pEMF = 0;
        if (dynamic_cast<ExtFileHandlerEDGE *>(pEFH) != 0) {
                // EDGE needs two separate ModalExt elements,
                // one for the rigid part and one for the modal part

                switch (bm & ExtModalForceBase::EMF_ALL) {
                case ExtModalForceBase::EMF_RIGID:
                        SAFENEWWITHCONSTRUCTOR(pEMF, ExtRigidForceEDGE,
                                ExtRigidForceEDGE(pDM));
                        break;

                case ExtModalForceBase::EMF_MODAL:
                        SAFENEWWITHCONSTRUCTOR(pEMF, ExtModalForceEDGE,
                                ExtModalForceEDGE(pDM));
                        break;

                case ExtModalForceBase::EMF_ALL:
                        silent_cerr("ModalExt(" << uLabel << "): "
                                "EDGE ExtFileHandler can only be used "
                                "when ModalExt is either \"rigid\" "
                                "or \"modal\" but not when it is \"all\" "
                                " at line " << HP.GetLineData() << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);

                default:
                        ASSERT(0);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

        // add more types if specific behavior is needed

        } else {
                // ExtFileHandler
                // ExtSocketHandler

                // wild guess: the default is fine
                SAFENEW(pEMF, ExtModalForce);
        }

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

        if (HP.IsArg()) {
                silent_cerr("ModalExt(" << uLabel << "): "
                        "semicolon expected at line "
                        << HP.GetLineData() << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        Elem *pEl = 0;
        SAFENEWWITHCONSTRUCTOR(pEl, ModalExt,
                ModalExt(uLabel, pDM, pModal, pNode, bOutputAccelerations,
                        pEFH, pEMF, bSendAfterPredict, iCoupling, bm, fOut));

        return pEl;
}

Here is the call graph for this function: