#include "mbconfig.h"
#include "myassert.h"
#include "mynewmem.h"
#include "dataman.h"
#include "tpldrive_impl.h"
#include "reffrm.h"

Include dependency graph for tpldrive_impl.cc:

Go to the source code of this file.

Classes
class	NullTDCR< T >

class	ZeroTDCR< T >

class	SingleTDCR< T >

class	CompTplDriveCaller< T >

class	CompTplDriveCaller< Mat3x3 >

class	CompTplDriveCaller< Mat6x6 >

class	CompTDCR< T >

struct	DrivesArray< T >

class	ArrayTplDriveCaller< T >

class	ArrayTplDriveCaller< doublereal >

class	ArrayTDCR< T >

struct	DC1DWordSetType

struct	DC3DWordSetType

struct	DC6DWordSetType

struct	DC3x3DWordSetType

struct	DC6x6DWordSetType

Typedefs
typedef std::map< std::string, TplDriveCallerRead< doublereal > *, ltstrcase >	DC1DFuncMapType

typedef std::map< std::string, TplDriveCallerRead< Vec3 > *, ltstrcase >	DC3DFuncMapType

typedef std::map< std::string, TplDriveCallerRead< Vec6 > *, ltstrcase >	DC6DFuncMapType

typedef std::map< std::string, TplDriveCallerRead< Mat3x3 > *, ltstrcase >	DC3x3DFuncMapType

typedef std::map< std::string, TplDriveCallerRead< Mat6x6 > *, ltstrcase >	DC6x6DFuncMapType

Functions
doublereal	GetT (MBDynParser &HP, const doublereal &t)

template<class T >
T	GetT (MBDynParser &HP, const T &t)

bool	SetDC1D (const char name, TplDriveCallerRead< doublereal > rf)

bool	SetDC3D (const char name, TplDriveCallerRead< Vec3 > rf)

bool	SetDC6D (const char name, TplDriveCallerRead< Vec6 > rf)

bool	SetDC3x3D (const char name, TplDriveCallerRead< Mat3x3 > rf)

bool	SetDC6x6D (const char name, TplDriveCallerRead< Mat6x6 > rf)

TplDriveCaller< doublereal > *	ReadDC1D (const DataManager *pDM, MBDynParser &HP)

TplDriveCaller< Vec3 > *	ReadDC3D (const DataManager *pDM, MBDynParser &HP)

TplDriveCaller< Vec6 > *	ReadDC6D (const DataManager *pDM, MBDynParser &HP)

TplDriveCaller< Mat3x3 > *	ReadDC3x3D (const DataManager *pDM, MBDynParser &HP)

TplDriveCaller< Mat6x6 > *	ReadDC6x6D (const DataManager *pDM, MBDynParser &HP)

template<class VM >
static TplDriveCaller< Vec3 > *	ReadDCVec (const DataManager *pDM, MBDynParser &HP, const ReferenceFrame &rf)

TplDriveCaller< Vec3 > *	ReadDCVecRel (const DataManager *pDM, MBDynParser &HP, const ReferenceFrame &rf)

TplDriveCaller< Vec3 > *	ReadDCVecAbs (const DataManager *pDM, MBDynParser &HP, const ReferenceFrame &rf)

void	InitTplDC (void)

void	DestroyTplDC (void)

Variables
static DC1DFuncMapType	DC1DFuncMap

static DC3DFuncMapType	DC3DFuncMap

static DC6DFuncMapType	DC6DFuncMap

static DC3x3DFuncMapType	DC3x3DFuncMap

static DC6x6DFuncMapType	DC6x6DFuncMap

static DC1DWordSetType	DC1DWordSet

static DC3DWordSetType	DC3DWordSet

static DC6DWordSetType	DC6DWordSet

static DC3x3DWordSetType	DC3x3DWordSet

static DC6x6DWordSetType	DC6x6DWordSet

static unsigned	done

Typedef Documentation

typedef std::map<std::string, TplDriveCallerRead<doublereal> *, ltstrcase> DC1DFuncMapType

Definition at line 718 of file tpldrive_impl.cc.

typedef std::map<std::string, TplDriveCallerRead<Vec3> *, ltstrcase> DC3DFuncMapType

Definition at line 719 of file tpldrive_impl.cc.

