shape.cc File Reference

#include "mbconfig.h"
#include "mbpar.h"
#include "dataman.h"
#include "shape_impl.h"

Include dependency graph for shape.cc:

Go to the source code of this file.

Functions
Shape *	ReadShape (MBDynParser &HP)

Function Documentation

Shape* ReadShape

(

MBDynParser &

HP

)

Definition at line 298 of file shape.cc.

References ASSERT, ASSERTMSG, DEBUGCOUTFNAME, DEBUGLCOUT, HighParser::GetInt(), IncludeParser::GetLineData(), HighParser::GetReal(), HighParser::IsKeyWord(), LASTKEYWORD, MBDYN_EXCEPT_ARGS, MYDEBUG_INPUT, SAFEDELETEARR, SAFENEWARR, and SAFENEWWITHCONSTRUCTOR.

Referenced by ReadAeroData().

{
        DEBUGCOUTFNAME("ReadShape");

        const char* sKeyWords[] = {
                "const",
                "piecewise" "const",
                "linear",
                "piecewise" "linear",
                "parabolic",
                NULL
        };

        /* enum delle parole chiave */
        enum KeyWords {
                UNKNOWN = -1,
                SHAPECONST = 0,
                PIECEWISECONST,
                LINEAR,
                PIECEWISELINEAR,
                PARABOLIC,
                LASTKEYWORD
        };

        /* tabella delle parole chiave */
        KeyTable K(HP, sKeyWords);

        /* lettura del tipo di drive */
        KeyWords CurrKeyWord;
        if ((CurrKeyWord = KeyWords(HP.IsKeyWord())) == UNKNOWN) {
                CurrKeyWord = SHAPECONST;
        }

#ifdef DEBUG
        if (CurrKeyWord >= 0) {
                std::cout << "shape type: " << sKeyWords[CurrKeyWord] << std::endl;
        }
#endif /* DEBUG */

        Shape* pS = NULL;

        switch (CurrKeyWord) {
        /* forma costante */
        case SHAPECONST: {
                /* lettura dei dati specifici */
                doublereal dConst = HP.GetReal();
                DEBUGLCOUT(MYDEBUG_INPUT, "Const value: " << dConst << std::endl);

                /* allocazione e creazione */
                SAFENEWWITHCONSTRUCTOR(pS,
                        ConstShape1D,
                        ConstShape1D(dConst));
        } break;

        /* forma lineare */
        case LINEAR: {
                /* lettura dei dati specifici */
                doublereal da0;
                doublereal da1;
                if (HP.IsKeyWord("coefficients")) {
                        da0 = HP.GetReal();
                        da1 = HP.GetReal();
                } else {
                        doublereal dm = HP.GetReal();
                        doublereal dp = HP.GetReal();
                        da0 = (dp + dm)/2.;
                        da1 = (dp - dm)/2;
                }

                DEBUGLCOUT(MYDEBUG_INPUT, "Coefficients: "
                        << da0 << ", " << da1 << std::endl);

                /* allocazione e creazione */
                SAFENEWWITHCONSTRUCTOR(pS,
                        LinearShape1D,
                        LinearShape1D(da0, da1));
        } break;

        /* forma lineare a tratti (costante al di fuori del dominio definito) */
        case PIECEWISECONST:
        case PIECEWISELINEAR: {
                const char *sType = 0;
                switch (CurrKeyWord) {
                case PIECEWISECONST:
                        sType = "piecewise const";
                        break;

                case PIECEWISELINEAR:
                        sType = "piecewise linear";
                        break;

                default:
                        ASSERT(0);
                        break;
                }

                int np = HP.GetInt();
                if (np <= 0) {
                        silent_cerr("Illegal number of points " << np
                                << " for " << sType << " shape at line "
                                << HP.GetLineData() << std::endl);
                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

                doublereal *px = NULL;
                doublereal *pv = NULL;

                SAFENEWARR(px, doublereal, np);
                SAFENEWARR(pv, doublereal, np);

                px[0] = HP.GetReal();
                if (px[0] < -1. || px[0] > 1.) {
                        silent_cerr("Illegal value " << px[0]
                                << " for first point abscissa (must be -1. < x < 1.) "
                                "in " << sType << " shape at line "
                                << HP.GetLineData() << std::endl);
                        SAFEDELETEARR(px);
                        SAFEDELETEARR(pv);
                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                }
                pv[0] = HP.GetReal();

                for (int i = 1; i < np; i++) {
                        px[i] = HP.GetReal();
                        if (px[i] <= px[i-1] || px[i] > 1.) {
                                silent_cerr("Illegal value " << px[i]
                                        << " for point " << i + 1 << " abscissa "
                                        "(must be " << px[i - 1] << " < x < 1.) "
                                        "in " << sType << " shape at line "
                                        << HP.GetLineData() << std::endl);
                                SAFEDELETEARR(px);
                                SAFEDELETEARR(pv);
                                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }
                        pv[i] = HP.GetReal();
                }

                /* allocazione e creazione */
                switch (CurrKeyWord) {
                case PIECEWISECONST:
                        SAFENEWWITHCONSTRUCTOR(pS,
                                PiecewiseConstShape1D,
                                PiecewiseConstShape1D(np, px, pv));
                        break;

                case PIECEWISELINEAR:
                        SAFENEWWITHCONSTRUCTOR(pS,
                                PiecewiseLinearShape1D,
                                PiecewiseLinearShape1D(np, px, pv));
                        break;

                default:
                        ASSERT(0);
                        break;
                }

        } break;

        /* forma lineare */
        case PARABOLIC: {
                /* lettura dei dati specifici */
                doublereal dm = HP.GetReal();
                doublereal da0 = HP.GetReal();
                doublereal dp = HP.GetReal();
                doublereal da1 = (dp - dm)/2.;
                doublereal da2 = (dp + dm)/2. - da0;
                DEBUGLCOUT(MYDEBUG_INPUT, "Coefficients: "
                        << da0 << ", " << da1 << ", " << da2 << std::endl);

                /* allocazione e creazione */
                SAFENEWWITHCONSTRUCTOR(pS,
                        ParabolicShape1D,
                        ParabolicShape1D(da0, da1, da2));
        } break;

        /* Non c'e' default in quanto all'inizio il default e' stato messo
         * pari a SHAPECONST */
        default:
                ASSERTMSG(0, "You shouldn't have reached this point");
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        ASSERT(pS != NULL);
        return pS;
} /* ReadShape */

Here is the call graph for this function: