jointreg.h File Reference

#include <cfloat>
#include "joint.h"

Include dependency graph for jointreg.h:

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

Go to the source code of this file.

Classes
class	JointRegularization
class	TikhonovRegularization
class	DynamicRegularization
class	JacobianRegularization

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

Function Documentation

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

Definition at line 527 of file jointreg.cc.

References DEBUGCERR, DEBUGCOUTFNAME, IncludeParser::GetLineData(), HighParser::GetReal(), Elem::iGetNumDof(), HighParser::IsArg(), HighParser::IsKeyWord(), Elem::JOINT, Elem::JOINT_REGULARIZATION, LASTKEYWORD, MBDYN_EXCEPT_ARGS, DataManager::pFindElem(), NestedElem::pGetElem(), psElemNames, and SAFENEWWITHCONSTRUCTOR.

Referenced by DataManager::ReadOneElem().

{
        DEBUGCOUTFNAME("ReadRegularizationJoint");

        const char* sKeyWords[] = {
                "tikhonov",
                "dynamic",
                "jacobian",

                0
        };

        /* enum delle parole chiave */
        enum KeyWords {
                UNKNOWN = -1,

                TIKHONOV = 0,
                DYNAMIC,
                JACOBIAN,

                LASTKEYWORD
        };

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

        /* lettura del tipo di vincolo */
        KeyWords CurrKeyWord = KeyWords(HP.IsKeyWord());

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

        Elem* pEl = 0;

        switch (CurrKeyWord) {

        case TIKHONOV:
        case DYNAMIC:
        case JACOBIAN:
        {
                Elem *pTmpEl = pDM->pFindElem(Elem::JOINT, uLabel);
                Joint *pJ = dynamic_cast<Joint *>(pTmpEl);
                if (pJ == 0) {
                        DrivenElem *pDE = dynamic_cast<DrivenElem *>(pTmpEl);
                        if (pDE != 0) {
                                pJ = dynamic_cast<Joint *>(pDE->pGetElem());
                        }
                }

                if (pJ == 0) {
                        silent_cerr(psElemNames[Elem::JOINT_REGULARIZATION]
                                << "(" << uLabel << "): "
                                "unable to find "
                                << psElemNames[Elem::JOINT]
                                << "(" << uLabel << ") "
                                "at line " << HP.GetLineData()
                                << std::endl);
                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

                unsigned iNumDofs = pJ->iGetNumDof();
                if (iNumDofs == 0) {
                        silent_cerr(psElemNames[Elem::JOINT_REGULARIZATION]
                                << "(" << uLabel << "): "
                                "no dofs for "
                                << psElemNames[Elem::JOINT]
                                << "(" << uLabel << ") "
                                "at line " << HP.GetLineData()
                                << std::endl);
                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);

                }

                std::vector<doublereal> dC(iNumDofs);
                if (HP.IsKeyWord("list")) {
                        for (unsigned iCnt = 0; iCnt < iNumDofs; iCnt++) {
                                dC[iCnt] = HP.GetReal();
                        }

                } else if (HP.IsArg()) {
                        doublereal d = HP.GetReal();

                        for (unsigned iCnt = 0; iCnt < iNumDofs; iCnt++) {
                                dC[iCnt] = d;
                        }

                } else {
                        for (unsigned iCnt = 0; iCnt < iNumDofs; iCnt++) {
                                dC[iCnt] = 1e-6;
                        }
                }

                switch (CurrKeyWord) {
                case TIKHONOV:
                        SAFENEWWITHCONSTRUCTOR(pEl,
                                TikhonovRegularization,
                                TikhonovRegularization(uLabel, pJ, dC, 0));
                        break;

                case DYNAMIC:
                        SAFENEWWITHCONSTRUCTOR(pEl,
                                DynamicRegularization,
                                DynamicRegularization(uLabel, pJ, dC, 0));
                        break;

                case JACOBIAN:
                        SAFENEWWITHCONSTRUCTOR(pEl,
                                JacobianRegularization,
                                JacobianRegularization(uLabel, pJ, dC, 0));
                        break;

                default:
                        DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

        } break;

        /* Aggiungere qui altri vincoli */

        default:
                break;
        }

        /* Se non c'e' il punto e virgola finale */
        if (pEl == 0) {
                DEBUGCERR("");
                silent_cerr("error in allocation of "
                        << psElemNames[Elem::JOINT_REGULARIZATION]
                        << "(" << uLabel << ")" << std::endl);

                throw ErrMemory(MBDYN_EXCEPT_ARGS);
        }

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

        return pEl;
} /* ReadJointRegularization() */

Here is the call graph for this function: