ExtModalForceEDGE Class Reference

#include <modaledge.h>

Inheritance diagram for ExtModalForceEDGE:

Collaboration diagram for ExtModalForceEDGE:

Public Member Functions
	ExtModalForceEDGE (DataManager *pDM)
unsigned	Recv (ExtFileHandlerBase *pEFH, unsigned uFlags, unsigned &uLabel, Vec3 &f, Vec3 &m, std::vector< doublereal > &a)
void	Send (ExtFileHandlerBase *pEFH, unsigned uFlags, unsigned uLabel, const Vec3 &x, const Mat3x3 &R, const Vec3 &v, const Vec3 &w, const std::vector< doublereal > &q, const std::vector< doublereal > &qP)
Public Member Functions inherited from ExtForceEDGE
	ExtForceEDGE (DataManager *pDM)
virtual	~ExtForceEDGE (void)
bool	Prepare (ExtFileHandlerBase *pEFH, unsigned uLabel, bool bRigid, unsigned uModes)
Public Member Functions inherited from ExtModalForceBase
virtual	~ExtModalForceBase (void)

Additional Inherited Members
Public Types inherited from ExtModalForceBase
enum	BitMask {   EMF_NONE = 0x0U, EMF_RIGID = 0x1U, EMF_MODAL = 0x2U, EMF_ALL = (EMF_RIGID | EMF_MODAL),   EMF_RIGID_DETECT = 0x10U, EMF_MODAL_DETECT = 0x20U, EMF_RIGID_DETECT_MASK = (EMF_RIGID_DETECT | EMF_RIGID), EMF_MODAL_DETECT_MASK = (EMF_MODAL_DETECT | EMF_MODAL),   EMF_DETECT_MASK = (EMF_RIGID_DETECT | EMF_MODAL_DETECT), EMF_ERR = 0x10000000U }
Protected Attributes inherited from ExtForceEDGE
const AirProperties *	pAP

Detailed Description

Definition at line 77 of file modaledge.h.

Constructor & Destructor Documentation

ExtModalForceEDGE::ExtModalForceEDGE

(

DataManager *

pDM

)

Definition at line 286 of file modaledge.cc.

References NO_OP.

: ExtForceEDGE(pDM)
{
        NO_OP;
}

Member Function Documentation

unsigned ExtModalForceEDGE::Recv ( ExtFileHandlerBase *  pEFH, unsigned  uFlags, unsigned &  uLabel, Vec3 &  f, Vec3 &  m, std::vector< doublereal > &  a  )

virtual

Implements ExtModalForceBase.

Definition at line 301 of file modaledge.cc.

References ASSERT, buf, ExtModalForceBase::EMF_ALL, ExtModalForceBase::EMF_MODAL, ExtModalForceBase::EMF_MODAL_DETECT_MASK, ExtModalForceBase::EMF_NONE, ExtFileHandlerBase::GetInStream(), MBDYN_EXCEPT_ARGS, mbedge_eat_field(), mbedge_eat_sep(), mbedge_goto_eol(), and STRLENOF.

{
        std::istream& fin = *pEFH->GetInStream();
        unsigned uOutFlags = ExtModalForceBase::EMF_NONE;

        ASSERT((uFlags & ExtModalForceBase::EMF_MODAL) != 0);
        ASSERT((uFlags & ~ExtModalForceBase::EMF_ALL) == 0);

        // fake
        uLabel = 0;

        // cycle
        unsigned lineno = 0;
        while (true) {
                char buf[BUFSIZ], *p;
                if (mbedge_goto_eol(fin, buf, sizeof(buf))) {
                        if (!fin) {
                                break;
                        }
                }

                lineno++;

                if (buf[0] == '*') {
                        continue;
                }

                if (strncasecmp(buf, "modal_force_flow", STRLENOF("modal_force_flow")) == 0) {
                        p = buf + STRLENOF("modal_force_flow");

                        size_t buflen = sizeof(buf) - STRLENOF("modal_force_flow");
                        p = &buf[0] + STRLENOF("modal_force_flow");

                        p = mbedge_eat_sep(p, buflen);
                        if (p == 0) {
                                silent_cerr("ExtModalForceEDGE: unable to skip separator "
                                        "at line=" << lineno << ", \"" << buf[sizeof(buf) - buflen] << "\"" << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }

                        p = mbedge_eat_field(p, buflen, "R");
                        if (p == 0) {
                                silent_cerr("ExtModalForceEDGE: unable to skip field \"R\" "
                                        "at line=" << lineno << ", \"" << buf[sizeof(buf) - buflen] << "\"" << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }

                        p = mbedge_eat_sep(p, buflen);
                        if (p == 0) {
                                silent_cerr("ExtModalForceEDGE: unable to skip separator "
                                        "at line=" << lineno << ", \"" << buf[sizeof(buf) - buflen] << "\"" << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }

                        char *next;
                        errno = 0;
                        long nmodes = strtol(p, &next, 10);
                        int save_errno = errno;
                        if (next == p) {
                                silent_cerr("ExtModalForceEDGE: unable to skip modes number field "
                                        "at line=" << lineno << ", \"" << buf[sizeof(buf) - buflen] << "\"" << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);

                        } else if (save_errno == ERANGE) {
                                silent_cerr("ExtModalForceEDGE: modes number field overflows "
                                        "at line=" << lineno << ", \"" << buf[sizeof(buf) - buflen] << "\"" << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }

                        p = mbedge_eat_sep(next, buflen);
                        if (p == 0) {
                                silent_cerr("ExtModalForceEDGE: unable to skip separator "
                                        "at line=" << lineno << ", \"" << buf[sizeof(buf) - buflen] << "\"" << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }

                        p = mbedge_eat_field(p, buflen, "1");
                        if (p == 0) {
                                silent_cerr("ExtModalForceEDGE: unable to skip field \"1\" "
                                        "at line=" << lineno << ", \"" << buf[sizeof(buf) - buflen] << "\"" << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }

                        p = mbedge_eat_sep(p, buflen);
                        if (p == 0) {
                                silent_cerr("ExtModalForceEDGE: unable to skip separator "
                                        "at line=" << lineno << ", \"" << buf[sizeof(buf) - buflen] << "\"" << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }

                        p = mbedge_eat_field(p, buflen, "0");
                        if (p == 0) {
                                silent_cerr("ExtModalForceEDGE: unable to skip field \"0\" "
                                        "at line=" << lineno << ", \"" << buf[sizeof(buf) - buflen] << "\"" << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }

                        p = mbedge_eat_sep(p, buflen);
                        if (p == 0) {
                                silent_cerr("ExtModalForceEDGE: unable to skip separator "
                                        "at line=" << lineno << ", \"" << buf[sizeof(buf) - buflen] << "\"" << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }

                        if (p[0] != '\0' && p[0] != '\n') {
                                silent_cerr("ExtModalForceEDGE: no line terminator "
                                        "at line=" << lineno << ", \"" << p << "\"" << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }

                        if (std::vector<doublereal>::size_type(nmodes) != a.size()) {
                                silent_cerr("ExtModalForceEDGE: mode number mismatch, "
                                        "expected " << a.size() << " got " << nmodes << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }

                        if (uFlags & ExtModalForceBase::EMF_MODAL_DETECT_MASK) {
                                for (std::vector<doublereal>::iterator i = a.begin();
                                        i != a.end(); ++i)
                                {
                                        fin >> *i;
                                }

                                uOutFlags |= (uFlags & ExtModalForceBase::EMF_MODAL_DETECT_MASK);
                        }

                        // skip to eol
                        if (mbedge_goto_eol(fin, buf, sizeof(buf))) {
                                silent_cerr("ExtModalForceEDGE: unable to skip to end of line "
                                        "at line=" << lineno << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }
                        continue;
                }

                silent_cerr("ExtModalForceEDGE: unexpected line=" << lineno << ", "
                        "\"" << buf << "\"" << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        return uOutFlags;
}

Here is the call graph for this function:

void ExtModalForceEDGE::Send ( ExtFileHandlerBase *  pEFH, unsigned  uFlags, unsigned  uLabel, const Vec3 &  x, const Mat3x3 &  R, const Vec3 &  v, const Vec3 &  w, const std::vector< doublereal > &  q, const std::vector< doublereal > &  qP  )

virtual

Implements ExtModalForceBase.

Definition at line 461 of file modaledge.cc.

References ASSERT, ExtModalForceBase::EMF_ALL, ExtModalForceBase::EMF_MODAL, and ExtFileHandlerBase::GetOutStream().

{
        std::ostream& fout = *pEFH->GetOutStream();
        ASSERT((uFlags & ExtModalForceBase::EMF_MODAL) != 0);
        ASSERT((uFlags & ~ExtModalForceBase::EMF_ALL) == 0);

        fout << "* MBDyn to EDGE modal dynamics\n"
                "modal_state,N,0,0,2\n"
                "modal_coordinate,R," << q.size() << ",1,0\n"
                << q[0];
        for (std::vector<doublereal>::const_iterator i = q.begin() + 1;
                i < q.end(); ++i)
        {
                fout << " " << *i;
        }
        fout << "\n"
                "modal_velocity,R," << qP.size() << ",1,0\n"
                << qP[0];
        for (std::vector<doublereal>::const_iterator i = qP.begin() + 1;
                i < qP.end(); ++i)
        {
                fout << " " << *i;
        }
        fout << "\n";
}

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• modaledge.h
• modaledge.cc