SymbolicCLR< T, Tder > Struct Template Reference

Inheritance diagram for SymbolicCLR< T, Tder >:

Collaboration diagram for SymbolicCLR< T, Tder >:

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>
struct SymbolicCLR< T, Tder >

Definition at line 595 of file constltp_impl.cc.

Member Function Documentation

template<class T , class Tder >

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

inlinevirtual

Implements ConstitutiveLawRead< T, Tder >.

Reimplemented in SymbolicViscoElasticCLR< T, Tder >, SymbolicViscousCLR< T, Tder >, and SymbolicElasticCLR< T, Tder >.

Definition at line 597 of file constltp_impl.cc.

References ASSERT, ConstLawType::ELASTIC, IncludeParser::GetLineData(), GetPreStress(), HighParser::GetStringWithDelims(), HighParser::IsKeyWord(), MBDYN_EXCEPT_ARGS, SAFENEWWITHCONSTRUCTOR, ConstLawType::VISCOELASTIC, and ConstLawType::VISCOUS.

Referenced by SymbolicElasticCLR< T, Tder >::Read(), SymbolicViscousCLR< T, Tder >::Read(), and SymbolicViscoElasticCLR< T, Tder >::Read().

                                                                                {
                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 symbolic constitutive law "
                                "at line " << HP.GetLineData()
                                << std::endl);
                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

                std::vector<std::string> epsilon;
                if (CLType & ConstLawType::ELASTIC) {
                        if (!HP.IsKeyWord("epsilon")) {
                                silent_cerr("keyword \"epsilon\" expected at line " << HP.GetLineData() << std::endl);
                                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }

                        epsilon.resize(dim);

                        for (unsigned row = 0; row < dim; row++) {
                                const char *tmp = HP.GetStringWithDelims();

                                if (tmp == 0) {
                                        silent_cerr("unable to get \"epsilon\" "
                                                "symbol #" << row << " "
                                                "at line " << HP.GetLineData() << std::endl);
                                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                                }
                                epsilon[row] = tmp;
                        }
                }

                std::vector<std::string> epsilonPrime;
                if (CLType & ConstLawType::VISCOUS) {
                        if (!HP.IsKeyWord("epsilon" "prime")) {
                                silent_cerr("keyword \"epsilon prime\" expected at line " << HP.GetLineData() << std::endl);
                                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }

                        epsilonPrime.resize(dim);

                        for (unsigned row = 0; row < dim; row++) {
                                const char *tmp = HP.GetStringWithDelims();

                                if (tmp == 0) {
                                        silent_cerr("unable to get \"epsilonPrime\" "
                                                "symbol #" << row << " "
                                                "at line " << HP.GetLineData() << std::endl);
                                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                                }
                                epsilonPrime[row] = tmp;
                        }
                }

                if (!HP.IsKeyWord("expression")) {
                        silent_cerr("keyword \"expression\" expected at line " << HP.GetLineData() << std::endl);
                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

                std::vector<std::string> expression(dim);
                for (unsigned row = 0; row < dim; row++) {
                        const char *tmp = HP.GetStringWithDelims();
                        if (tmp == 0) {
                                silent_cerr("unable to get \"expression\" "
                                        "#" << row << " "
                                        "at line " << HP.GetLineData()
                                        << std::endl);
                                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }
                        expression[row] = tmp;
                }

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

                switch (CLType) {
                case ConstLawType::ELASTIC: {
#ifdef USE_GINAC
                        typedef GiNaCElasticConstitutiveLaw<T, Tder> L;
                        SAFENEWWITHCONSTRUCTOR(pCL, L,
                                        L(pTplDC, PreStress,
                                                epsilon,
                                                expression));
#else /* ! USE_GINAC */
                        silent_cerr("symbolic constitutive law not supported "
                                "at line " << HP.GetLineData() << std::endl);
                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
#endif /* ! USE_GINAC */
                        break;
                }

                case ConstLawType::VISCOUS: {
#ifdef USE_GINAC
                        typedef GiNaCViscousConstitutiveLaw<T, Tder> L;
                        SAFENEWWITHCONSTRUCTOR(pCL, L,
                                        L(PreStress, epsilonPrime, expression));
#else /* ! USE_GINAC */
                        silent_cerr("symbolic constitutive law not supported "
                                "at line " << HP.GetLineData() << std::endl);
                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
#endif /* ! USE_GINAC */
                        break;
                }

                case ConstLawType::VISCOELASTIC: {
#ifdef USE_GINAC
                        typedef GiNaCViscoElasticConstitutiveLaw<T, Tder> L;
                        SAFENEWWITHCONSTRUCTOR(pCL, L,
                                        L(pTplDC, PreStress,
                                                epsilon, epsilonPrime,
                                                expression));
#else /* ! USE_GINAC */
                        silent_cerr("symbolic constitutive law not supported "
                                "at line " << HP.GetLineData() << std::endl);
                        throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
#endif /* ! USE_GINAC */
                        break;
                }

                default:
                        ASSERT(0);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

                return pCL;
        };

Here is the call graph for this function:

---

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

• constltp_impl.cc