typedef std::map<std::string, TplDriveCallerRead<Mat3x3> *, ltstrcase> DC3x3DFuncMapType

Definition at line 722 of file tpldrive_impl.cc.

typedef std::map<std::string, TplDriveCallerRead<Vec6> *, ltstrcase> DC6DFuncMapType

Definition at line 720 of file tpldrive_impl.cc.

typedef std::map<std::string, TplDriveCallerRead<Mat6x6> *, ltstrcase> DC6x6DFuncMapType

Definition at line 723 of file tpldrive_impl.cc.

Function Documentation

void DestroyTplDC ( void )

Definition at line 980 of file tpldrive_impl.cc.

References DC1DFuncMap, DC3DFuncMap, DC3x3DFuncMap, DC6DFuncMap, DC6x6DFuncMap, done, and MBDYN_EXCEPT_ARGS.

Referenced by MBDynParser::~MBDynParser().

 {
         if (::done == 0) {
                 silent_cerr("DestroyTplDC() called once too many" << std::endl);
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         if (--::done > 0) {
                 return;
         }
 
         /* free stuff */
         for (DC1DFuncMapType::iterator i = DC1DFuncMap.begin(); i != DC1DFuncMap.end(); ++i) {
                 delete i->second;
         }
         DC1DFuncMap.clear();
 
         for (DC3DFuncMapType::iterator i = DC3DFuncMap.begin(); i != DC3DFuncMap.end(); ++i) {
                 delete i->second;
         }
         DC3DFuncMap.clear();
 
         for (DC6DFuncMapType::iterator i = DC6DFuncMap.begin(); i != DC6DFuncMap.end(); ++i) {
                 delete i->second;
         }
         DC6DFuncMap.clear();
 
         for (DC3x3DFuncMapType::iterator i = DC3x3DFuncMap.begin(); i != DC3x3DFuncMap.end(); ++i) {
                 delete i->second;
         }
         DC3x3DFuncMap.clear();
 
         for (DC6x6DFuncMapType::iterator i = DC6x6DFuncMap.begin(); i != DC6x6DFuncMap.end(); ++i) {
                 delete i->second;
         }
         DC6x6DFuncMap.clear();
 }

doublereal GetT	(	MBDynParser &	HP,
		const doublereal &	t
	)

Definition at line 37 of file tpldrive.cc.

Referenced by SingleTDCR< T >::Read(), and ArrayTDCR< T >::Read().

 {
         return 0.;
 }

template<class T >

T GetT	(	MBDynParser &	HP,
		const T &	t
	)

Definition at line 712 of file tpldrive_impl.cc.

References MBDynParser::Get().

 {
         return HP.Get(t);
 }

Here is the call graph for this function:

void InitTplDC ( void )

Definition at line 931 of file tpldrive_impl.cc.

References done, SetDC1D(), SetDC3D(), SetDC3x3D(), SetDC6D(), and SetDC6x6D().

Referenced by MBDynParser::MBDynParser().

 {
         if (::done++ > 0) {
                 return;
         }
 
         /* null */
         SetDC1D("null", new NullTDCR<doublereal>);
         SetDC3D("null", new NullTDCR<Vec3>);
         SetDC6D("null", new NullTDCR<Vec6>);
 
         SetDC3x3D("null", new NullTDCR<Mat3x3>);
         SetDC6x6D("null", new NullTDCR<Mat6x6>);
 
         /* zero (deprecated) */
         SetDC1D("zero", new ZeroTDCR<doublereal>);
         SetDC3D("zero", new ZeroTDCR<Vec3>);
         SetDC6D("zero", new ZeroTDCR<Vec6>);
 
         SetDC3x3D("zero", new ZeroTDCR<Mat3x3>);
         SetDC6x6D("zero", new ZeroTDCR<Mat6x6>);
 
         /* single */
         SetDC1D("single", new SingleTDCR<doublereal>);
         SetDC3D("single", new SingleTDCR<Vec3>);
         SetDC6D("single", new SingleTDCR<Vec6>);
 
         SetDC3x3D("single", new SingleTDCR<Mat3x3>);
         SetDC6x6D("single", new SingleTDCR<Mat6x6>);
 
         /* component */
         /* in the scalar case, "single" and "component" are identical */
         SetDC1D("component", new SingleTDCR<doublereal>);
         SetDC3D("component", new CompTDCR<Vec3>);
         SetDC6D("component", new CompTDCR<Vec6>);
 
         SetDC3x3D("component", new CompTDCR<Mat3x3>);
         SetDC6x6D("component", new CompTDCR<Mat6x6>);
 
         /* array */
         SetDC1D("array", new ArrayTDCR<doublereal>);
         SetDC3D("array", new ArrayTDCR<Vec3>);
         SetDC6D("array", new ArrayTDCR<Vec6>);
 
         SetDC3x3D("array", new ArrayTDCR<Mat3x3>);
         SetDC6x6D("array", new ArrayTDCR<Mat6x6>);
 }

Here is the call graph for this function:

TplDriveCaller<doublereal>* ReadDC1D	(	const DataManager *	pDM,
		MBDynParser &	HP
	)

Definition at line 812 of file tpldrive_impl.cc.

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

Referenced by MBDynParser::GetTplDriveCaller().

 {
         const char *s = HP.IsWord(DC1DWordSet);
         if (s == 0) {
                 s = "single";
         }
 
         DC1DFuncMapType::iterator func = DC1DFuncMap.find(std::string(s));
         if (func == DC1DFuncMap.end()) {
                 silent_cerr("unknown template drive caller 1D type \"" << s << "\" "
                         "at line " << HP.GetLineData() << std::endl);
                 throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         return func->second->Read(pDM, HP);
 }

Here is the call graph for this function:

TplDriveCaller<Vec3>* ReadDC3D	(	const DataManager *	pDM,
		MBDynParser &	HP
	)

Definition at line 830 of file tpldrive_impl.cc.

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

Referenced by MBDynParser::GetTplDriveCaller(), ReadAirstreamData(), DataManager::ReadControl(), ReadForce(), and ReadGravity().

 {
         const char *s = HP.IsWord(DC3DWordSet);
         if (s == 0) {
                 s = "single";
         }
 
         DC3DFuncMapType::iterator func = DC3DFuncMap.find(std::string(s));
         if (func == DC3DFuncMap.end()) {
                 silent_cerr("unknown template drive caller 3D type \"" << s << "\" "
                         "at line " << HP.GetLineData() << std::endl);
                 throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         return func->second->Read(pDM, HP);
 }

Here is the call graph for this function:

TplDriveCaller<Mat3x3>* ReadDC3x3D	(	const DataManager *	pDM,
		MBDynParser &	HP
	)

Definition at line 866 of file tpldrive_impl.cc.

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

Referenced by MBDynParser::GetTplDriveCaller().

 {
         const char *s = HP.IsWord(DC3x3DWordSet);
         if (s == 0) {
                 s = "single";
         }
 
         DC3x3DFuncMapType::iterator func = DC3x3DFuncMap.find(std::string(s));
         if (func == DC3x3DFuncMap.end()) {
                 silent_cerr("unknown template drive caller 3x3D type \"" << s << "\" "
                         "at line " << HP.GetLineData() << std::endl);
                 throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         return func->second->Read(pDM, HP);
 }

Here is the call graph for this function:

TplDriveCaller<Vec6>* ReadDC6D	(	const DataManager *	pDM,
		MBDynParser &	HP
	)

Definition at line 848 of file tpldrive_impl.cc.

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

Referenced by MBDynParser::GetTplDriveCaller().

 {
         const char *s = HP.IsWord(DC6DWordSet);
         if (s == 0) {
                 s = "single";
         }
 
         DC6DFuncMapType::iterator func = DC6DFuncMap.find(std::string(s));
         if (func == DC6DFuncMap.end()) {
                 silent_cerr("unknown template drive caller 6D type \"" << s << "\" "
                         "at line " << HP.GetLineData() << std::endl);
                 throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         return func->second->Read(pDM, HP);
 }

Here is the call graph for this function:

TplDriveCaller<Mat6x6>* ReadDC6x6D	(	const DataManager *	pDM,
		MBDynParser &	HP
	)

Definition at line 884 of file tpldrive_impl.cc.

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

Referenced by MBDynParser::GetTplDriveCaller().

 {
         const char *s = HP.IsWord(DC6x6DWordSet);
         if (s == 0) {
                 s = "single";
         }
 
         DC6x6DFuncMapType::iterator func = DC6x6DFuncMap.find(std::string(s));
         if (func == DC6x6DFuncMap.end()) {
                 silent_cerr("unknown template drive caller 6x6D type \"" << s << "\" "
                         "at line " << HP.GetLineData() << std::endl);
                 throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         return func->second->Read(pDM, HP);
 }

Here is the call graph for this function:

template<class VM >

static TplDriveCaller<Vec3>* ReadDCVec	(	const DataManager *	pDM,
		MBDynParser &	HP,
		const ReferenceFrame &	rf
	)

static

Definition at line 903 of file tpldrive_impl.cc.

References MBDynParser::GetManip(), MBDynParser::GetTplDriveCaller(), MBDynParser::PopManip(), and MBDynParser::PushManip().

 {
         VM manip(HP, rf);
 
         HP.PushManip(&manip);
         TplDriveCaller<Vec3>* pDC = HP.GetTplDriveCaller<Vec3>();
         if (HP.GetManip() == &manip) {
                 HP.PopManip();
         }
 
         return pDC;
 }

Here is the call graph for this function:

TplDriveCaller<Vec3>* ReadDCVecAbs	(	const DataManager *	pDM,
		MBDynParser &	HP,
		const ReferenceFrame &	rf
	)

Definition at line 923 of file tpldrive_impl.cc.

Referenced by ReadStructuralForce().

 {
         return ReadDCVec<MBDynParser::VecAbsManip>(pDM, HP, rf); 
 }

TplDriveCaller<Vec3>* ReadDCVecRel	(	const DataManager *	pDM,
		MBDynParser &	HP,
		const ReferenceFrame &	rf
	)

Definition at line 917 of file tpldrive_impl.cc.

Referenced by ModuleIMUConstraint::ModuleIMUConstraint(), DataManager::ReadControl(), and ReadStructuralForce().

 {
         return ReadDCVec<MBDynParser::VecRelManip>(pDM, HP, rf); 
 }

bool SetDC1D	(	const char *	name,
		TplDriveCallerRead< doublereal > *	rf
	)

Definition at line 771 of file tpldrive_impl.cc.

References DC1DFuncMap.

Referenced by InitTplDC(), and mbdyn_octave_set().

 {
         pedantic_cout("registering template drive caller 1D \"" << name << "\""
                 << std::endl );
         return DC1DFuncMap.insert(DC1DFuncMapType::value_type(name, rf)).second;
 }

bool SetDC3D	(	const char *	name,
		TplDriveCallerRead< Vec3 > *	rf
	)

Definition at line 779 of file tpldrive_impl.cc.

References DC3DFuncMap.

Referenced by InitTplDC(), mbdyn_octave_set(), and module_init().

 {
         pedantic_cout("registering template drive caller 3D \"" << name << "\""
                 << std::endl );
         return DC3DFuncMap.insert(DC3DFuncMapType::value_type(name, rf)).second;
 }

bool SetDC3x3D	(	const char *	name,
		TplDriveCallerRead< Mat3x3 > *	rf
	)

Definition at line 795 of file tpldrive_impl.cc.

References DC3x3DFuncMap.

Referenced by InitTplDC(), and mbdyn_octave_set().

 {
         pedantic_cout("registering template drive caller 3x3D \"" << name << "\""
                 << std::endl );
         return DC3x3DFuncMap.insert(DC3x3DFuncMapType::value_type(name, rf)).second;
 }

bool SetDC6D	(	const char *	name,
		TplDriveCallerRead< Vec6 > *	rf
	)

Definition at line 787 of file tpldrive_impl.cc.

References DC6DFuncMap.

Referenced by InitTplDC(), and mbdyn_octave_set().

 {
         pedantic_cout("registering template drive caller 6D \"" << name << "\""
                 << std::endl );
         return DC6DFuncMap.insert(DC6DFuncMapType::value_type(name, rf)).second;
 }

bool SetDC6x6D	(	const char *	name,
		TplDriveCallerRead< Mat6x6 > *	rf
	)

Definition at line 803 of file tpldrive_impl.cc.

References DC6x6DFuncMap.

Referenced by InitTplDC(), and mbdyn_octave_set().

 {
         pedantic_cout("registering template drive caller 6x6D \"" << name << "\""
                 << std::endl );
         return DC6x6DFuncMap.insert(DC6x6DFuncMapType::value_type(name, rf)).second;
 }