drive.h File Reference

#include <time.h>
#include "ac/f2c.h"
#include "ac/pthread.h"
#include "myassert.h"
#include "mynewmem.h"
#include "mathp.h"
#include "output.h"
#include "solman.h"
#include "withlab.h"

Include dependency graph for drive.h:

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

Go to the source code of this file.

Classes
class	Drive
class	DriveOwner
class	DriveHandler
class	DriveHandler::MyMeter
class	DriveHandler::MyRand
class	DriveHandler::MyClosestNext
class	DriveHandler::MySH
class	DriveCaller
class	NullDriveCaller
class	OneDriveCaller
class	ConstDriveCaller
struct	DriveRead
struct	DriveCallerRead

Functions
bool	SetDriveData (const std::string &s, DriveRead *rf)
Drive *	ReadDriveData (unsigned uLabel, const DataManager *pDM, MBDynParser &HP)
void	InitDriveData (void)
void	DestroyDriveData (void)
bool	SetDriveCallerData (const char *name, DriveCallerRead *rf)
DriveCaller *	ReadDriveCallerData (const DataManager *pDM, MBDynParser &HP, bool bDeferred)
void	InitDriveCallerData (void)
void	DestroyDriveCallerData (void)

Variables
const char *	psDriveNames []
const char *	psReadControlDrivers []

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 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 &	s,
		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;
}

Variable Documentation

const char* psDriveNames[]

Definition at line 351 of file enums.cc.

Referenced by DataManager::DataManager(), DataManager::ElemManagerDestructor(), and DataManager::ReadDrivers().

const char* psReadControlDrivers[]

Definition at line 357 of file enums.cc.

Referenced by DataManager::MakeRestart(), and DataManager::ReadControl().