#include <drive_.h>

Inheritance diagram for PiecewiseLinearDriveCaller:

Collaboration diagram for PiecewiseLinearDriveCaller:

Public Member Functions
	PiecewiseLinearDriveCaller (const DriveHandler pDH, unsigned int i, doublereal p)

virtual	~PiecewiseLinearDriveCaller (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
unsigned int	iNumPoints

doublereal *	pPoints

doublereal *	pVals

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 1396 of file drive_.h.

Constructor & Destructor Documentation

PiecewiseLinearDriveCaller::PiecewiseLinearDriveCaller	(	const DriveHandler *	pDH,
		unsigned int	i,
		doublereal *	p
	)

Definition at line 1063 of file drive_.cc.

References ASSERT.

Referenced by pCopy().

 : DriveCaller(pDH), iNumPoints(i), pPoints(p), pVals(p + i)
 {
         ASSERT(i >= 2);
         ASSERT(p != 0);
 }

PiecewiseLinearDriveCaller::~PiecewiseLinearDriveCaller ( void )

virtual

Definition at line 1071 of file drive_.cc.

References pPoints, and SAFEDELETEARR.

 {
         if (pPoints != 0) {
                 SAFEDELETEARR(pPoints);
         }
 }

Member Function Documentation

bool PiecewiseLinearDriveCaller::bIsDifferentiable ( void ) const

inlinevirtual

Reimplemented from DriveCaller.

Definition at line 1449 of file drive_.h.

 {
         return true;
 }

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

inlinevirtual

Implements DriveCaller.

Definition at line 1424 of file drive_.h.

References iNumPoints, MBDYN_EXCEPT_ARGS, pPoints, and pVals.

 {
         if (dVar <= pPoints[0]) {
                 return pVals[0];
         }
 
         if (dVar >= pPoints[iNumPoints - 1]) {
                 return pVals[iNumPoints - 1];
         }
 
         for (unsigned int i = 1; i < iNumPoints; i++) {
                 if (dVar == pPoints[i]) {
                         return pVals[i];
                 }
                 if (dVar < pPoints[i]) {
                         doublereal dx = pPoints[i] - pPoints[i - 1];
                         return ((dVar - pPoints[i - 1])*pVals[i]
                                 + (pPoints[i] - dVar)*pVals[i - 1])/dx;
                 }
         }
 
         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
 }

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

inlinevirtual

Reimplemented from DriveCaller.

Definition at line 1455 of file drive_.h.

References iNumPoints, MBDYN_EXCEPT_ARGS, pPoints, and pVals.

 {
         if (dVar < pPoints[0] || dVar > pPoints[iNumPoints - 1]) {
                 return 0.;
         }
 
         if (dVar == pPoints[0]) {
                 return (pVals[1] - pVals[0])/(pPoints[1] - pPoints[0])/2.;
         }
 
         if (dVar == pPoints[iNumPoints - 1]) {
                 return (pVals[iNumPoints - 1] - pVals[iNumPoints - 2])/(pPoints[iNumPoints - 1] - pPoints[iNumPoints - 2])/2.;
         }
 
         for (unsigned int i = 1; i < iNumPoints; i++) {
                 if (dVar == pPoints[i]) {
                         doublereal dS1 = (pVals[i] - pVals[i - 1])/(pPoints[i] - pPoints[i - 1]);
                         doublereal dS2 = (pVals[i + 1] - pVals[i])/(pPoints[i + 1] - pPoints[i]);
 
                         return (dS1 + dS2)/2.;
                 }
 
                 if (dVar < pPoints[i]) {
                         return (pVals[i] - pVals[i - 1])/(pPoints[i] - pPoints[i - 1]);
                 }
         }
 
         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
 }

DriveCaller * PiecewiseLinearDriveCaller::pCopy ( void ) const

virtual

Implements DriveCaller.

Definition at line 1080 of file drive_.cc.

References iNumPoints, DriveCaller::pDrvHdl, PiecewiseLinearDriveCaller(), pPoints, SAFENEWARR, and SAFENEWWITHCONSTRUCTOR.

 {
         doublereal *p = 0;
         SAFENEWARR(p, doublereal, 2*iNumPoints);
         for (unsigned int i = 0; i < 2*iNumPoints; i++) {
                 p[i] = pPoints[i];
         }
 
         DriveCaller* pDC = 0;
         SAFENEWWITHCONSTRUCTOR(pDC,
                         PiecewiseLinearDriveCaller,
                         PiecewiseLinearDriveCaller(pDrvHdl, iNumPoints, p));
 
         return pDC;
 }

Here is the call graph for this function:

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

virtual

Implements DriveCaller.

Definition at line 1098 of file drive_.cc.

References iNumPoints, pPoints, and pVals.

 {
         out << "piecewise linear, " << iNumPoints;
 
         for (unsigned int i = 0; i < iNumPoints; i++) {
                 out << ", " << pPoints[i] << ", " << pVals[i];
         }
 
         return out;
 }

Member Data Documentation

unsigned int PiecewiseLinearDriveCaller::iNumPoints

private

Definition at line 1398 of file drive_.h.

Referenced by dGet(), dGetP(), pCopy(), and Restart().

doublereal* PiecewiseLinearDriveCaller::pPoints

private

Definition at line 1399 of file drive_.h.

Referenced by dGet(), dGetP(), pCopy(), Restart(), and ~PiecewiseLinearDriveCaller().

doublereal* PiecewiseLinearDriveCaller::pVals

private

Definition at line 1400 of file drive_.h.

Referenced by dGet(), dGetP(), and Restart().

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation