#include <ginaccltp.h>

Inheritance diagram for GiNaCViscousConstitutiveLaw< T, Tder >:

Collaboration diagram for GiNaCViscousConstitutiveLaw< T, Tder >:

Public Member Functions
	GiNaCViscousConstitutiveLaw (const T &PStress, std::vector< std::string > &epsilon, std::vector< std::string > &expression)

virtual	~GiNaCViscousConstitutiveLaw (void)

virtual ConstitutiveLaw< T, Tder > *	pCopy (void) const

virtual std::ostream &	Restart (std::ostream &out) const

virtual void	Update (const T &Eps, const T &=0.)

Public Member Functions inherited from SymbolicViscousConstitutiveLaw< T, Tder >
	SymbolicViscousConstitutiveLaw (const T &PStress, std::vector< std::string > &epsilonPrime, std::vector< std::string > &expression)

virtual	~SymbolicViscousConstitutiveLaw (void)

virtual ConstLawType::Type	GetConstLawType (void) const

Public Member Functions inherited from ElasticConstitutiveLaw< T, Tder >
	ElasticConstitutiveLaw (const TplDriveCaller< T > *pDC, const T &PStress)

virtual	~ElasticConstitutiveLaw (void)

void	SetValue (DataManager pDM, VectorHandler &X, VectorHandler &XP, SimulationEntity::Hints ph=0)

virtual Hint *	ParseHint (DataManager pDM, const char s) const

Public Member Functions inherited from ConstitutiveLaw< T, Tder >
	ConstitutiveLaw (void)

virtual	~ConstitutiveLaw (void)

virtual void	AfterConvergence (const T &Eps, const T &EpsPrime=mb_zero< T >())

virtual const T &	GetEpsilon (void) const

virtual const T &	GetEpsilonPrime (void) const

virtual const T &	GetF (void) const

virtual const Tder &	GetFDE (void) const

virtual const Tder &	GetFDEPrime (void) const

virtual unsigned int	iGetNumDof (void) const

virtual std::ostream &	DescribeDof (std::ostream &out, const char *prefix="", bool bInitial=false) const

virtual void	DescribeDof (std::vector< std::string > &desc, bool bInitial=false, int i=-1) const

virtual std::ostream &	DescribeEq (std::ostream &out, const char *prefix="", bool bInitial=false) const

virtual void	DescribeEq (std::vector< std::string > &desc, bool bInitial=false, int i=-1) const

virtual DofOrder::Order	GetDofType (unsigned int i) const

Public Member Functions inherited from WithLabel
	WithLabel (unsigned int uL=0, const std::string &sN="")

virtual	~WithLabel (void)

void	PutLabel (unsigned int uL)

void	PutName (const std::string &sN)

unsigned int	GetLabel (void) const

const std::string &	GetName (void) const

Public Member Functions inherited from SimulationEntity
	SimulationEntity (void)

virtual	~SimulationEntity (void)

virtual bool	bIsValidIndex (unsigned int i) const

virtual DofOrder::Order	GetEqType (unsigned int i) const

virtual void	BeforePredict (VectorHandler &, VectorHandler &, VectorHandler &, VectorHandler &) const

virtual void	AfterPredict (VectorHandler &X, VectorHandler &XP)

virtual void	Update (const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

virtual void	DerivativesUpdate (const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

virtual void	Update (const VectorHandler &XCurr, InverseDynamics::Order iOrder)

virtual void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP)

virtual void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP, const VectorHandler &XPP)

virtual unsigned int	iGetNumPrivData (void) const

virtual unsigned int	iGetPrivDataIdx (const char *s) const

virtual doublereal	dGetPrivData (unsigned int i) const

virtual std::ostream &	OutputAppend (std::ostream &out) const

virtual void	ReadInitialState (MBDynParser &HP)

Public Member Functions inherited from TplDriveOwner< T >
	TplDriveOwner (const TplDriveCaller< T > *pDC=0)

virtual	~TplDriveOwner (void)

void	Set (const TplDriveCaller< T > *pDC)

TplDriveCaller< T > *	pGetDriveCaller (void) const

T	Get (const doublereal &dVar) const

T	Get (void) const

virtual bool	bIsDifferentiable (void) const

virtual T	GetP (void) const

Private Attributes
unsigned	dim

std::vector< GiNaC::symbol * >	gEpsPrime

std::vector< GiNaC::ex >	gExpr

std::vector< std::vector < GiNaC::ex > >	gExprDEpsPrime

Additional Inherited Members
Public Types inherited from ConstitutiveLaw< T, Tder >
typedef ConstitutiveLaw< T, Tder >::ErrNotAvailable	Err

Public Types inherited from SimulationEntity
typedef std::vector< Hint * >	Hints

Protected Member Functions inherited from ElasticConstitutiveLaw< T, Tder >
virtual std::ostream &	Restart_int (std::ostream &out) const

Protected Attributes inherited from ElasticConstitutiveLaw< T, Tder >
T	PreStress

Protected Attributes inherited from ConstitutiveLaw< T, Tder >
T	Epsilon

T	EpsilonPrime

T	F

Tder	FDE

Tder	FDEPrime

Protected Attributes inherited from WithLabel
unsigned int	uLabel

std::string	sName

Protected Attributes inherited from TplDriveOwner< T >
TplDriveCaller< T > *	pTplDriveCaller

Detailed Description

template<class T, class Tder>
class GiNaCViscousConstitutiveLaw< T, Tder >

Definition at line 374 of file ginaccltp.h.

Constructor & Destructor Documentation

template<class T , class Tder >

GiNaCViscousConstitutiveLaw< T, Tder >::GiNaCViscousConstitutiveLaw	(	const T &	PStress,
		std::vector< std::string > &	epsilon,
		std::vector< std::string > &	expression
	)

Definition at line 403 of file ginaccltp.h.

References GiNaCViscousConstitutiveLaw< T, Tder >::dim, GiNaCViscousConstitutiveLaw< T, Tder >::gEpsPrime, GiNaCViscousConstitutiveLaw< T, Tder >::gExpr, GiNaCViscousConstitutiveLaw< T, Tder >::gExprDEpsPrime, MBDYN_EXCEPT_ARGS, and GiNaCViscousConstitutiveLaw< T, Tder >::Update().

 : SymbolicViscousConstitutiveLaw<T, Tder>(PStress, epsilonPrime, expression)
 { 
         if (typeid(T) == typeid(Vec3)) {
                 dim = 3;
 
         } else if (typeid(T) == typeid(Vec6)) {
                 dim = 6;
 
         } else {
                 throw (typename ConstitutiveLaw<T, Tder>::ErrNotAvailable(MBDYN_EXCEPT_ARGS)); 
         }
 
         gEpsPrime.resize(dim);
         gExpr.resize(dim);
 
         gExprDEpsPrime.resize(dim);
         for (unsigned row = 0; row < dim; row++) {
                 gExprDEpsPrime[row].resize(dim);
         }
 
         ConstitutiveLaw<T, Tder>::FDE = mb_zero<Tder>();
         ConstitutiveLaw<T, Tder>::FDEPrime = mb_zero<Tder>();
 
         GiNaC::lst l; 
 
         for (unsigned row = 0; row < dim; row++) {
                 gEpsPrime[row] = new GiNaC::symbol(epsilonPrime[row]);
                 l.append(*gEpsPrime[row]);
         }
 
         for (unsigned row = 0; row < dim; row++) {
                 try {
                         gExpr[row] = GiNaC::ex(expression[row], l);
 
                 } catch (std::exception& e) {
                         silent_cerr("GiNaCViscousConstitutiveLaw<T, Tder>: expression #" << row << " parsing "
                                 "failed: " << e.what() << std::endl);
                         throw e;
                 }
 
                 for (unsigned col = 0; col < dim; col++) {
                         try {
                                 gExprDEpsPrime[row][col] = gExpr[row].diff(*gEpsPrime[col]);
 
                         } catch (std::exception& e) {
                                 silent_cerr("GiNaCViscousConstitutiveLaw<T, Tder>: expression #" << row << " differentiation "
                                         "wrt/ EpsPrime #" << col << " failed: " << e.what()
                                         << std::endl);
                                 throw e;
                         }
                 }
         }
 
         silent_cout("\tGiNaCViscousConstitutiveLaw:" << std::endl);
         for (unsigned row = 0; row < dim; row++) {
                 silent_cout("\t\tEpsPrime[" << row << "]:         \"" << *gEpsPrime[row] << "\"" << std::endl);
         }
         for (unsigned row = 0; row < dim; row++) {
                 silent_cout("\t\tConstitutive law[" << row << "]: \"" << gExpr[row] << "\"" << std::endl);
         }
         for (unsigned row = 0; row < dim; row++) {
                 for (unsigned col = 0; col < dim; col++) {
                         silent_cout("\t\tDer[" << row << "]/EpsPrime[" << row << "][" << col << "]:  \"" << gExprDEpsPrime[row][col] << "\"" << std::endl);
                 }
         }
 
         // try and evaluate the constitutive law
         try {
                 Update(ElasticConstitutiveLaw<T, Tder>::Epsilon, ElasticConstitutiveLaw<T, Tder>::Epsilon);
         }
         catch (std::exception& e) {
                 silent_cerr("GiNaCViscousConstitutiveLaw<T, Tder>::GiNaCViscousConstitutiveLaw: Update() failed (" << e.what() << ")" << std::endl);
                 throw e;
         }
 };

