constltp.h File Reference

#include "withlab.h"
#include "simentity.h"
#include "tpldrive.h"

Include dependency graph for constltp.h:

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

Go to the source code of this file.

Classes
class	ConstLawType
class	ConstitutiveLaw< T, Tder >
class	ConstitutiveLaw< T, Tder >::ErrNotAvailable
class	ConstitutiveLawOwner< T, Tder >
struct	ConstitutiveLawRead< T, Tder >

Typedefs
typedef ConstitutiveLaw < doublereal, doublereal >	ConstitutiveLaw1D
typedef ConstitutiveLaw< Vec3, Mat3x3 >	ConstitutiveLaw3D
typedef ConstitutiveLaw< Vec6, Mat6x6 >	ConstitutiveLaw6D
typedef ConstitutiveLawOwner < doublereal, doublereal >	ConstitutiveLaw1DOwner
typedef ConstitutiveLawOwner < Vec3, Mat3x3 >	ConstitutiveLaw3DOwner
typedef ConstitutiveLawOwner < Vec6, Mat6x6 >	ConstitutiveLaw6DOwner

Functions
ConstitutiveLaw< doublereal, doublereal > *	ReadCL1D (const DataManager *pDM, MBDynParser &HP, ConstLawType::Type &CLType)
ConstitutiveLaw< Vec3, Mat3x3 > *	ReadCL3D (const DataManager *pDM, MBDynParser &HP, ConstLawType::Type &CLType)
ConstitutiveLaw< Vec6, Mat6x6 > *	ReadCL6D (const DataManager *pDM, MBDynParser &HP, ConstLawType::Type &CLType)
bool	SetCL1D (const char *name, ConstitutiveLawRead< doublereal, doublereal > *rf)
bool	SetCL3D (const char *name, ConstitutiveLawRead< Vec3, Mat3x3 > *rf)
bool	SetCL6D (const char *name, ConstitutiveLawRead< Vec6, Mat6x6 > *rf)
void	InitCL (void)
void	DestroyCL (void)

Typedef Documentation

typedef ConstitutiveLaw<doublereal, doublereal> ConstitutiveLaw1D

Definition at line 183 of file constltp.h.

typedef ConstitutiveLawOwner<doublereal, doublereal> ConstitutiveLaw1DOwner

Definition at line 378 of file constltp.h.

typedef ConstitutiveLaw<Vec3, Mat3x3> ConstitutiveLaw3D

Definition at line 184 of file constltp.h.

typedef ConstitutiveLawOwner<Vec3, Mat3x3> ConstitutiveLaw3DOwner

Definition at line 379 of file constltp.h.

typedef ConstitutiveLaw<Vec6, Mat6x6> ConstitutiveLaw6D

Definition at line 185 of file constltp.h.

typedef ConstitutiveLawOwner<Vec6, Mat6x6> ConstitutiveLaw6DOwner

Definition at line 380 of file constltp.h.

Function Documentation

void DestroyCL

(

void

)

Definition at line 1549 of file constltp_impl.cc.

References CL1DFuncMap, CL3DFuncMap, CL6DFuncMap, done, and MBDYN_EXCEPT_ARGS.

Referenced by MBDynParser::~MBDynParser().

