NLPViscoElasticCLR< T, Tder, Typ > Struct Template Reference

Inheritance diagram for NLPViscoElasticCLR< T, Tder, Typ >:

Collaboration diagram for NLPViscoElasticCLR< T, Tder, Typ >:

Public Member Functions
virtual ConstitutiveLaw< T, Tder > *	Read (const DataManager *pDM, MBDynParser &HP, ConstLawType::Type &CLType)
Public Member Functions inherited from ConstitutiveLawRead< T, Tder >
virtual	~ConstitutiveLawRead (void)

Detailed Description

template<class T, class Tder, ConstLawType::Type Typ>
struct NLPViscoElasticCLR< T, Tder, Typ >

Definition at line 322 of file constltp_nlp.cc.

Member Function Documentation

template<class T , class Tder , ConstLawType::Type Typ>

virtual ConstitutiveLaw<T, Tder>* NLPViscoElasticCLR< T, Tder, Typ >::Read ( const DataManager *  pDM, MBDynParser &  HP, ConstLawType::Type &  CLType  )

inlinevirtual

Implements ConstitutiveLawRead< T, Tder >.

Definition at line 324 of file constltp_nlp.cc.

References ConstLawType::ELASTIC, MBDynParser::Get(), IncludeParser::GetLineData(), GetPreStress(), HighParser::GetReal(), HighParser::IsKeyWord(), MBDYN_EXCEPT_ARGS, ParseScalarFunction(), SAFENEWWITHCONSTRUCTOR, ConstLawType::VISCOELASTIC, and ConstLawType::VISCOUS.

        {
                ConstitutiveLaw<T, Tder>* pCL = 0;

                unsigned dim;
                if (typeid(T) == typeid(doublereal)) {
                        dim = 1;

                } else if (typeid(T) == typeid(Vec3)) {
                        dim = 3;

                } else if (typeid(T) == typeid(Vec6)) {
                        dim = 6;

                } else {
                        silent_cerr("Invalid dimensionality "
                                "for NLP viscoelastic constitutive law "
                                "at line " << HP.GetLineData()
                                << std::endl);
                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

                /* stiffness */
                Tder FDE0(mb_zero<Tder>());
                bool bElastic(false);
                std::vector<const DifferentiableScalarFunction *> FDEsc(dim);
                for (unsigned i = 0; i < dim; i++) {
                        FDEsc[i] = 0;
                }
                        

                if (Typ & ConstLawType::ELASTIC) {
                        FDE0 = HP.Get(FDE0);

                        bElastic = !IsNull<Tder>(FDE0);
                        for (unsigned i = 0; i < dim; i++) {
                                if (!HP.IsKeyWord("null")) {
                                        const BasicScalarFunction *const sc
                                                = ParseScalarFunction(HP, (DataManager *const)pDM);
                                        FDEsc[i] = dynamic_cast<const DifferentiableScalarFunction *>(sc);
                                        if (FDEsc[i] == 0) {
                                                silent_cerr("NLPViscoElasticCLR: "
                                                        "stiffness scalar function #" << i << " "
                                                        "at line " << HP.GetLineData() << " "
                                                        "must be differentiable" << std::endl);
                                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                                        }
                                        bElastic = true;
                                }
                        }
                }

                /* damping */
                Tder FDEPrime0(mb_zero<Tder>());
                bool bViscous(false);
                std::vector<const DifferentiableScalarFunction *> FDEPrimesc(dim);
                for (unsigned i = 0; i < dim; i++) {
                        FDEPrimesc[i] = 0;
                }

                if (Typ & ConstLawType::VISCOUS) {
                        if ((Typ & ConstLawType::ELASTIC) && HP.IsKeyWord("proportional")) {
                                FDEPrime0 = FDE0*HP.GetReal();
                        } else {
                                FDEPrime0 = HP.Get(FDEPrime0);
                        }


                        bViscous = !IsNull<Tder>(FDEPrime0);
                        for (unsigned i = 0; i < dim; i++) {
                                if (!HP.IsKeyWord("null")) {
                                        const BasicScalarFunction *const sc
                                                = ParseScalarFunction(HP, (DataManager *const)pDM);
                                        FDEPrimesc[i] = dynamic_cast<const DifferentiableScalarFunction *>(sc);
                                        if (FDEPrimesc[i] == 0) {
                                                silent_cerr("NLPViscoElasticCLR: "
                                                        "damping scalar function #" << i << " "
                                                        "at line " << HP.GetLineData() << " "
                                                        "must be differentiable" << std::endl);
                                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                                        }
                                        bViscous = true;
                                }
                        }
                }

                /* Prestress and prestrain */
                T PreStress(mb_zero<T>());
                GetPreStress(HP, PreStress);
                TplDriveCaller<T>* pTplDC = GetPreStrain<T>(pDM, HP);

                if (bElastic && bViscous) {
                        CLType = ConstLawType::VISCOELASTIC;
                } else if (bElastic) {
                        CLType = ConstLawType::ELASTIC;
                } else if (bViscous) {
                        CLType = ConstLawType::VISCOUS;
                } else {
                        /* needs to be at least elastic... */
                        CLType = ConstLawType::ELASTIC;
                }

                typedef NLPViscoElasticConstitutiveLaw<T, Tder> L;
                SAFENEWWITHCONSTRUCTOR(pCL, L,
                        L(pTplDC, PreStress,
                                CLType,
                                FDE0, FDEsc,
                                FDEPrime0, FDEPrimesc));

                return pCL;
        };

Here is the call graph for this function:

---

The documentation for this struct was generated from the following file:

• constltp_nlp.cc