aeromodal.h File Reference

#include "myassert.h"
#include "mynewmem.h"
#include "elem.h"
#include "aerodyn.h"
#include "modal.h"
#include "spmapmh.h"

Include dependency graph for aeromodal.h:

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

Go to the source code of this file.

Classes
class	AerodynamicModal

Functions
Elem *	ReadAerodynamicModal (DataManager *pDM, MBDynParser &HP, const DofOwner *pDO, unsigned int uLabel)

Function Documentation

Elem* ReadAerodynamicModal	(	DataManager *	pDM,
		MBDynParser &	HP,
		const DofOwner *	pDO,
		unsigned int	uLabel
	)

Definition at line 612 of file aeromodal.cc.

References AbsRefFrame, Elem::AEROMODAL, DEBUGCOUT, DEBUGCOUTFNAME, DataManager::fReadOutput(), IncludeParser::GetFileName(), HighParser::GetInt(), IncludeParser::GetLineData(), HighParser::GetReal(), MBDynParser::GetRotRel(), HighParser::IsArg(), HighParser::IsKeyWord(), Elem::JOINT, MBDYN_EXCEPT_ARGS, AerodynamicModal::NO_RIGID, Modal::pGetModalNode(), FullMatrixHandler::PutCoef(), SpMapMatrixHandler::PutCoef(), DataManager::ReadElem(), SpMapMatrixHandler::Reset(), MBDynParser::RF, AerodynamicModal::RIGID, SAFENEWWITHCONSTRUCTOR, STRLENOF, and Modal::uGetNModes().

Referenced by DataManager::ReadOneElem().

