67 #endif // STATIC_MODULES
74 :
DriveCaller(pDH), sEvalStr(sTmpStr), m_expr(new SharedExpr(expr))
77 ASSERT(m_expr->Get() != 0);
82 const std::string& sTmpStr, SharedExprPtr_t expr)
86 ASSERT(m_expr->Get() != 0);
92 ASSERT(m_expr->Get() != 0);
112 const std::string& sTmpStr)
142 return out <<
"string, \"" <<
sEvalStr <<
"\"";
174 return out <<
"time";
206 return out <<
"timestep";
242 return out <<
"mult, ",
276 return out <<
" const, " <<
dConst;
309 return out <<
" linear, " <<
dC0 <<
", " <<
dC1;
342 return out <<
" parabolic, " <<
dC0 <<
", " <<
dC1 <<
", " <<
dC2;
353 :
DriveCaller(pDH), dC0(d0), dC1(d1), dC2(d2), dC3(d3)
376 return out <<
" cubic, "
388 dStepTime(d1), dStepValue(d2), dInitialValue(d3)
427 dEndStepTime(d3), dInitialValue(d4)
510 dAscendingSlope(d1), dAscendingStartTime(d2), dAscendingEndTime(d3),
511 dDescendingSlope(d4), dDescendingStartTime(d5), dDescendingEndTime(d6),
558 iNumCycles(iNumCyc), dInitialValue(d4), bNeverEnd(
false)
614 std::vector<doublereal>&
a,
618 dStartTime(dStartTime),
621 dInitialValue(dInitialValue),
637 for (
unsigned i = 0; i < a.size(); i++) {
670 <<
" fourier series, "
676 for (
unsigned i = 1; i <
amplitudes.size(); i++) {
698 iNumCycles(iNumCyc), dInitialValue(d4), bNeverEnd(
false)
755 dStart(ds), dA(da), dB(db), dInitialValue(di)
801 pAmplitude(pAmplitude),
802 dInitialValue(d2), dEndTime(d3), dFinalValue(d4),
859 dAmplitude(dA), dTimeConst(dT),
dStartTime(dS), dInitialValue(dI)
932 out <<
", steps, " <<
iSteps;
976 out <<
", steps, " <<
iSteps;
990 pIncrement(pIncrement)
1055 return out <<
" direct";
1065 :
DriveCaller(pDH), iNumPoints(i), pPoints(p), pVals(p + i)
1084 for (
unsigned int i = 0; i < 2*
iNumPoints; i++) {
1102 for (
unsigned int i = 0; i <
iNumPoints; i++) {
1119 for (dcv_t::const_iterator i =
m_dc.begin(); i !=
m_dc.end(); ++i) {
1129 for (dcv_t::iterator i =
m_dc.begin(); i !=
m_dc.end(); ++i) {
1142 for (
unsigned i = 0; i <
m_dc.size(); i++) {
1143 DC[i] =
m_dc[i]->pCopy();
1158 out <<
" array, " <<
m_dc.size();
1160 for (dcv_t::const_iterator i =
m_dc.begin(); i !=
m_dc.end(); ++i) {
1163 out <<
", ", (*i)->Restart(out);
1176 DO(pDC), dT0(dT0), dPeriod(dPeriod)
1201 return out <<
"periodic, " <<
dT0 <<
", " <<
dPeriod <<
", ",
1215 silent_cerr(
"PostponedDriveCaller: unable to resolve postponed drive caller \"" <<
uDriveLabel <<
"\"" << std::endl);
1225 HP(HP), uDriveLabel(uLabel), DO(0)
1241 out <<
", deferred, " <<
uDriveLabel <<
" /* actual drive: ",
1267 return DriveFuncMap.find(s) != DriveFuncMap.end();
1276 pedantic_cout(
"registering drive \"" << name <<
"\"" << std::endl);
1277 return DriveFuncMap.insert(DriveFuncMapType::value_type(name, rf)).second;
1287 const char *s = HP.
IsWord(DriveWordSet);
1289 silent_cerr(
"ReadDriveData(" << uLabel <<
"): "
1290 "unknown drive type "
1295 DriveFuncMapType::iterator
func = DriveFuncMap.find(std::string(s));
1296 if (func == DriveFuncMap.end()) {
1297 silent_cerr(
"unknown drive type \"" << s <<
"\" "
1302 return func->second->Read(uLabel, pDM, HP);
1317 return DriveCallerFuncMap.find(s) != DriveCallerFuncMap.end();
1326 pedantic_cout(
"registering drive caller \"" << name <<
"\"" << std::endl);
1327 return DriveCallerFuncMap.insert(DriveCallerFuncMapType::value_type(name, rf)).second;
1337 const char *s = HP.
IsWord(DriveCallerWordSet);
1339 pedantic_cerr(
"ReadDriveCallerData: warning, assuming \"const\" drive caller at line " << HP.
GetLineData() << std::endl);
1343 DriveCallerFuncMapType::iterator
func = DriveCallerFuncMap.find(std::string(s));
1344 if (func == DriveCallerFuncMap.end()) {
1345 silent_cerr(
"unknown drive caller type \"" << s <<
"\" "
1350 return func->second->Read(pDM, HP, bDeferred);
1355 const char *
const name)
1357 if (pDM == 0 && !bDeferred) {
1358 silent_cerr(
"\"" << name <<
"\" drive caller needs data manager "
1376 bool bGotKeyWord =
false;
1413 silent_cerr(
"warning invalid output flag: drive caller(" << pDC->
GetLabel()
1414 <<
") is not differentiable at line "
1430 bool bGotKeyWord =
false;
1467 silent_cerr(
"warning invalid trace flag: drive caller (" << pDC->
GetLabel()
1468 <<
") is not differentiable at line "
1490 NeedDM(pDM, HP, bDeferred,
"time");
1512 NeedDM(pDM, HP, bDeferred,
"timestep");
1534 NeedDM(pDM, HP, bDeferred,
"mult");
1594 DEBUGCOUT(
"Const value: " << dConst << std::endl);
1600 }
else if (dConst == 1.) {
1618 NeedDM(pDM, HP, bDeferred,
"linear");
1629 DEBUGCOUT(
"Offset: " << dC0 << std::endl);
1632 DEBUGCOUT(
"Slope: " << dC1 << std::endl);
1650 NeedDM(pDM, HP, bDeferred,
"parabolic");
1661 DEBUGCOUT(
"Offset: " << dC0 << std::endl);
1664 DEBUGCOUT(
"Slope: " << dC1 << std::endl);
1667 DEBUGCOUT(
"Parabolic slope: " << dC2 << std::endl);
1685 NeedDM(pDM, HP, bDeferred,
"cubic");
1696 DEBUGCOUT(
"Offset: " << dC0 << std::endl);
1699 DEBUGCOUT(
"Slope: " << dC1 << std::endl);
1702 DEBUGCOUT(
"Parabolic slope: " << dC2 << std::endl);
1705 DEBUGCOUT(
"Cubic slope: " << dC3 << std::endl);
1737 NeedDM(pDM, HP, bDeferred,
"step");
1747 DEBUGCOUT(
"Initial time: " << dStepTime << std::endl);
1750 DEBUGCOUT(
"Step Value: " << dStepValue << std::endl);
1753 DEBUGCOUT(
"InitialValue: " << dInitialValue << std::endl);
1770 NeedDM(pDM, HP, bDeferred,
"double step");
1780 DEBUGCOUT(
"Initial time: " << dStepTime << std::endl);
1783 DEBUGCOUT(
"Final time: " << dEndStepTime << std::endl);
1785 if (dEndStepTime <= dStepTime) {
1786 silent_cerr(
"Warning at line "
1788 <<
": final time " << dEndStepTime
1789 <<
" is less than or equal to initial time " << dStepTime
1790 <<
" in double step func drive" << std::endl);
1794 DEBUGCOUT(
"Step Value: " << dStepValue << std::endl);
1797 DEBUGCOUT(
"InitialValue: " << dInitialValue << std::endl);
1818 NeedDM(pDM, HP, bDeferred,
"ramp");
1829 DEBUGCOUT(
"Slope Value: " << dSlope << std::endl);
1832 DEBUGCOUT(
"Initial time: " << dInitialTime << std::endl);
1834 doublereal dFinalTime = std::numeric_limits<double>::max();
1838 DEBUGCOUT(
"Final time: " << dFinalTime << std::endl);
1840 if (dFinalTime <= dInitialTime) {
1841 silent_cerr(
"Warning at line "
1843 <<
": final time " << dFinalTime
1844 <<
" is less than or equal to initial time " << dInitialTime
1845 <<
" in ramp func drive" << std::endl);
1849 DEBUGCOUT(
"InitialValue: " << dInitialValue << std::endl);
1854 dFinalTime, dInitialValue));
1867 NeedDM(pDM, HP, bDeferred,
"double ramp");
1878 DEBUGCOUT(
"Ascending Slope Value: " << dAscendingSlope << std::endl);
1881 DEBUGCOUT(
"Ascending Initial time: " << dAscendingInitialTime << std::endl);
1884 DEBUGCOUT(
"Ascending Final time: " << dAscendingFinalTime << std::endl);
1886 if (dAscendingFinalTime <= dAscendingInitialTime) {
1887 silent_cerr(
"Warning at line "
1889 << dAscendingFinalTime
1890 <<
" is less than or equal to ascending initial time "
1891 << dAscendingInitialTime
1892 <<
" in double ramp func drive" << std::endl);
1897 DEBUGCOUT(
"Descending Slope Value: " << dDescendingSlope << std::endl);
1899 doublereal dDescendingInitialTime = std::numeric_limits<doublereal>::max();
1901 dDescendingInitialTime = HP.
GetReal();
1903 DEBUGCOUT(
"Descending Initial time: " << dDescendingInitialTime << std::endl);
1905 if (dDescendingInitialTime < dAscendingFinalTime) {
1906 silent_cerr(
"Warning at line "
1907 << HP.
GetLineData() <<
": descending initial time "
1908 << dDescendingInitialTime
1909 <<
" is less than ascending final time "
1910 << dAscendingFinalTime
1911 <<
" in double ramp func drive" << std::endl);
1917 dDescendingFinalTime = std::numeric_limits<doublereal>::max();
1920 dDescendingFinalTime = HP.
GetReal();
1923 DEBUGCOUT(
"Descending Final time: " << dDescendingFinalTime << std::endl);
1925 if (dDescendingFinalTime <= dDescendingInitialTime) {
1926 silent_cerr(
"Warning at line "
1928 << dDescendingFinalTime
1929 <<
" is less than descending initial time "
1930 << dDescendingInitialTime
1931 <<
" in double ramp func drive" << std::endl);
1936 DEBUGCOUT(
"InitialValue: " << dInitialValue << std::endl);
1941 dAscendingSlope, dAscendingInitialTime, dAscendingFinalTime,
1942 dDescendingSlope, dDescendingInitialTime, dDescendingFinalTime,
1967 DEBUGCOUT(
"Initial time: " << dInitialTime << std::endl);
1970 DEBUGCOUT(
"Omega: " << dOmega << std::endl);
1973 DEBUGCOUT(
"Amplitude: " << dAmplitude << std::endl);
1986 iNumCycles = HP.
GetInt();
1988 DEBUGCOUT(
"Number of cycles: " << iNumCycles << std::endl);
1991 DEBUGCOUT(
"InitialValue: " << dInitialValue << std::endl);
1996 SineDriveCaller(pDrvHdl, dInitialTime, dOmega, dAmplitude, iNumCycles, dInitialValue));
2001 CosineDriveCaller(pDrvHdl, dInitialTime, dOmega, dAmplitude, iNumCycles, dInitialValue));
2015 NeedDM(pDM, HP, bDeferred,
"sine");
2028 NeedDM(pDM, HP, bDeferred,
"cosine");
2041 NeedDM(pDM, HP, bDeferred,
"tanh");
2052 DEBUGCOUT(
"Initial time: " << dStart << std::endl);
2055 DEBUGCOUT(
"Amplitude: " << dA << std::endl);
2058 DEBUGCOUT(
"Slope: " << dB << std::endl);
2061 DEBUGCOUT(
"InitialValue: " << dInitialValue << std::endl);
2078 NeedDM(pDM, HP, bDeferred,
"Fourier series");
2088 DEBUGCOUT(
"Initial time: " << dInitialTime << std::endl);
2091 DEBUGCOUT(
"Omega: " << dOmega << std::endl);
2095 silent_cerr(
"FourierSeriesDriveCaller: invalid order " << n
2100 std::vector<doublereal>
a(1 + 2*n);
2101 for (
unsigned i = 0; i < 1 + 2*unsigned(n); i++) {
2116 iNumCycles = HP.
GetInt();
2118 DEBUGCOUT(
"Number of cycles: " << iNumCycles << std::endl);
2119 if (iNumCycles < 0) {
2120 silent_cerr(
"FourierSeriesDriveCaller: invalid number of cycles "
2121 << iNumCycles <<
" at line " << HP.
GetLineData() << std::endl);
2126 DEBUGCOUT(
"InitialValue: " << dInitialValue << std::endl);
2148 NeedDM(pDM, HP, bDeferred,
"frequency sweep");
2158 DEBUGCOUT(
"Initial time: " << dInitialTime << std::endl);
2167 DEBUGCOUT(
"Initial value: " << dInitialValue << std::endl);
2169 doublereal dFinalTime = std::numeric_limits<double>::max();
2173 DEBUGCOUT(
"Final time: " << dFinalTime << std::endl);
2176 DEBUGCOUT(
"Final value: " << dFinalValue << std::endl);
2181 dInitialValue, dFinalTime, dFinalValue));
2194 NeedDM(pDM, HP, bDeferred,
"exponential");
2204 DEBUGCOUT(
"Amplitude value: " << dAmplitude << std::endl);
2207 DEBUGCOUT(
"Time constant value: " << dTimeConst << std::endl);
2210 DEBUGCOUT(
"Initial time: " << dInitialTime << std::endl);
2213 DEBUGCOUT(
"Initial value: " << dInitialValue << std::endl);
2218 dInitialTime, dInitialValue));
2231 NeedDM(pDM, HP, bDeferred,
"random");
2242 DEBUGCOUT(
"Amplitude value: " << dAmplitude << std::endl);
2245 DEBUGCOUT(
"Mean value: " << dRefVal << std::endl);
2248 DEBUGCOUT(
"Initial time: " << dInitialTime << std::endl);
2250 doublereal dFinalTime = std::numeric_limits<double>::max();
2254 DEBUGCOUT(
"Final time: " << dFinalTime << std::endl);
2262 silent_cerr(
"Warning: Steps number " << iSteps
2263 <<
" is illegal; resorting to default value" << std::endl);
2266 DEBUGCOUT(
"Force changes every " << iSteps
2267 <<
" steps" << std::endl);
2271 DEBUGCOUT(
"(Re)Seeding random numbers with current time ...");
2274 DEBUGCOUT(
"(Re)Seeding random numbers with given value ...");
2284 RandDriveCaller(pDrvHdl, dAmplitude, dRefVal, dInitialTime, dFinalTime, iSteps));
2297 NeedDM(pDM, HP, bDeferred,
"meter");
2308 DEBUGCOUT(
"Initial time: " << dInitialTime << std::endl);
2310 doublereal dFinalTime = std::numeric_limits<double>::max();
2314 DEBUGCOUT(
"Final time: " << dFinalTime << std::endl);
2322 silent_cerr(
"Warning: Steps number " << iSteps
2323 <<
" is illegal; resorting to default value" << std::endl);
2326 DEBUGCOUT(
"Force changes every " << iSteps
2327 <<
" steps" << std::endl);
2348 NeedDM(pDM, HP, bDeferred,
"closest next");
2358 DEBUGCOUT(
"Initial time: " << dInitialTime << std::endl);
2360 doublereal dFinalTime = std::numeric_limits<double>::max();
2364 DEBUGCOUT(
"Final time: " << dFinalTime << std::endl);
2384 NeedDM(pDM, HP, bDeferred,
"direct");
2408 NeedDM(pDM, HP, bDeferred,
"piecewise linear");
2418 unsigned int n = HP.
GetInt();
2419 DEBUGCOUT(
"number of points: " << n << std::endl);
2422 silent_cerr(
"Need at least two points for piecewise linear drive at line "
2431 for (
unsigned int i = 1; i < n; i++) {
2433 if (p[i] <= p[i-1]) {
2434 silent_cerr(
"point " << p[i]
2435 <<
" is smaller than or equal to preceding point " << p[i-1]
2459 NeedDM(pDM, HP, bDeferred,
"string");
2473 std::istringstream in(s);
2480 pedantic_cout(
"StringDriveCaller: \"" << s <<
"\" => \"" << out <<
"\"" << std::endl);
2491 #define TRIM_ALL_SPACES_BUT_ONE
2493 #if defined(TRIM_ALL_SPACES)
2494 for (std::string::iterator i = s.begin(); i != s.end();) {
2502 #elif defined(TRIM_ALL_SPACES_BUT_ONE)
2503 bool bString(
false);
2504 for (std::string::iterator i = s.begin(); i != s.end();) {
2521 #endif // TRIM_ALL_SPACES_BUT_ONE
2523 DEBUGCOUT(
"String to evaluate: \"" << s <<
'\"' << std::endl);
2543 NeedDM(pDM, HP, bDeferred,
"dof");
2554 silent_cerr(
"sorry, since the driver is not owned by a DataManager" << std::endl
2555 <<
"no DOF dependent drivers are allowed;" << std::endl
2556 <<
"aborting..." << std::endl);
2563 if (MPI::Is_initialized() && MBDynComm.Get_size() > 1) {
2564 silent_cerr(
"warning: add explicit connection entry for "
2600 unsigned int iIndex = 0;
2601 std::string sIndexName;
2604 if (sIndexName.empty()) {
2605 silent_cerr(
"empty string for " << msg
2612 silent_cerr(
"illegal string \"" << sIndexName <<
"\""
2620 silent_cout(
"\"index\" deprecated for " << msg
2621 <<
"; use \"string\" instead at line " << HP.
GetLineData() << std::endl);
2629 silent_cerr(
"need a private data index for " << msg
2635 silent_cerr(
"illegal index " << iIndex <<
" for " << msg
2642 if (MPI::Is_initialized() && MBDynComm.Get_size() > 1) {
2643 silent_cerr(
"warning: add explicit connection entry for " << msg
2668 NeedDM(pDM, HP, bDeferred,
"element");
2672 silent_cerr(
"since the driver is not owned by a DataManager" << std::endl
2673 <<
"no element dependent drivers are allowed;" << std::endl
2674 <<
"aborting..." << std::endl);
2678 unsigned uLabel = HP.
GetInt();
2683 silent_cerr(
"unknown element type \"" << s
2690 std::ostringstream os;
2695 silent_cerr(
"unable to find " << os.str() <<
" at line "
2711 NeedDM(pDM, HP, bDeferred,
"node");
2715 silent_cerr(
"since the driver is not owned by a DataManager" << std::endl
2716 <<
"no node dependent drivers are allowed;" << std::endl
2717 <<
"aborting..." << std::endl);
2721 unsigned uLabel = HP.
GetInt();
2726 silent_cerr(
"unknown node type \"" << s
2733 std::ostringstream os;
2738 silent_cerr(
"unable to find " << os.str() <<
" at line "
2817 unsigned short int iNumDr = (
unsigned short int)HP.
GetInt();
2819 silent_cerr(
"Sorry, at least one driver is required" << std::endl);
2823 }
else if (iNumDr == 1) {
2828 for (
int i = 0; i < iNumDr; i++) {
2849 NeedDM(pDM, HP, bDeferred,
"file");
2853 silent_cerr(
"sorry, since the driver is not owned by a DataManager" << std::endl
2854 <<
"no driver dependent drivers are allowed;" << std::endl
2855 <<
"aborting..." << std::endl);
2864 unsigned int uL = HP.
GetInt();
2868 <<
": can't find FileDrive(" << uL <<
")" << std::endl);
2877 id = it->second->Read(pDM, HP, pDrv);
2883 <<
": invalid column number " <<
id
2884 <<
" (must be between 1 and "
2917 return fileDriveCallerTypeMap.find(std::string(s)) != fileDriveCallerTypeMap.end();
2921 pedantic_cout(
"registering FileDriveCaller type \"" << name <<
"\""
2923 return fileDriveCallerTypeMap.insert(FileDriveCallerTypeMap::value_type(name, rf)).second;
2927 for (FileDriveCallerTypeMap::iterator i = fileDriveCallerTypeMap.begin(); i != fileDriveCallerTypeMap.end(); ++i) {
2930 fileDriveCallerTypeMap.clear();
2943 NeedDM(pDM, HP, bDeferred,
"periodic");
2947 silent_cerr(
"sorry, since the driver is not owned by a DataManager" << std::endl
2948 <<
"no driver dependent drivers are allowed;" << std::endl
2949 <<
"aborting..." << std::endl);
2958 if (dPeriod <= 0.) {
2959 silent_cerr(
"PeriodicDriveCaller: invalid negative or null period at line " << HP.
GetLineData() << std::endl);
2984 silent_cerr(
"PostponedDriveCaller: invalid negative label \"" << label <<
"\" at line " << HP.
GetLineData() << std::endl);
3004 if (::d_done++ > 0) {
3015 #endif // USE_SOCKET
3030 if (::d_done == 0) {
3031 silent_cerr(
"DestroyDriveData() called once too many" << std::endl);
3035 if (--::d_done > 0) {
3040 for (DriveFuncMapType::iterator i = DriveFuncMap.begin(); i != DriveFuncMap.end(); ++i) {
3043 DriveFuncMap.clear();
3052 if (::dc_done++ > 0) {
3103 #ifdef STATIC_MODULES
3106 #endif // USE_OCTAVE
3109 #endif // STATIC_MODULES
3115 if (::dc_done == 0) {
3116 silent_cerr(
"DestroyDriveCallerData() called once too many" << std::endl);
3120 if (--::dc_done > 0) {
3125 for (DriveCallerFuncMapType::iterator i = DriveCallerFuncMap.begin(); i != DriveCallerFuncMap.end(); ++i) {
3128 DriveCallerFuncMap.clear();
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
virtual std::ostream & Restart(std::ostream &out) const
virtual DriveCaller * pCopy(void) const
virtual ~ParabolicDriveCaller(void)
bool bOutputDriveCallers(void) const
virtual bool IsWord(const std::string &s) const
virtual DriveCaller * pCopy(void) const
Drive * pFindDrive(Drive::Type Typ, unsigned int uL) const
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
TimeDriveCaller(const DriveHandler *pDH)
DriveArrayCaller(const DriveHandler *pDH, dcv_t &DC)
virtual std::ostream & Restart(std::ostream &out) const
std::vector< doublereal > amplitudes
virtual ~DriveArrayCaller(void)
virtual std::ostream & Restart(std::ostream &out) const
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
static DriveCallerWordSetType DriveCallerWordSet
bool SetDriveData(const std::string &name, DriveRead *rf)
const DriveCaller * pAmplitude
const char * psReadNodesNodes[]
virtual DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred, bool bSine)
#define MBDYN_EXCEPT_ARGS
bool IsWord(const std::string &s) const
virtual ~ConstDriveCaller(void)
virtual std::ostream & Restart(std::ostream &out) const
static DriveCallerFuncMapType DriveCallerFuncMap
#define DEBUGCOUTFNAME(fname)
virtual ~LinearDriveCaller(void)
virtual integer GetInt(integer iDefval=0)
bool IsWord(const std::string &s) const
virtual DriveCaller * pCopy(void) const
virtual const char * IsWord(const HighParser::WordSet &ws)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
virtual DriveCaller * pCopy(void) const
virtual DriveCaller * pCopy(void) const
bool setFileDriveCallerType(const char *name, FileDriveCallerTypeReader *rf)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
const DriveCaller * GetDrive(unsigned uLabel) const
void DestroyDriveData(void)
virtual DriveCaller * pCopy(void) const
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
virtual const DriveHandler * pGetDrvHdl(void) const
virtual std::ostream & Restart(std::ostream &out) const
virtual unsigned int iGetPrivDataIdx(const char *s) const
virtual DriveCaller * pCopy(void) const
static DriveWordSetType DriveWordSet
#define SAFEDELETEARR(pnt)
virtual DriveCaller * pCopy(void) const
virtual ~ClosestNextDriveCaller(void)
FileDriveCallerTypeMap fileDriveCallerTypeMap
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
CubicDriveCaller(const DriveHandler *pDH, doublereal d0, doublereal d1, doublereal d2, doublereal d3)
virtual ~RandDriveCaller(void)
const std::string sEvalStr
MeterDriveCaller(const DriveHandler *pDH, doublereal dS, doublereal dE, integer iS)
void DestroyFileDriveCallerTypes(void)
CosineDriveCaller(const DriveHandler *pDH, doublereal d1, doublereal d2, doublereal d3, integer iNumCyc, doublereal d4)
const DriveHandler * pGetDrvHdl(void) const
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
ClosestNextDriveCaller(const DriveHandler *pDH, doublereal dS, doublereal dE, const DriveCaller *pIncrement)
bool SetDriveCallerData(const char *name, DriveCallerRead *rf)
virtual DriveCaller * pCopy(void) const
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
doublereal dAscendingEndTime
virtual ~PeriodicDriveCaller(void)
virtual std::ostream & Restart(std::ostream &out) const
virtual DriveCaller * pCopy(void) const
LinearDriveCaller(const DriveHandler *pDH, doublereal d0, doublereal d1)
virtual DriveCaller * pCopy(void) const
FileDriveCallerTypeWordSet fileDriveCallerTypeWordSet
virtual ~DirectDriveCaller(void)
virtual std::ostream & Restart(std::ostream &out) const
virtual std::ostream & Restart(std::ostream &out) const
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
doublereal dDescendingSlope
virtual std::ostream & Restart(std::ostream &out) const =0
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
virtual bool GetYesNoOrBool(bool bDefval=false)
virtual std::ostream & Restart(std::ostream &out) const
virtual ~PiecewiseLinearDriveCaller(void)
virtual DriveCaller * pCopy(void) const
virtual ~DriveCallerRead(void)
void func(const T &u, const T &v, const T &w, doublereal e, T &f)
virtual std::ostream & Restart(std::ostream &out) const
virtual std::ostream & Restart(std::ostream &out) const
virtual DriveCaller * pCopy(void) const
Elem * pFindElem(Elem::Type Typ, unsigned int uElem, unsigned int iDeriv) const
virtual DriveCaller * pCopy(void) const
ParabolicDriveCaller(const DriveHandler *pDH, doublereal d0, doublereal d1, doublereal d2)
virtual ~ExpDriveCaller(void)
doublereal dAscendingStartTime
virtual DriveCaller * pCopy(void) const
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
virtual void SetDrvHdl(const DriveHandler *pDH)
~DoubleRampDriveCaller(void)
virtual DriveCaller * pCopy(void) const
integer iMeterInit(integer iSteps)
virtual DriveCaller * pCopy(void) const
virtual bool bIsDifferentiable(void) const
std::vector< const DriveCaller * > dcv_t
#define SAFENEW(pnt, item)
RampDriveCaller(const DriveHandler *pDH, doublereal d1, doublereal d2, doublereal d3, doublereal d4)
virtual ~MultDriveCaller(void)
virtual DriveCaller * pCopy(void) const
doublereal dDescendingEndTime
DoubleStepDriveCaller(const DriveHandler *pDH, doublereal d1, doublereal d2, doublereal d3, doublereal d4)
virtual std::ostream & Restart(std::ostream &out) const
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
virtual bool IsKeyWord(const char *sKeyWord)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
void DestroyDriveCallerData(void)
virtual std::ostream & Restart(std::ostream &out) const
integer iMeterDriveNumber
virtual ~TimeDriveCaller(void)
virtual std::ostream & Restart(std::ostream &out) const
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
virtual DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
~FourierSeriesDriveCaller(void)
virtual DriveCaller * pCopy(void) const
virtual std::ostream & Restart(std::ostream &out) const
virtual DriveCaller * pCopy(void) const
virtual const char * GetStringWithDelims(enum Delims Del=DEFAULTDELIM, bool escape=true)
virtual std::ostream & Restart(std::ostream &out) const
~FreqSweepDriveCaller(void)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, const SimulationEntity *pSE, const std::string &msg)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
ExpDriveCaller(const DriveHandler *pDH, doublereal dA, doublereal dT, doublereal dS, doublereal dI)
virtual std::ostream & Restart(std::ostream &out) const
virtual std::ostream & Restart(std::ostream &out) const
std::string EEStrOut(const ExpressionElement *e)
virtual MathParser & GetMathParser(void)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
const DriveCaller * pOmega
virtual integer iGetNumDrives(void) const
Drive * ReadDriveData(unsigned uLabel, const DataManager *pDM, MBDynParser &HP)
virtual std::ostream & Restart(std::ostream &out) const
#define ASSERT(expression)
std::map< std::string, DriveRead *, ltstrcase > DriveFuncMapType
virtual ~MeterDriveCaller(void)
DirectDriveCaller(const DriveHandler *pDH)
virtual DriveCaller * pCopy(void) const
#define SAFENEWWITHCONSTRUCTOR(pnt, item, constructor)
DriveCaller * pGetDriveCaller(void) const
virtual std::ostream & Restart(std::ostream &out) const
integer iRandInit(integer iSteps)
StringDriveCaller(const DriveHandler *pDH, const std::string &sTmpStr)
virtual DriveCaller * pCopy(void) const =0
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
RandDriveCaller(const DriveHandler *pDH, doublereal dA, doublereal dR, doublereal dS, doublereal dE, integer iS)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
std::map< std::string, FileDriveCallerTypeReader * > FileDriveCallerTypeMap
virtual unsigned int iGetNumPrivData(void) const
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
virtual std::string GetString(const std::string &sDefVal)
virtual ~TimeStepDriveCaller(void)
const char * psNodeNames[]
virtual std::ostream & Restart(std::ostream &out) const
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
virtual DriveCaller * pCopy(void) const
const DriveCaller * pIncrement
PostponedDriveCaller(MBDynParser &HP, unsigned uLabel)
std::map< std::string, DriveCallerRead *, ltstrcase > DriveCallerFuncMapType
virtual ~PostponedDriveCaller(void)
virtual std::ostream & Restart(std::ostream &out) const
virtual void SetTraceFlag(flag f=TRACE)
virtual Node::Type GetNodeType(void) const =0
virtual std::ostream & Restart(std::ostream &out) const
StepDriveCaller(const DriveHandler *pDH, doublereal d1, doublereal d2, doublereal d3)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
const char * psElemNames[]
bool mbdyn_octave_set(void)
FourierSeriesDriveCaller(const DriveHandler *pDH, doublereal dStartTime, doublereal dOmega, std::vector< doublereal > &a, integer iNumCyc, doublereal dInitialValue)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
PiecewiseLinearDriveCaller(const DriveHandler *pDH, unsigned int i, doublereal *p)
void Set(const DriveCaller *pDC)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
static DriveFuncMapType DriveFuncMap
DriveCaller * ReadDriveCallerData(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
const char * psReadElemsElems[]
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
ConstDriveCaller(doublereal d)
#define SAFENEWARR(pnt, item, sz)
virtual DriveCaller * pCopy(void) const
virtual DriveCaller * pCopy(void) const
DriveCaller * GetDriveCaller(bool bDeferred=false)
static const doublereal a
integer iClosestNextInit(const DriveCaller *pIncrement, doublereal dStartTime)
virtual ~CubicDriveCaller(void)
void NeedDM(const DataManager *pDM, MBDynParser &HP, bool bDeferred, const char *const name)
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
static void ReadOutput(DriveCaller *pDC, const DataManager *pDM, MBDynParser &HP)
TimeStepDriveCaller(const DriveHandler *pDH)
virtual void SetOutputFlag(flag f=flag(1))
DriveCaller * Read(const DataManager *pDM, MBDynParser &HP, bool bDeferred)
void InitDriveCallerData(void)
TanhDriveCaller(const DriveHandler *pDH, doublereal ds, doublereal da, doublereal db, doublereal di)
MultDriveCaller(const DriveHandler *pDH, const DriveCaller *pDC1, const DriveCaller *pDC2)
virtual std::ostream & Restart(std::ostream &out) const
DriveCaller * Read(const DataManager *, MBDynParser &, bool)
PeriodicDriveCaller(const DriveHandler *pDH, const DriveCaller *pDC, doublereal dT0, doublereal dPeriod)
~DoubleStepDriveCaller(void)
virtual HighParser::ErrOut GetLineData(void) const
virtual ~SineCosineDCR(void)
DriveCaller * Read(const DataManager *, MBDynParser &, bool)
unsigned int GetLabel(void) const
SineDriveCaller(const DriveHandler *pDH, doublereal d1, doublereal d2, doublereal d3, integer iNumCyc, doublereal d4)
Node * pFindNode(Node::Type Typ, unsigned int uNode) const
DoubleRampDriveCaller(const DriveHandler *pDH, doublereal d1, doublereal d2, doublereal d3, doublereal d4, doublereal d5, doublereal d6, doublereal d7)
doublereal dDescendingStartTime
virtual DriveCaller * pCopy(void) const
doublereal dAscendingSlope
FreqSweepDriveCaller(const DriveHandler *pDH, doublereal d1, const DriveCaller *pOmega, const DriveCaller *pAmplitude, doublereal d2, doublereal d3, doublereal d4)
virtual DriveCaller * pCopy(void) const
ScalarDof ReadScalarDof(const DataManager *pDM, MBDynParser &HP, bool bDof, bool bOrder)
virtual std::ostream & Restart(std::ostream &out) const
virtual std::ostream & Restart(std::ostream &out) const
virtual doublereal GetReal(const doublereal &dDefval=0.0)