#include <drive_.h>

Inheritance diagram for FourierSeriesDriveCaller:

Collaboration diagram for FourierSeriesDriveCaller:

Public Member Functions
	FourierSeriesDriveCaller (const DriveHandler *pDH, doublereal dStartTime, doublereal dOmega, std::vector< doublereal > &a, integer iNumCyc, doublereal dInitialValue)

	~FourierSeriesDriveCaller (void)

virtual DriveCaller *	pCopy (void) const

virtual std::ostream &	Restart (std::ostream &out) const

doublereal	dGet (const doublereal &dVar) const

virtual bool	bIsDifferentiable (void) const

virtual doublereal	dGetP (const doublereal &dVar) const

Public Member Functions inherited from DriveCaller
	DriveCaller (const DriveHandler *pDH)

virtual	~DriveCaller (void)

virtual doublereal	dGet (void) const

virtual doublereal	dGetP (void) const

virtual void	SetDrvHdl (const DriveHandler *pDH)

virtual const DriveHandler *	pGetDrvHdl (void) const

virtual void	Output (OutputHandler &OH) const

virtual void	Trace (OutputHandler &OH) const

Public Member Functions inherited from WithLabel
	WithLabel (unsigned int uL=0, const std::string &sN="")

virtual	~WithLabel (void)

void	PutLabel (unsigned int uL)

void	PutName (const std::string &sN)

unsigned int	GetLabel (void) const

const std::string &	GetName (void) const

Public Member Functions inherited from ToBeOutput
	ToBeOutput (flag fOut=fDefaultOut)

virtual	~ToBeOutput (void)

virtual void	OutputPrepare (OutputHandler &OH)

virtual void	Output (OutputHandler &OH, const VectorHandler &X, const VectorHandler &XP) const

virtual flag	fToBeOutput (void) const

virtual bool	bToBeOutput (void) const

virtual void	SetOutputFlag (flag f=flag(1))

Public Member Functions inherited from Traceable
	Traceable (flag fTrace=0)

virtual	~Traceable (void)

virtual flag	fToBeTraced (void) const

virtual void	SetTraceFlag (flag f=TRACE)

Private Attributes
doublereal	dStartTime

doublereal	dOmega

std::vector< doublereal >	amplitudes

integer	iNumCycles

doublereal	dInitialValue

doublereal	dEndTime

bool	bNeverEnd

Additional Inherited Members
Public Types inherited from DriveCaller
enum	OutputFlags { OUTPUT_VALUE = OUTPUT_PRIVATE << 0, OUTPUT_DERIVATIVE = OUTPUT_PRIVATE << 1 }

enum	TraceFlags { TRACE_VALUE = TRACE_PRIVATE << 0, TRACE_DERIVATIVE = TRACE_PRIVATE << 1 }

Public Types inherited from ToBeOutput
enum	{ OUTPUT = 0x1U, OUTPUT_MASK = 0xFU, OUTPUT_PRIVATE = 0x10U, OUTPUT_PRIVATE_MASK = ~OUTPUT_MASK }

Public Types inherited from Traceable
enum	{ TRACE = 0x01U, TRACE_PUBLIC_MASK = 0x0FU, TRACE_PRIVATE = 0x10U, TRACE_PRIVATE_MASK = ~TRACE_PUBLIC_MASK }

Protected Attributes inherited from DriveCaller
DriveHandler *	pDrvHdl

Protected Attributes inherited from WithLabel
unsigned int	uLabel

std::string	sName

Protected Attributes inherited from ToBeOutput
flag	fOutput

Detailed Description

Definition at line 964 of file drive_.h.

Constructor & Destructor Documentation

FourierSeriesDriveCaller::FourierSeriesDriveCaller	(	const DriveHandler *	pDH,
		doublereal	dStartTime,
		doublereal	dOmega,
		std::vector< doublereal > &	a,
		integer	iNumCyc,
		doublereal	dInitialValue
	)

Definition at line 611 of file drive_.cc.

References amplitudes, ASSERT, bNeverEnd, dEndTime, iNumCycles, and M_PI.

Referenced by pCopy().

 : DriveCaller(pDH),
 dStartTime(dStartTime),
 dOmega(dOmega),
 iNumCycles(iNumCyc),
 dInitialValue(dInitialValue),
 bNeverEnd(false)
 {
         ASSERT(iNumCycles >= 0);
 
         if (iNumCycles > 0) {
                 dEndTime = dStartTime
                         + 2.*M_PI/dOmega*doublereal(iNumCycles);
 
         /* Onde di coseno che continuano all'infinito */
         } else if (iNumCycles == 0) {
                 dEndTime = 0.;
                 bNeverEnd = true;
         }
 
         amplitudes.resize(a.size());
         for (unsigned i = 0; i < a.size(); i++) {
                 amplitudes[i] = a[i];
         }
 }

FourierSeriesDriveCaller::~FourierSeriesDriveCaller ( void )

Definition at line 642 of file drive_.cc.

References NO_OP.

 {
         NO_OP;
 }

Member Function Documentation

bool FourierSeriesDriveCaller::bIsDifferentiable ( void ) const

inlinevirtual

Reimplemented from DriveCaller.

Definition at line 1023 of file drive_.h.

 {
         return true;
 }

doublereal FourierSeriesDriveCaller::dGet ( const doublereal & dVar ) const

inlinevirtual

Implements DriveCaller.

Definition at line 1003 of file drive_.h.

References amplitudes, bNeverEnd, grad::cos(), dEndTime, dInitialValue, dOmega, dStartTime, and grad::sin().

 {
         doublereal d = dInitialValue;
 
         if (dVar >= dStartTime && (bNeverEnd || dVar < dEndTime)) {
                 doublereal t = dVar - dStartTime;
 
                 d += amplitudes[0];
 
                 for (unsigned i = 2; i < amplitudes.size(); i += 2 ) {
                         doublereal theta = (i/2)*dOmega*t;
 
                         d += amplitudes[i - 1]*cos(theta) + amplitudes[i]*sin(theta);
                 }
         }
 
         return d;
 }

Here is the call graph for this function:

doublereal FourierSeriesDriveCaller::dGetP ( const doublereal & dVar ) const

inlinevirtual

Reimplemented from DriveCaller.

Definition at line 1029 of file drive_.h.

References amplitudes, bNeverEnd, grad::cos(), dEndTime, dOmega, dStartTime, MBDYN_EXCEPT_ARGS, and grad::sin().

 {
         if (dVar < dStartTime) {
                 return 0.;
         }
 
         if (!bNeverEnd && dVar > dEndTime) {
                 return 0.;
         }
 
         doublereal t = dVar - dStartTime;
         doublereal dVal = 0.;
         bool bSingular = (amplitudes[0] != 0);
         for (unsigned i = 2; i < amplitudes.size(); i += 2 ) {
                 doublereal omega = (i/2)*dOmega;
                 doublereal theta = omega*t;
 
                 dVal += omega*(-amplitudes[i - 1]*sin(theta) + amplitudes[i]*cos(theta));
 
                 if (amplitudes[i - 1] != 0) {
                         bSingular = true;
                 }
         }
 
         if (dVar == dStartTime || (!bNeverEnd && dVar == dEndTime)) {
                 if (bSingular) {
                         silent_cerr("singularity in fourier series drive derivative at " << dVar << std::endl);
                         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                 }
                 dVal /= 2.;
         }
 
         return dVal;
 }

Here is the call graph for this function:

DriveCaller * FourierSeriesDriveCaller::pCopy ( void ) const

virtual

Implements DriveCaller.

Definition at line 649 of file drive_.cc.

References amplitudes, dInitialValue, dOmega, dStartTime, FourierSeriesDriveCaller(), iNumCycles, DriveCaller::pDrvHdl, and SAFENEWWITHCONSTRUCTOR.

 {
         DriveCaller* pDC = 0;
 
         SAFENEWWITHCONSTRUCTOR(pDC,
                 FourierSeriesDriveCaller,
                 FourierSeriesDriveCaller(pDrvHdl,
                         dStartTime,
                         dOmega,
                         amplitudes,
                         iNumCycles,
                         dInitialValue));
         return pDC;
 }

Here is the call graph for this function:

std::ostream & FourierSeriesDriveCaller::Restart ( std::ostream & out ) const

virtual

Implements DriveCaller.

Definition at line 667 of file drive_.cc.

References amplitudes, dInitialValue, dOmega, dStartTime, and iNumCycles.

 {
         out
                 << " fourier series, "
                 << dStartTime << ", "
                 << dOmega << ", "
                 << amplitudes.size()/2 << ", "
                 << 2.*amplitudes[0] << ", ";
 
         for (unsigned i = 1; i < amplitudes.size(); i++) {
                 out << amplitudes[i] << ", ";
         }
 
         out
                 << iNumCycles << ", "
                 << dInitialValue;
 
         return out;
 }