Here is the call graph for this function:

template<class T , class Tder >

GiNaCViscousConstitutiveLaw< T, Tder >::~GiNaCViscousConstitutiveLaw ( void )

virtual

Definition at line 484 of file ginaccltp.h.

 {
         for (unsigned row = 0; row < dim; row++) {
                 delete gEpsPrime[row];
         }
 }

Member Function Documentation

template<class T , class Tder >

ConstitutiveLaw< T, Tder > * GiNaCViscousConstitutiveLaw< T, Tder >::pCopy ( void ) const

virtual

Implements ConstitutiveLaw< T, Tder >.

Definition at line 492 of file ginaccltp.h.

References SAFENEWWITHCONSTRUCTOR.

 {
         ConstitutiveLaw<T, Tder>* pCL = 0;
 
         std::vector<std::string> epsilonPrime(dim);
         std::vector<std::string> expression(dim);
 
         for (unsigned row = 0; row < dim; row++) {
                 std::ostringstream      epsPrime;
                 std::ostringstream      expr;
 
                 epsPrime << *gEpsPrime[row];
                 expr << gExpr[row];
 
                 epsilonPrime[row] = epsPrime.str();
                 expression[row] = expr.str();
         }
 
         typedef GiNaCViscousConstitutiveLaw<T, Tder> cl;
         SAFENEWWITHCONSTRUCTOR(pCL, 
                 cl, 
                 cl(ElasticConstitutiveLaw<T, Tder>::PreStress,
                         epsilonPrime, expression));
       
         return pCL;
 }

template<class T , class Tder >

std::ostream & GiNaCViscousConstitutiveLaw< T, Tder >::Restart ( std::ostream & out ) const

virtual

Reimplemented from ConstitutiveLaw< T, Tder >.

Definition at line 520 of file ginaccltp.h.

References ElasticConstitutiveLaw< T, Tder >::Restart_int().

 {
         out << "symbolic viscous, epsilonPrime";
         for (unsigned row = 0; row < dim; row++) {
                 out << ", \"" << *gEpsPrime[row] << "\"";
         }
         out << "\", expression";
         for (unsigned row = 0; row < dim; row++) {
                 out << ", \"" << gExpr[row] << "\"";
         }
 
         return ElasticConstitutiveLaw<T, Tder>::Restart_int(out);
 }

Here is the call graph for this function:

template<class T , class Tder >

void GiNaCViscousConstitutiveLaw< T, Tder >::Update	(	const T &	Eps,
		const T &	EpsPrime = `0.`
	)

virtual

Implements ConstitutiveLaw< T, Tder >.

Definition at line 535 of file ginaccltp.h.

References ConstitutiveLaw< T, Tder >::F, and ConstitutiveLaw< T, Tder >::FDEPrime.

Referenced by GiNaCViscousConstitutiveLaw< T, Tder >::GiNaCViscousConstitutiveLaw(), and GiNaCViscousConstitutiveLaw< doublereal, doublereal >::GiNaCViscousConstitutiveLaw().

 {
         GiNaC::lst l;
 
         ConstitutiveLaw<T, Tder>::EpsilonPrime = EpsPrime;
 
         for (unsigned row = 0; row < dim; row++) {
                 l.append(*gEpsPrime[row] == EpsPrime(row + 1));
         }
 
         for (unsigned row = 0; row < dim; row++) {
                 GiNaC::ex f_expr = gExpr[row].subs(l);
 
                 ConstitutiveLaw<T, Tder>::F(row + 1)
                         = GiNaC::ex_to<GiNaC::numeric>(f_expr).to_double();
 
                 for (unsigned col = 0; col < dim; col++) {
                         GiNaC::ex f_derEpsPrime = gExprDEpsPrime[row][col].subs(l);
 
                         ConstitutiveLaw<T, Tder>::FDEPrime(row + 1, col + 1)
                                 = GiNaC::ex_to<GiNaC::numeric>(f_derEpsPrime).to_double();
                 }
         }
 }