DriveCallerRead Struct Reference

#include <drive.h>

Inheritance diagram for DriveCallerRead:

Public Member Functions
virtual	~DriveCallerRead (void)
virtual DriveCaller *	Read (const DataManager *pDM, MBDynParser &HP, bool bDeferred)=0

Static Public Member Functions
static void	ReadOutput (DriveCaller *pDC, const DataManager *pDM, MBDynParser &HP)

Protected Member Functions
void	NeedDM (const DataManager *pDM, MBDynParser &HP, bool bDeferred, const char *const name)

Detailed Description

Definition at line 739 of file drive.h.

Constructor & Destructor Documentation

DriveCallerRead::~DriveCallerRead ( void  )

virtual

Definition at line 1364 of file drive_.cc.

References NO_OP.

{
        NO_OP;
}

Member Function Documentation

void DriveCallerRead::NeedDM ( const DataManager *  pDM, MBDynParser &  HP, bool  bDeferred, const char *const  name  )

protected

Definition at line 1354 of file drive_.cc.

References IncludeParser::GetLineData(), and MBDYN_EXCEPT_ARGS.

Referenced by MultiStepDriveDCR::Read(), SwitchDriveDCR::Read(), NodeDistDCR::Read(), ScalarFunctionDCR::Read(), TimeDCR::Read(), TimeStepDCR::Read(), MultDCR::Read(), LinearDCR::Read(), ParabolicDCR::Read(), CubicDCR::Read(), StepDCR::Read(), DoubleStepDCR::Read(), RampDCR::Read(), DoubleRampDCR::Read(), SineDCR::Read(), CosineDCR::Read(), TanhDCR::Read(), FourierSeriesDCR::Read(), FrequencySweepDCR::Read(), ExponentialDCR::Read(), RandomDCR::Read(), MeterDCR::Read(), ClosestNextDCR::Read(), DirectDCR::Read(), PiecewiseLinearDCR::Read(), StringDCR::Read(), DofDCR::Read(), ElementDCR::Read(), NodeDCR::Read(), FileDCR::Read(), and PeriodicDCR::Read().