{
        DEBUGCOUTFNAME("ReadAerodynamicModal(" << uLabel << ")" << std::endl);

        /* formato dell'input:
         *
         *  label,
         *  modal node,
         *  reference modal joint,
         *  rotation of the aerodynamic reference in respect of nodal reference,
         *  reference cord,
         *  number of aerodynamic states,
         *  {rigid, gust, gust filter cut-off frequency}
         *  file name containing state space model matrices;
         */

        /* giunto modale collegato */
        const Modal *pModalJoint = pDM->ReadElem<const Modal, const Joint, Elem::JOINT>(HP);
        ReferenceFrame RF;
        const StructNode *pModalNode = pModalJoint->pGetModalNode();
        if (pModalNode) {
                RF = ReferenceFrame(pModalNode);

        } else {
                RF = ::AbsRefFrame;
        }

        Mat3x3 Ra(HP.GetRotRel(RF));

        doublereal Chord = HP.GetReal();

        unsigned int AeroN = HP.GetInt();
        /* numero modi e FEM */
        unsigned int NModes = pModalJoint->uGetNModes();

        AerodynamicModal::RigidF_t rigidF = AerodynamicModal::NO_RIGID;
        if (HP.IsKeyWord("rigid")) {
                rigidF = AerodynamicModal::RIGID;
                NModes += rigidF;
        }

        /* Eventuale raffica */
        unsigned int GustN = 0;
        doublereal Vff = 0.;
        if (HP.IsKeyWord("gust")) {
                GustN = 2;
                Vff = HP.GetReal();
        }

        /* apre il file contenente le matrici A B C D0 D1 D2 */
        const char *sFileData = HP.GetFileName();
        std::ifstream fdat(sFileData);
        DEBUGCOUT("Reading Aerodynamic State Space Matrices from file '"
                << sFileData << '\'' << std::endl);
        if (!fdat) {
                int save_errno = errno;
                silent_cerr(std::endl << "Unable to open file \"" << sFileData << "\" "
                        "(" << save_errno << ": " << strerror(save_errno) << ")" << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        SpMapMatrixHandler* pAMat = 0;
        FullMatrixHandler* pBMat = 0;
        FullMatrixHandler* pCMat = 0;
        FullMatrixHandler* pD0Mat = 0;
        FullMatrixHandler* pD1Mat = 0;
        FullMatrixHandler* pD2Mat = 0;
        SAFENEWWITHCONSTRUCTOR(pAMat, SpMapMatrixHandler, SpMapMatrixHandler(AeroN, AeroN));
        pAMat->Reset();
        SAFENEWWITHCONSTRUCTOR(pBMat, FullMatrixHandler, FullMatrixHandler(AeroN, NModes + GustN));
        SAFENEWWITHCONSTRUCTOR(pCMat, FullMatrixHandler, FullMatrixHandler(NModes, AeroN));
        SAFENEWWITHCONSTRUCTOR(pD0Mat, FullMatrixHandler, FullMatrixHandler(NModes, NModes + GustN));
        SAFENEWWITHCONSTRUCTOR(pD1Mat, FullMatrixHandler, FullMatrixHandler(NModes, NModes + GustN));
        SAFENEWWITHCONSTRUCTOR(pD2Mat, FullMatrixHandler, FullMatrixHandler(NModes, NModes + GustN));

        doublereal d;
        char str[BUFSIZ];

        /* parsing del file */
        while (!fdat.eof()) {
                fdat.getline(str, sizeof(str));

                /* legge il primo blocco (HEADER) */
                if (!strncmp("*** MATRIX A", str, STRLENOF("*** MATRIX A"))) {
                        for (unsigned int iCnt = 1; iCnt <= AeroN; iCnt++)  {
                                for (unsigned int jCnt = 1; jCnt <= AeroN; jCnt++)  {
                                        fdat >> d;
                                        pAMat->PutCoef(iCnt, jCnt, d);
                                }
                        }

                /* legge il primo blocco (HEADER) */
                } else if (!strncmp("*** MATRIX B", str, STRLENOF("*** MATRIX B"))) {
                        for (unsigned int iCnt = 1; iCnt <= AeroN; iCnt++)  {
                                for (unsigned int jCnt = 1; jCnt <= NModes + GustN; jCnt++)  {
                                        fdat >> d;
                                        pBMat->PutCoef(iCnt, jCnt, d);
                                }
                        }

                /* legge il primo blocco (HEADER) */
                } else if (!strncmp("*** MATRIX C", str, STRLENOF("*** MATRIX C"))) {
                        for (unsigned int iCnt = 1; iCnt <= NModes; iCnt++)  {
                                for (unsigned int jCnt = 1; jCnt <= AeroN; jCnt++)  {
                                        fdat >> d;
                                        pCMat->PutCoef(iCnt, jCnt, d);
                                }
                        }

                /* legge il primo blocco (HEADER) */
                } else if (!strncmp("*** MATRIX D0", str, STRLENOF("*** MATRIX D0"))) {
                        for (unsigned int iCnt = 1; iCnt <= NModes; iCnt++)  {
                                for (unsigned int jCnt = 1; jCnt <= NModes + GustN; jCnt++)  {
                                        fdat >> d;
                                        pD0Mat->PutCoef(iCnt, jCnt, d);
                                }
                        }

                /* legge il primo blocco (HEADER) */
                } else if (!strncmp("*** MATRIX D1", str, STRLENOF("*** MATRIX D1"))) {
                        for (unsigned int iCnt = 1; iCnt <= NModes; iCnt++)  {
                                for (unsigned int jCnt = 1; jCnt <= NModes + GustN; jCnt++)  {
                                        fdat >> d;
                                        pD1Mat->PutCoef(iCnt, jCnt, d);
                                }
                        }

                /* legge il primo blocco (HEADER) */
                } else if (!strncmp("*** MATRIX D2", str, STRLENOF("*** MATRIX D2"))) {
                        for (unsigned int iCnt = 1; iCnt <= NModes; iCnt++)  {
                                for (unsigned int jCnt = 1; jCnt <= NModes + GustN; jCnt++)  {
                                        fdat >> d;
                                        pD2Mat->PutCoef(iCnt, jCnt, d);
                                }
                        }
                }
        }
        fdat.close();

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

        Elem* pEl = 0;
        SAFENEWWITHCONSTRUCTOR(pEl,
                AerodynamicModal,
                AerodynamicModal(uLabel, pModalNode, pModalJoint,
                        Ra, pDO, Chord, NModes - rigidF,
                        AeroN, rigidF, GustN, Vff,
                        pAMat, pBMat, pCMat, pD0Mat, pD1Mat, pD2Mat, fOut));

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

        return pEl;
} /* End of DataManager::ReadAerodynamicModal() */

Here is the call graph for this function: