#include "mbconfig.h"
#include <limits>
#include <cmath>
#include <cfloat>
#include "dataman.h"
#include "drive_.h"
#include "dofdrive.h"
#include "privdrive.h"
#include "ddrive.h"
#include "shdrive.h"
#include "filedrv.h"
#include "fixedstep.h"
#include "varstep.h"
#include "sockdrv.h"
#include "streamdrive.h"
#include "socketstreamdrive.h"
#include "bufferstreamdrive.h"

Include dependency graph for drive_.cc:

Classes
struct	DriveWordSetType

struct	DriveCallerWordSetType

struct	TimeDCR

struct	TimeStepDCR

struct	MultDCR

struct	NullDCR

struct	OneDCR

struct	ConstDCR

struct	LinearDCR

struct	ParabolicDCR

struct	CubicDCR

struct	FunctionDCR

struct	StepDCR

struct	DoubleStepDCR

struct	RampDCR

struct	DoubleRampDCR

struct	SineCosineDCR

struct	SineDCR

struct	CosineDCR

struct	TanhDCR

struct	FourierSeriesDCR

struct	FrequencySweepDCR

struct	ExponentialDCR

struct	RandomDCR

struct	MeterDCR

struct	ClosestNextDCR

struct	DirectDCR

struct	PiecewiseLinearDCR

struct	StringDCR

struct	DofDCR

struct	SimulationEntityDCR

struct	ElementDCR

struct	NodeDCR

struct	DriveDCR

struct	SHDCR

struct	ArrayDCR

struct	FileDCR

struct	PeriodicDCR

struct	PostponedDCR

Macros
#define	TRIM_ALL_SPACES_BUT_ONE

Typedefs
typedef std::map< std::string, DriveRead *, ltstrcase >	DriveFuncMapType

typedef std::map< std::string, DriveCallerRead *, ltstrcase >	DriveCallerFuncMapType

Functions
bool	SetDriveData (const std::string &name, DriveRead *rf)

Drive *	ReadDriveData (unsigned uLabel, const DataManager *pDM, MBDynParser &HP)

bool	SetDriveCallerData (const char name, DriveCallerRead rf)

DriveCaller *	ReadDriveCallerData (const DataManager *pDM, MBDynParser &HP, bool bDeferred)

bool	setFileDriveCallerType (const char name, FileDriveCallerTypeReader rf)

void	DestroyFileDriveCallerTypes (void)

void	InitDriveData (void)

void	DestroyDriveData (void)

void	InitDriveCallerData (void)

void	DestroyDriveCallerData (void)

Variables
static DriveFuncMapType	DriveFuncMap

static DriveWordSetType	DriveWordSet

static DriveCallerFuncMapType	DriveCallerFuncMap

static DriveCallerWordSetType	DriveCallerWordSet

FileDriveCallerTypeMap	fileDriveCallerTypeMap

FileDriveCallerTypeWordSet	fileDriveCallerTypeWordSet

static unsigned	d_done

static unsigned	dc_done

Macro Definition Documentation

#define TRIM_ALL_SPACES_BUT_ONE

Typedef Documentation

typedef std::map<std::string, DriveCallerRead *, ltstrcase> DriveCallerFuncMapType

Definition at line 1312 of file drive_.cc.

typedef std::map<std::string, DriveRead *, ltstrcase> DriveFuncMapType

Definition at line 1262 of file drive_.cc.

Function Documentation

void DestroyDriveCallerData ( void )

Definition at line 3113 of file drive_.cc.

References MBDYN_EXCEPT_ARGS.

Referenced by MBDynParser::~MBDynParser().

 {
         if (::dc_done == 0) {
                 silent_cerr("DestroyDriveCallerData() called once too many" << std::endl);
                 throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         if (--::dc_done > 0) {
                 return;
         }
 
         /* free stuff */
         for (DriveCallerFuncMapType::iterator i = DriveCallerFuncMap.begin(); i != DriveCallerFuncMap.end(); ++i) {
                 delete i->second;
         }
         DriveCallerFuncMap.clear();
 }

void DestroyDriveData ( void )

Definition at line 3028 of file drive_.cc.

References MBDYN_EXCEPT_ARGS.

Referenced by DataManager::~DataManager().

 {
         if (::d_done == 0) {
                 silent_cerr("DestroyDriveData() called once too many" << std::endl);
                 throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         if (--::d_done > 0) {
                 return;
         }
 
         /* free stuff */
         for (DriveFuncMapType::iterator i = DriveFuncMap.begin(); i != DriveFuncMap.end(); ++i) {
                 delete i->second;
         }
         DriveFuncMap.clear();
 }

void DestroyFileDriveCallerTypes ( void )

Definition at line 2926 of file drive_.cc.

Referenced by MBDynParser::~MBDynParser().

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

void InitDriveCallerData ( void )

Definition at line 3050 of file drive_.cc.

References mbdyn_octave_set(), minmaxdrive_set(), nodedistdrive_set(), and SetDriveCallerData().

Referenced by MBDynParser::MBDynParser().

 {
         if (::dc_done++ > 0) {
                 return;
         }
 
         SetDriveCallerData("array", new ArrayDCR);
         SetDriveCallerData("closest" "next", new ClosestNextDCR);
         SetDriveCallerData("const", new ConstDCR);
         SetDriveCallerData("cosine", new CosineDCR);
         SetDriveCallerData("cubic", new CubicDCR);
         SetDriveCallerData("direct", new DirectDCR);
         SetDriveCallerData("dof", new DofDCR);
         SetDriveCallerData("double" "ramp", new DoubleRampDCR);
         SetDriveCallerData("double" "step", new DoubleStepDCR);
         SetDriveCallerData("drive", new DriveDCR);
         SetDriveCallerData("element", new ElementDCR);
         SetDriveCallerData("exponential", new ExponentialDCR);
         SetDriveCallerData("file", new FileDCR);
         SetDriveCallerData("fourier" "series", new FourierSeriesDCR);
         SetDriveCallerData("frequency" "sweep", new FrequencySweepDCR);
         SetDriveCallerData("function", new FunctionDCR);
 #ifdef USE_GINAC
         SetDriveCallerData("ginac", new GiNaCDCR);
 #endif // USE_GINAC
         SetDriveCallerData("linear", new LinearDCR);
         SetDriveCallerData("meter", new MeterDCR);
         SetDriveCallerData("mult", new MultDCR);
         SetDriveCallerData("node", new NodeDCR);
         SetDriveCallerData("null", new NullDCR);
         SetDriveCallerData("one", new OneDCR);  /* deprecated */
         SetDriveCallerData("parabolic", new ParabolicDCR);
         SetDriveCallerData("periodic", new PeriodicDCR);
         SetDriveCallerData("piecewise" "linear", new PiecewiseLinearDCR);
         SetDriveCallerData("postponed", new PostponedDCR);
         SetDriveCallerData("ramp", new RampDCR);
         SetDriveCallerData("random", new RandomDCR);
         SetDriveCallerData("sample" "and" "hold", new SHDCR);
         SetDriveCallerData("sine", new SineDCR);
         SetDriveCallerData("step", new StepDCR);
         SetDriveCallerData("string", new StringDCR);
         SetDriveCallerData("tanh", new TanhDCR);
         SetDriveCallerData("time", new TimeDCR);
         SetDriveCallerData("timestep", new TimeStepDCR);
         SetDriveCallerData("unit", new OneDCR);
 
         /* NOTE: add here initialization of new built-in drive callers;
          * alternative ways to register new custom drive callers are:
          * - call SetDriveCallerData() from anywhere in the code
          * - write a module that calls SetDriveCallerData() from inside a function
          *   called module_init(), and run-time load it using "module load"
          *   in the input file.
          */
 #ifdef STATIC_MODULES
 #ifdef USE_OCTAVE
         mbdyn_octave_set();
 #endif // USE_OCTAVE
         nodedistdrive_set();
         minmaxdrive_set();
 #endif // STATIC_MODULES
 }

Here is the call graph for this function:

void InitDriveData ( void )

Definition at line 3002 of file drive_.cc.

References SetDriveData().

Referenced by DataManager::DataManager().

 {
         if (::d_done++ > 0) {
                 return;
         }
 
         SetDriveData("fixed" "step", new FixedStepDR);
         SetDriveData("variable" "step", new VariableStepDR);
 #ifdef USE_SOCKET
         SetDriveData("socket", new SocketDR);
         SetDriveData("socket" "stream", new StreamDR("socket stream"));
         SetDriveData("rtai" "input", new StreamDR("RTAI input"));
         SetDriveData("stream", new StreamDR);
 #endif // USE_SOCKET
         SetDriveData("buffer" "stream", new BufferStreamDR);
 
         /* NOTE: add here initialization of new built-in drives;
          * alternative ways to register new custom drives are:
          * - call SetDriveData() from anywhere in the code
          * - write a module that calls SetDriveData() from inside a function
          *   called module_init(), and run-time load it using "module load"
          *   in the input file.
          */
 }

Here is the call graph for this function:

DriveCaller* ReadDriveCallerData	(	const DataManager *	pDM,
		MBDynParser &	HP,
		bool	bDeferred
	)

Definition at line 1333 of file drive_.cc.

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

Referenced by MBDynParser::GetDriveCaller().

 {
         DEBUGCOUTFNAME("ReadDriveCallerData()");
 
         const char *s = HP.IsWord(DriveCallerWordSet);
         if (s == 0) {
                 pedantic_cerr("ReadDriveCallerData: warning, assuming \"const\" drive caller at line " << HP.GetLineData() << std::endl);
                 s = "const";
         }
 
         DriveCallerFuncMapType::iterator func = DriveCallerFuncMap.find(std::string(s));
         if (func == DriveCallerFuncMap.end()) {
                 silent_cerr("unknown drive caller type \"" << s << "\" "
                         "at line " << HP.GetLineData() << std::endl);
                 throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         return func->second->Read(pDM, HP, bDeferred);
 }

Here is the call graph for this function:

Drive* ReadDriveData	(	unsigned	uLabel,
		const DataManager *	pDM,
		MBDynParser &	HP
	)

Definition at line 1283 of file drive_.cc.

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

Referenced by DataManager::ReadDrivers().

 {
         DEBUGCOUTFNAME("ReadDriveData()");
 
         const char *s = HP.IsWord(DriveWordSet);
         if (s == 0) {
                 silent_cerr("ReadDriveData(" << uLabel << "): "
                         "unknown drive type "
                         "at line " << HP.GetLineData() << std::endl);
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         DriveFuncMapType::iterator func = DriveFuncMap.find(std::string(s));
         if (func == DriveFuncMap.end()) {
                 silent_cerr("unknown drive type \"" << s << "\" "
                         "at line " << HP.GetLineData() << std::endl);
                 throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         return func->second->Read(uLabel, pDM, HP);
 }

Here is the call graph for this function:

bool SetDriveCallerData	(	const char *	name,
		DriveCallerRead *	rf
	)

Definition at line 1324 of file drive_.cc.

Referenced by InitDriveCallerData(), InitSF(), mbdyn_octave_set(), minmaxdrive_set(), module_init(), multi_step_drive_set(), nodedistdrive_set(), and switch_drive_set().

 {
         pedantic_cout("registering drive caller \"" << name << "\"" << std::endl);
         return DriveCallerFuncMap.insert(DriveCallerFuncMapType::value_type(name, rf)).second;
 }

bool SetDriveData	(	const std::string &	name,
		DriveRead *	rf
	)

Definition at line 1274 of file drive_.cc.

Referenced by InitDriveData(), and module_init().

 {
         pedantic_cout("registering drive \"" << name << "\"" << std::endl);
         return DriveFuncMap.insert(DriveFuncMapType::value_type(name, rf)).second;
 }

bool setFileDriveCallerType	(	const char *	name,
		FileDriveCallerTypeReader *	rf
	)

Definition at line 2920 of file drive_.cc.

Referenced by module_init().

                                                                             {
         pedantic_cout("registering FileDriveCaller type \"" << name << "\""
                 << std::endl );
         return fileDriveCallerTypeMap.insert(FileDriveCallerTypeMap::value_type(name, rf)).second;
 }