{
        if (::done == 0) {
                silent_cerr("DestroyCL() called once too many" << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        if (--::done > 0) {
                return;
        }

        /* free stuff */
        for (CL1DFuncMapType::iterator i = CL1DFuncMap.begin(); i != CL1DFuncMap.end(); ++i) {
                delete i->second;
        }
        CL1DFuncMap.clear();

        for (CL3DFuncMapType::iterator i = CL3DFuncMap.begin(); i != CL3DFuncMap.end(); ++i) {
                delete i->second;
        }
        CL3DFuncMap.clear();

        for (CL6DFuncMapType::iterator i = CL6DFuncMap.begin(); i != CL6DFuncMap.end(); ++i) {
                delete i->second;
        }
        CL6DFuncMap.clear();
}

void InitCL

(

void

)

Definition at line 1389 of file constltp_impl.cc.

References done, NLP_init(), NLSF_init(), SetCL1D(), SetCL3D(), SetCL6D(), and TDCLW_init().

Referenced by MBDynParser::MBDynParser().

{
        if (::done++ > 0) {
                return;
        }

        /* constitutive law array */
        SetCL1D("array", new CLArray1DR);
        SetCL3D("array", new CLArray3DR);
        SetCL6D("array", new CLArray6DR);

        /* linear elastic */
        SetCL1D("linear" "elastic", new LinearElasticCLR<doublereal, doublereal>);
        SetCL3D("linear" "elastic", new LinearElasticCLR<Vec3, Mat3x3>);
        SetCL6D("linear" "elastic", new LinearElasticCLR<Vec6, Mat6x6>);

        /* linear elastic isotropic */
        SetCL1D("linear" "elastic" "isotropic", new LinearElasticCLR<doublereal, doublereal>);
        SetCL3D("linear" "elastic" "isotropic", new LinearElasticCLR<Vec3, Mat3x3>);
        SetCL6D("linear" "elastic" "isotropic", new LinearElasticCLR<Vec6, Mat6x6>);

        /* linear elastic generic */
        SetCL1D("linear" "elastic" "generic", new LinearElasticGenericCLR<doublereal, doublereal>);
        SetCL3D("linear" "elastic" "generic", new LinearElasticGenericCLR<Vec3, Mat3x3>);
        SetCL6D("linear" "elastic" "generic", new LinearElasticGenericCLR<Vec6, Mat6x6>);

        /* linear (visco)elastic generic axial torsion coupling*/
        SetCL6D("linear" "elastic" "generic" "axial" "torsion" "coupling",
                new LinearElasticGenericAxialTorsionCouplingCLR<Vec6, Mat6x6>);
        SetCL6D("linear" "viscoelastic" "generic" "axial" "torsion" "coupling",
                new LinearViscoElasticGenericAxialTorsionCouplingCLR<Vec6, Mat6x6>);

        /* inverse square elastic */
        SetCL1D("inverse" "square" "elastic", new InverseSquareElasticCLR);

        /* log elastic */
        SetCL1D("log" "elastic", new LogElasticCLR<doublereal, doublereal>);

        /* double linear elastic */
        SetCL1D("double" "linear" "elastic", new DoubleLinearElasticCLR<doublereal, doublereal>);
        SetCL3D("double" "linear" "elastic", new DoubleLinearElasticCLR<Vec3, Mat3x3>);

        /* isotropic hardening elastic */
        SetCL1D("isotropic" "hardening" "elastic", new IsotropicHardeningCLR<doublereal, doublereal>);
        SetCL3D("isotropic" "hardening" "elastic", new IsotropicHardeningCLR<Vec3, Mat3x3>);
        SetCL6D("isotropic" "hardening" "elastic", new IsotropicHardeningCLR<Vec6, Mat6x6>);

        /* contact elastic */
        SetCL1D("contact" "elastic", new ContactElasticCLR<doublereal, doublereal>);
        SetCL3D("contact" "elastic", new ContactElasticCLR<Vec3, Mat3x3>);

        /* symbolic (elastic, viscous, viscoelastic) */
        SetCL1D("symbolic", new SymbolicCLR<doublereal, doublereal>);
        SetCL3D("symbolic", new SymbolicCLR<Vec3, Mat3x3>);
        SetCL6D("symbolic", new SymbolicCLR<Vec6, Mat6x6>);

        SetCL1D("symbolic" "elastic", new SymbolicElasticCLR<doublereal, doublereal>);
        SetCL3D("symbolic" "elastic", new SymbolicElasticCLR<Vec3, Mat3x3>);
        SetCL6D("symbolic" "elastic", new SymbolicElasticCLR<Vec6, Mat6x6>);

        SetCL1D("symbolic" "viscous", new SymbolicViscousCLR<doublereal, doublereal>);
        SetCL3D("symbolic" "viscous", new SymbolicViscousCLR<Vec3, Mat3x3>);
        SetCL6D("symbolic" "viscous", new SymbolicViscousCLR<Vec6, Mat6x6>);

        SetCL1D("symbolic" "viscoelastic", new SymbolicViscoElasticCLR<doublereal, doublereal>);
        SetCL3D("symbolic" "viscoelastic", new SymbolicViscoElasticCLR<Vec3, Mat3x3>);
        SetCL6D("symbolic" "viscoelastic", new SymbolicViscoElasticCLR<Vec6, Mat6x6>);

        /* linear viscous */
        SetCL1D("linear" "viscous", new LinearViscousCLR<doublereal, doublereal>);
        SetCL3D("linear" "viscous", new LinearViscousCLR<Vec3, Mat3x3>);
        SetCL6D("linear" "viscous", new LinearViscousCLR<Vec6, Mat6x6>);

        /* linear viscous isotropic */
        SetCL1D("linear" "viscous" "isotropic", new LinearViscousCLR<doublereal, doublereal>);
        SetCL3D("linear" "viscous" "isotropic", new LinearViscousCLR<Vec3, Mat3x3>);
        SetCL6D("linear" "viscous" "isotropic", new LinearViscousCLR<Vec6, Mat6x6>);

        /* linear viscous generic */
        SetCL1D("linear" "viscous" "generic", new LinearViscousGenericCLR<doublereal, doublereal>);
        SetCL3D("linear" "viscous" "generic", new LinearViscousGenericCLR<Vec3, Mat3x3>);
        SetCL6D("linear" "viscous" "generic", new LinearViscousGenericCLR<Vec6, Mat6x6>);

        /* linear viscoelastic */
        SetCL1D("linear" "viscoelastic", new LinearViscoElasticCLR<doublereal, doublereal>);
        SetCL3D("linear" "viscoelastic", new LinearViscoElasticCLR<Vec3, Mat3x3>);
        SetCL6D("linear" "viscoelastic", new LinearViscoElasticCLR<Vec6, Mat6x6>);

        /* linear viscoelastic isotropic */
        SetCL1D("linear" "viscoelastic" "isotropic", new LinearViscoElasticCLR<doublereal, doublereal>);
        SetCL3D("linear" "viscoelastic" "isotropic", new LinearViscoElasticCLR<Vec3, Mat3x3>);
        SetCL6D("linear" "viscoelastic" "isotropic", new LinearViscoElasticCLR<Vec6, Mat6x6>);

        /* linear viscoelastic generic */
        SetCL1D("linear" "viscoelastic" "generic", new LinearViscoElasticGenericCLR<doublereal, doublereal>);
        SetCL3D("linear" "viscoelastic" "generic", new LinearViscoElasticGenericCLR<Vec3, Mat3x3>);
        SetCL6D("linear" "viscoelastic" "generic", new LinearViscoElasticGenericCLR<Vec6, Mat6x6>);

        /* linear time variant viscoelastic generic */
        SetCL1D("linear" "time" "variant" "viscoelastic" "generic", new LTVViscoElasticGenericCLR<doublereal, doublereal>);
        SetCL3D("linear" "time" "variant" "viscoelastic" "generic", new LTVViscoElasticGenericCLR<Vec3, Mat3x3>);
        SetCL6D("linear" "time" "variant" "viscoelastic" "generic", new LTVViscoElasticGenericCLR<Vec6, Mat6x6>);

        /* cubic elastic generic */
        SetCL1D("cubic" "elastic" "generic", new CubicElasticGenericCLR<doublereal, doublereal>);
        SetCL3D("cubic" "elastic" "generic", new CubicElasticGenericCLR<Vec3, Mat3x3>);

        /* cubic viscoelastic generic */
        SetCL1D("cubic" "viscoelastic" "generic", new CubicViscoElasticGenericCLR<doublereal, doublereal>);
        SetCL3D("cubic" "viscoelastic" "generic", new CubicViscoElasticGenericCLR<Vec3, Mat3x3>);

        /* double linear viscoelastic */
        SetCL1D("double" "linear" "viscoelastic", new DoubleLinearViscoElasticCLR<doublereal, doublereal>);
        SetCL3D("double" "linear" "viscoelastic", new DoubleLinearViscoElasticCLR<Vec3, Mat3x3>);

        /* turbulent viscoelastic */
        SetCL1D("turbulent" "viscoelastic", new TurbulentViscoElasticCLR<doublereal, doublereal>);

        /* linear elastic bistop */
        SetCL1D("linear" "elastic" "bistop", new LinearElasticBiStopCLR<doublereal, doublereal>);
        SetCL3D("linear" "elastic" "bistop", new LinearElasticBiStopCLR<Vec3, Mat3x3>);
        SetCL6D("linear" "elastic" "bistop", new LinearElasticBiStopCLR<Vec6, Mat6x6>);

        /* linear viscoelastic bistop */
        SetCL1D("linear" "viscoelastic" "bistop", new LinearViscoElasticBiStopCLR<doublereal, doublereal>);
        SetCL3D("linear" "viscoelastic" "bistop", new LinearViscoElasticBiStopCLR<Vec3, Mat3x3>);
        SetCL6D("linear" "viscoelastic" "bistop", new LinearViscoElasticBiStopCLR<Vec6, Mat6x6>);

        /* bistop wrapper */
        SetCL1D("bistop", new BiStopCLW1DR);
        SetCL3D("bistop", new BiStopCLW3DR);
        SetCL6D("bistop", new BiStopCLW6DR);

        /* shock absorber */
        SetCL1D("shock" "absorber", new ShockAbsorberCLR<doublereal, doublereal>);

        /* Artificial Neural Network */
        SetCL1D("ann" "elastic", new AnnElasticCLR<doublereal, doublereal>);
        SetCL1D("ann" "viscoelastic", new AnnViscoElasticCLR<doublereal, doublereal>);

        /* constitutive laws sponsored by Hutchinson CdR */
        NLP_init();
        NLSF_init();

        /* invariant constitutive law */
        SetCL3D("invariant" "angular", new InvAngularCLR);
        SetCL3D("axial" "wrapper", new AxialCLR);

        /* ... */
        TDCLW_init();

        /* NOTE: add here initialization of new built-in constitutive laws;
         * alternative ways to register new custom constitutive laws are:
         * - call SetCL*D() from anywhere in the code
         * - write a module that calls SetCL*D() from inside a function
         *   called module_init(), and load it using "module load".
         */
}

Here is the call graph for this function:

ConstitutiveLaw<doublereal, doublereal>* ReadCL1D	(	const DataManager *	pDM,
		MBDynParser &	HP,
		ConstLawType::Type &	CLType
	)

Definition at line 118 of file constltp_impl.cc.

References CL1DFuncMap, func(), IncludeParser::GetLineData(), HighParser::IsWord(), and MBDYN_EXCEPT_ARGS.

Referenced by MBDynParser::GetConstLaw1D(), CLArray1DR::Read(), and BiStopCLW1DR::Read().

{
        const char *s, *sOrig = HP.IsWord(CL1DWordSet);
        if (sOrig == 0) {
                /* default to linear elastic? */
                s = "linear" "elastic";
                sOrig = "";

        } else {
                s = sOrig;
        }

        CL1DFuncMapType::iterator func = CL1DFuncMap.find(std::string(s));
        if (func == CL1DFuncMap.end()) {
                silent_cerr("unknown constitutive law 1D type "
                        "\"" << sOrig << "\" "
                        "at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        return func->second->Read(pDM, HP, CLType);
}

Here is the call graph for this function:

ConstitutiveLaw<Vec3, Mat3x3>* ReadCL3D	(	const DataManager *	pDM,
		MBDynParser &	HP,
		ConstLawType::Type &	CLType
	)

Definition at line 142 of file constltp_impl.cc.

References CL3DFuncMap, func(), IncludeParser::GetLineData(), HighParser::IsWord(), and MBDYN_EXCEPT_ARGS.

Referenced by MBDynParser::GetConstLaw3D(), CLArray3DR::Read(), and BiStopCLW3DR::Read().

{
        const char *s, *sOrig = HP.IsWord(CL3DWordSet);
        if (sOrig == 0) {
#if 0
                s = "linear" "elastic";
                sOrig = "";
#else
                silent_cerr("unknown constitutive law 3D type "
                        "at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
#endif

        } else {
                s = sOrig;
        }

        CL3DFuncMapType::iterator func = CL3DFuncMap.find(std::string(s));
        if (func == CL3DFuncMap.end()) {
                silent_cerr("unknown constitutive law 3D type "
                        "\"" << sOrig << "\" "
                        "at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        return func->second->Read(pDM, HP, CLType);
}

Here is the call graph for this function:

ConstitutiveLaw<Vec6, Mat6x6>* ReadCL6D	(	const DataManager *	pDM,
		MBDynParser &	HP,
		ConstLawType::Type &	CLType
	)

Definition at line 171 of file constltp_impl.cc.

References CL6DFuncMap, func(), IncludeParser::GetLineData(), HighParser::IsWord(), and MBDYN_EXCEPT_ARGS.

Referenced by MBDynParser::GetConstLaw6D(), CLArray6DR::Read(), and BiStopCLW6DR::Read().

{
        const char *s, *sOrig = HP.IsWord(CL6DWordSet);
        if (sOrig == 0) {
#if 0
                s = "linear" "elastic";
                sOrig = "";
#else
                silent_cerr("unknown constitutive law 6D type "
                        "at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
#endif

        } else {
                s = sOrig;
        }

        CL6DFuncMapType::iterator func = CL6DFuncMap.find(std::string(s));
        if (func == CL6DFuncMap.end()) {
                silent_cerr("unknown constitutive law 6D type "
                        "\"" << sOrig << "\" "
                        "at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        return func->second->Read(pDM, HP, CLType);
}

Here is the call graph for this function:

bool SetCL1D	(	const char *	name,
		ConstitutiveLawRead< doublereal, doublereal > *	rf
	)

Definition at line 93 of file constltp_impl.cc.

References CL1DFuncMap.

Referenced by InitCL(), InitSF(), mbdyn_octave_set(), module_init(), NLP_init(), NLSF_init(), and TDCLW_init().

{
        pedantic_cout("registering constitutive law 1D \"" << name << "\""
                << std::endl );
        return CL1DFuncMap.insert(CL1DFuncMapType::value_type(name, rf)).second;
}

bool SetCL3D	(	const char *	name,
		ConstitutiveLawRead< Vec3, Mat3x3 > *	rf
	)

Definition at line 101 of file constltp_impl.cc.

References CL3DFuncMap.

Referenced by InitCL(), InitSF(), mbdyn_octave_set(), module_init(), NLP_init(), NLSF_init(), and TDCLW_init().

{
        pedantic_cout("registering constitutive law 3D \"" << name << "\""
                << std::endl );
        return CL3DFuncMap.insert(CL3DFuncMapType::value_type(name, rf)).second;
}

bool SetCL6D	(	const char *	name,
		ConstitutiveLawRead< Vec6, Mat6x6 > *	rf
	)

Definition at line 109 of file constltp_impl.cc.

References CL6DFuncMap.

Referenced by InitCL(), InitSF(), mbdyn_octave_set(), module_init(), NLP_init(), NLSF_init(), and TDCLW_init().

{
        pedantic_cout("registering constitutive law 6D \"" << name << "\""
                << std::endl );
        return CL6DFuncMap.insert(CL6DFuncMapType::value_type(name, rf)).second;
}