{
        if (pDM == 0 && !bDeferred) {
                silent_cerr("\"" << name << "\" drive caller needs data manager "
                        "at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrNeedDataManager(MBDYN_EXCEPT_ARGS);
        }
}

Here is the call graph for this function:

virtual DriveCaller* DriveCallerRead::Read ( const DataManager *  pDM, MBDynParser &  HP, bool  bDeferred  )

pure virtual

Implemented in PostponedDCR, PeriodicDCR, FileDCR, ArrayDCR, SHDCR, DriveDCR, NodeDCR, ElementDCR, DofDCR, StringDCR, PiecewiseLinearDCR, DirectDCR, ClosestNextDCR, MeterDCR, RandomDCR, ExponentialDCR, FrequencySweepDCR, FourierSeriesDCR, TanhDCR, CosineDCR, SineDCR, DoubleRampDCR, RampDCR, DoubleStepDCR, StepDCR, FunctionDCR, CubicDCR, ParabolicDCR, LinearDCR, ConstDCR, OneDCR, NullDCR, MultDCR, TimeStepDCR, TimeDCR, ScalarFunctionDCR, DummyDCR, MinMaxDriveDCR, GiNaCDCR, NodeDistDCR, SwitchDriveDCR, and MultiStepDriveDCR.

void DriveCallerRead::ReadOutput ( DriveCaller *  pDC, const DataManager *  pDM, MBDynParser &  HP  )

static

Definition at line 1369 of file drive_.cc.

References DriveCaller::bIsDifferentiable(), DataManager::bOutputDriveCallers(), WithLabel::GetLabel(), IncludeParser::GetLineData(), HighParser::GetYesNoOrBool(), HighParser::IsKeyWord(), ToBeOutput::OUTPUT, DriveCaller::OUTPUT_DERIVATIVE, DriveCaller::OUTPUT_VALUE, ToBeOutput::SetOutputFlag(), Traceable::SetTraceFlag(), Traceable::TRACE, DriveCaller::TRACE_DERIVATIVE, and DriveCaller::TRACE_VALUE.

Referenced by MBDynParser::DriveCaller_int().

{
        flag fOutput = pDM->bOutputDriveCallers()
                                        ? DriveCaller::OUTPUT_VALUE
                                        : 0;

        if (HP.IsKeyWord("output")) {
                bool bGotKeyWord = false;

                if (HP.IsKeyWord("value")) {
                        bGotKeyWord = true;

                        if (HP.GetYesNoOrBool()) {
                                fOutput |= DriveCaller::OUTPUT_VALUE;
                        } else {
                                fOutput &= ~DriveCaller::OUTPUT_VALUE;
                        }
                }

                if (HP.IsKeyWord("derivative")) {
                        bGotKeyWord = true;
            
                        if (HP.GetYesNoOrBool()) {
                                fOutput |= DriveCaller::OUTPUT_DERIVATIVE;
                        } else {
                                fOutput &= ~DriveCaller::OUTPUT_DERIVATIVE;
                        }
                }

                if (!bGotKeyWord) {
                        if (HP.GetYesNoOrBool()) {
                                fOutput |= DriveCaller::OUTPUT_VALUE;

                                if (pDC->bIsDifferentiable()) {
                                        fOutput |= DriveCaller::OUTPUT_DERIVATIVE;
                                }
                        } else {
                                fOutput = flag(0);
                        }
                }
        }

        if (fOutput & DriveCaller::OUTPUT_DERIVATIVE) {
                if (!pDC->bIsDifferentiable()) {
                        silent_cerr("warning invalid output flag: drive caller(" << pDC->GetLabel()
                                        << ") is not differentiable at line "
                                        << HP.GetLineData() << std::endl);

                        fOutput &= ~DriveCaller::OUTPUT_DERIVATIVE;
                }
        }

        if (fOutput) {
                fOutput |= DriveCaller::OUTPUT;
        }
    
        pDC->SetOutputFlag(fOutput);

        flag fTrace = 0;

        if (HP.IsKeyWord("output" "trace")) {
                bool bGotKeyWord = false;

                if (HP.IsKeyWord("value")) {
                        bGotKeyWord = true;

                        if (HP.GetYesNoOrBool()) {
                                fTrace |= DriveCaller::TRACE_VALUE;
                        } else {
                                fTrace &= ~DriveCaller::TRACE_VALUE;
                        }
                }

                if (HP.IsKeyWord("derivative")) {
                        bGotKeyWord = true;

                        if (HP.GetYesNoOrBool()) {
                                fTrace |= DriveCaller::TRACE_DERIVATIVE;
                        } else {
                                fTrace &= ~DriveCaller::TRACE_DERIVATIVE;
                        }
                }

                if (!bGotKeyWord) {
                        if (HP.GetYesNoOrBool()) {
                                fTrace |= DriveCaller::TRACE_VALUE;

                                if (pDC->bIsDifferentiable()) {
                                        fTrace |= DriveCaller::TRACE_DERIVATIVE;
                                }
                        } else {
                                fTrace = flag(0);
                        }
                }
        }

        if (fTrace & DriveCaller::TRACE_DERIVATIVE) {
                if (!pDC->bIsDifferentiable()) {
                        silent_cerr("warning invalid trace flag: drive caller (" << pDC->GetLabel()
                                        << ") is not differentiable at line "
                                        << HP.GetLineData() << std::endl);

                        fTrace &= ~DriveCaller::TRACE_DERIVATIVE;
                }
        }

        if (fTrace) {
                fTrace |= DriveCaller::TRACE;
        }
    
        pDC->SetTraceFlag(fTrace);
}

Here is the call graph for this function:

---

The documentation for this struct was generated from the following files:

• drive.h
• drive_.cc