#include <genfilt.h>

Inheritance diagram for GenelStateSpaceMIMO:

Collaboration diagram for GenelStateSpaceMIMO:

Public Member Functions
	GenelStateSpaceMIMO (unsigned int uLabel, const DofOwner pDO, unsigned int iNumOut, const ScalarDof y, std::vector< ScalarValue * > &u, unsigned int Order, doublereal pE, doublereal pA, doublereal pB, doublereal pC, doublereal pD, bool bBalance, doublereal pdX0, doublereal *pdXP0, flag fOutput)

virtual	~GenelStateSpaceMIMO (void)

virtual unsigned int	iGetNumDof (void) const

virtual DofOrder::Order	GetDofType (unsigned int i) const

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

virtual Genel::Type	GetGenelType (void) const

virtual void	WorkSpaceDim (integer piNumRows, integer piNumCols) const

virtual VariableSubMatrixHandler &	AssJac (VariableSubMatrixHandler &WorkMat, doublereal dCoef, const VectorHandler &, const VectorHandler &)

virtual SubVectorHandler &	AssRes (SubVectorHandler &WorkVec, doublereal, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

void	SetValue (DataManager pDM, VectorHandler &X, VectorHandler &XP, SimulationEntity::Hints ph=0)

virtual void	Output (OutputHandler &OH) const

virtual void	GetConnectedNodes (std::vector< const Node * > &connectedNodes) const

Public Member Functions inherited from Genel
	Genel (unsigned int uL, const DofOwner *pDO, flag fOut)

virtual	~Genel (void)

virtual Elem::Type	GetElemType (void) const

Public Member Functions inherited from Elem
	Elem (unsigned int uL, flag fOut)

virtual	~Elem (void)

virtual std::ostream &	DescribeDof (std::ostream &out, const char *prefix="", bool bInitial=false) const

virtual void	DescribeDof (std::vector< std::string > &desc, bool bInitial=false, int i=-1) const

virtual std::ostream &	DescribeEq (std::ostream &out, const char *prefix="", bool bInitial=false) const

virtual void	DescribeEq (std::vector< std::string > &desc, bool bInitial=false, int i=-1) const

virtual void	AssMats (VariableSubMatrixHandler &WorkMatA, VariableSubMatrixHandler &WorkMatB, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

virtual bool	bInverseDynamics (void) const

void	SetInverseDynamicsFlags (unsigned uIDF)

unsigned	GetInverseDynamicsFlags (void) const

bool	bIsErgonomy (void) const

bool	bIsRightHandSide (void) const

virtual VariableSubMatrixHandler &	AssJac (VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)

virtual SubVectorHandler &	AssRes (SubVectorHandler &WorkVec, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr, const VectorHandler &XPrimePrimeCurr, InverseDynamics::Order iOrder=InverseDynamics::INVERSE_DYNAMICS)

virtual int	GetNumConnectedNodes (void) 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 SimulationEntity
	SimulationEntity (void)

virtual	~SimulationEntity (void)

virtual bool	bIsValidIndex (unsigned int i) const

virtual DofOrder::Order	GetEqType (unsigned int i) const

virtual Hint *	ParseHint (DataManager pDM, const char s) const

virtual void	BeforePredict (VectorHandler &, VectorHandler &, VectorHandler &, VectorHandler &) const

virtual void	AfterPredict (VectorHandler &X, VectorHandler &XP)

virtual void	Update (const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

virtual void	DerivativesUpdate (const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

virtual void	Update (const VectorHandler &XCurr, InverseDynamics::Order iOrder)

virtual void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP)

virtual void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP, const VectorHandler &XPP)

virtual unsigned int	iGetNumPrivData (void) const

virtual unsigned int	iGetPrivDataIdx (const char *s) const

virtual doublereal	dGetPrivData (unsigned int i) const

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

virtual void	ReadInitialState (MBDynParser &HP)

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 ElemWithDofs
	ElemWithDofs (unsigned int uL, const DofOwner *pDO, flag fOut)

virtual	~ElemWithDofs (void)

Public Member Functions inherited from DofOwnerOwner
	DofOwnerOwner (const DofOwner *pDO)

virtual	~DofOwnerOwner ()

virtual const DofOwner *	pGetDofOwner (void) const

virtual integer	iGetFirstIndex (void) const

virtual void	SetInitialValue (VectorHandler &X)

Protected Attributes
unsigned int	iNumOutputs

unsigned int	iNumInputs

ScalarDof *	pvSD_y

std::vector< ScalarValue * >	SV_u

unsigned int	iNumDofs

doublereal *	pdE

doublereal *	pdA

doublereal *	pdB

doublereal *	pdC

doublereal *	pdD

doublereal *	pdX

doublereal *	pdXP

Protected Attributes inherited from WithLabel
unsigned int	uLabel

std::string	sName

Protected Attributes inherited from ToBeOutput
flag	fOutput

Additional Inherited Members
Public Types inherited from Genel
enum	Type { UNKNOWN = -1, SWASHPLATE = 0, ROTORTRIM, CLAMP, DISTANCE, SPRING, SPRINGSUPPORT, CROSSSPRINGSUPPORT, SPRINGDAMPER, SPRINGDAMPERSUPPORT, CROSSSPRINGDAMPERSUPPORT, MASS, SCALARFILTER, STATESPACESISO, STATESPACEMIMO, LASTGENELTYPE }

Public Types inherited from Elem
enum	Type { UNKNOWN = -1, AIRPROPERTIES = 0, INDUCEDVELOCITY, AUTOMATICSTRUCTURAL, GRAVITY, BODY, JOINT, JOINT_REGULARIZATION, BEAM, PLATE, FORCE, INERTIA, ELECTRICBULK, ELECTRIC, THERMAL, HYDRAULIC, BULK, LOADABLE, DRIVEN, EXTERNAL, AEROMODAL, AERODYNAMIC, GENEL, SOCKETSTREAM_OUTPUT, RTAI_OUTPUT = SOCKETSTREAM_OUTPUT, LASTELEMTYPE }

Public Types inherited from SimulationEntity
typedef std::vector< Hint * >	Hints

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

Detailed Description

Definition at line 123 of file genfilt.h.

Constructor & Destructor Documentation

GenelStateSpaceMIMO::GenelStateSpaceMIMO	(	unsigned int	uLabel,
		const DofOwner *	pDO,
		unsigned int	iNumOut,
		const ScalarDof *	y,
		std::vector< ScalarValue * > &	u,
		unsigned int	Order,
		doublereal *	pE,
		doublereal *	pA,
		doublereal *	pB,
		doublereal *	pC,
		doublereal *	pD,
		bool	bBalance,
		doublereal *	pdX0,
		doublereal *	pdXP0,
		flag	fOutput
	)

Definition at line 416 of file genfilt.cc.

References ASSERT, DEBUGCOUT, iNumDofs, iNumInputs, iNumOutputs, pdA, pdB, pdC, pdE, pdX, pdXP, pvSD_y, and SAFENEWARR.

 : Elem(uLabel, fOutput),
 Genel(uLabel, pDO, fOutput),
 iNumOutputs(iNumOut), iNumInputs(u.size()),
 pvSD_y(const_cast<ScalarDof *>(y)), SV_u(u),
 iNumDofs(Order),
 pdE(pE), pdA(pA), pdB(pB), pdC(pC), pdD(pD),
 pdX(0), pdXP(0)
 {
         ASSERT(iNumDofs > 0);
         ASSERT(iNumOutputs > 0);
         ASSERT(pvSD_y != 0);
         for (int i = iNumOutputs; i-- > 0; ) {
                 ASSERT(pvSD_y[i].iOrder == 0);
         }
         ASSERT(iNumInputs > 0);
         ASSERT(pdA != 0);
         ASSERT(pdB != 0);
         ASSERT(pdC != 0);
         DEBUGCOUT("GenelStateSpaceMIMO " << uLabel
                 << ", NumDofs: " << iNumDofs << std::endl);
 
 #ifdef USE_LAPACK
         // try balancing the matrix?
         if (bBalance) {
                 int rc;
                 char JOB = 'S';
                 integer N = Order;
                 integer LDA = Order;
                 integer LDB = Order;
                 integer ILO;
                 integer IHI;
                 integer INFO;
 
                 std::vector<doublereal> RSCALE(Order);
                 std::vector<doublereal> LSCALE(Order);
 
                 if (pdE != 0) {
                         std::vector<doublereal> WORK(6*Order);
 
                         rc = __FC_DECL__(dggbal)(&JOB, &N, pdA, &LDA,
                                 pdE, &LDB, &ILO, &IHI,
                                 &LSCALE[0], &RSCALE[0], &WORK[0], &INFO);
 
                 } else {
                         rc = __FC_DECL__(dgebal)(&JOB, &N, pdA, &LDA,
                                 &ILO, &IHI, &RSCALE[0], &INFO);
 
                         for (unsigned i = 0; i < Order; i++) {
                                 LSCALE[i] = 1./RSCALE[i];
                         }
                 }
 
                 if (INFO != 0) {
                         silent_cout("GenelStateSpaceMIMO(" << uLabel << "): "
                                 "balancing failed (ignored)" << std::endl);
 
                 } else {
                         doublereal *pd = pdB;
 
                         for (unsigned i = 0; i < Order; i++) {
                                 doublereal d = RSCALE[i];
                                 for (unsigned j = 0; j < iNumInputs; j++) {
                                         *pd++ *= d;
                                 }
                         }
         
                         pd = pdC;
                         for (unsigned j = 0; j < iNumOutputs; j++) {
                                 for (unsigned i = 0; i < Order; i++) {
                                         *pd++ *= LSCALE[i];
                                 }
                         }
                 }
         }
 #endif // USE_LAPACK
 
         SAFENEWARR(pdX, doublereal, 2*Order);
         pdXP = pdX + Order;
 
         for (unsigned i = 0; i < 2*Order; i++) {
                 pdX[i] = 0.;
         }
 
         if (pdX0) {
                 for (unsigned i = 0; i < Order; i++) {
                         pdX[i] = pdX0[i];
                 }
 
                 if (pdXP0) {
                         for (unsigned i = 0; i < Order; i++) {
                                 pdXP[i] = pdXP0[i];
                         }
                 }
         }
 }

GenelStateSpaceMIMO::~GenelStateSpaceMIMO ( void )

virtual

Definition at line 527 of file genfilt.cc.

References pdA, pdB, pdC, pdD, pdE, pdX, pvSD_y, SAFEDELETEARR, and SV_u.

 {
         if (pdX != 0) {
                 SAFEDELETEARR(pdX);
         }
 
         if (pdD != 0) {
                 SAFEDELETEARR(pdD);
         }
 
         if (pdC != 0) {
                 SAFEDELETEARR(pdC);
         }
 
         if (pdB != 0) {
                 SAFEDELETEARR(pdB);
         }
 
         if (pdA != 0) {
                 SAFEDELETEARR(pdA);
         }
 
         if (pdE != 0) {
                 SAFEDELETEARR(pdE);
         }
 
         for (std::vector<ScalarValue *>::iterator i = SV_u.begin();
                 i != SV_u.end(); ++i)
         {
                 delete *i;
         }
 
         if (pvSD_y != 0) {
                 SAFEDELETEARR(pvSD_y);
         }
 }

Member Function Documentation

VariableSubMatrixHandler & GenelStateSpaceMIMO::AssJac	(	VariableSubMatrixHandler &	WorkMat,
		doublereal	dCoef,
		const VectorHandler &	,
		const VectorHandler &
	)

virtual

Implements Elem.

Definition at line 599 of file genfilt.cc.

References DEBUGCOUT, Node::iGetFirstColIndex(), DofOwnerOwner::iGetFirstIndex(), Node::iGetFirstRowIndex(), FullSubMatrixHandler::IncCoef(), iNumDofs, iNumInputs, iNumOutputs, ScalarDof::iOrder, pdA, pdB, pdC, pdE, ScalarDof::pNode, FullSubMatrixHandler::PutCoef(), FullSubMatrixHandler::PutColIndex(), FullSubMatrixHandler::PutRowIndex(), pvSD_y, FullSubMatrixHandler::ResizeReset(), VariableSubMatrixHandler::SetFull(), SV_u, and WorkSpaceDim().

 {
         DEBUGCOUT("Entering GenelStateSpaceMIMO::AssJac()" << std::endl);
 
         FullSubMatrixHandler& WM = WorkMat.SetFull();
         integer iNumRows = 0;
         integer iNumCols = 0;
         WorkSpaceDim(&iNumRows, &iNumCols);
         WM.ResizeReset(iNumRows, iNumCols);
 
         // inputs may contribute to the Jacobian matrix
         integer iIdx_u = iNumDofs + iNumOutputs;
         for (unsigned int j = 0; j < iNumInputs; j++) {
                 ScalarDofValue *SDV_u = dynamic_cast<ScalarDofValue *>(SV_u[j]);
                 if (SDV_u != 0) {
                         ScalarDof& SD_u = dynamic_cast<ScalarDof &>(*SV_u[j]);
                         integer iColIndex_u = SD_u.pNode->iGetFirstRowIndex() + 1;
                         iIdx_u += 1;
                         WM.PutColIndex(iIdx_u, iColIndex_u);
 
                         doublereal dd;
                         if (SD_u.iOrder == 0) {
                                 dd = dCoef;
                         } else {
                                 dd = 1.;
                         }
 
                         doublereal *pdb = &pdB[j];
                         for (unsigned int i = 1; i <= iNumDofs; i++) {
                                 WM.PutCoef(i, iIdx_u, pdb[0]*dd);
                                 pdb += iNumInputs;
                         }
                 }
         }
 
         integer iFirstIndex = iGetFirstIndex();
         doublereal* pdc = pdC + iNumOutputs*iNumDofs - 1;
         for (unsigned int i = iNumOutputs; i > 0; i--) {
                 integer iRowIndex_y = pvSD_y[i - 1].pNode->iGetFirstRowIndex() + 1;
                 integer iColIndex_y = pvSD_y[i - 1].pNode->iGetFirstColIndex() + 1;
 
                 WM.PutRowIndex(iNumDofs + i, iRowIndex_y);
                 WM.PutColIndex(iNumDofs + i, iColIndex_y);
                 // 1 sulla diagonale
                 WM.PutCoef(iNumDofs + i, iNumDofs + i, dCoef);
 
                 pdc -= iNumDofs;
                 for (unsigned int j = iNumDofs; j > 0; j--) {
                         /* Attenzione: si assume C orientata per righe:
                          * c_11, c_12, ..., c_1n, c_21, ..., c_2n, ..., c_nn */
                         WM.PutCoef(iNumDofs + i, j, -pdc[j]*dCoef);
                 }
         }
 
         doublereal* pda = pdA + iNumDofs*iNumDofs - 1;
         if (pdE) {
                 doublereal* pde = pdE + iNumDofs*iNumDofs - 1;
 
                 for (unsigned int i = iNumDofs; i > 0; i--) {
                         WM.PutRowIndex(i, iFirstIndex + i);
                         WM.PutColIndex(i, iFirstIndex + i);
                         pde -= iNumDofs;
                         pda -= iNumDofs;
                         for (unsigned int j = iNumDofs; j > 0; j--) {
                                 /* Attenzione: si assume A orientata per righe:
                                  * a_11, a_12, ..., a_1n, a_21, ..., a_2n,
                                  * ..., a_nn */
                                 WM.PutCoef(i, j, pde[j] - pda[j]*dCoef);
                         }
                 }
 
         } else {
                 for (unsigned int i = iNumDofs; i > 0; i--) {
                         WM.PutRowIndex(i, iFirstIndex + i);
                         WM.PutColIndex(i, iFirstIndex + i);
                         pda -= iNumDofs;
                         for (unsigned int j = iNumDofs; j > 0; j--) {
                                 /* Attenzione: si assume A orientata per righe:
                                  * a_11, a_12, ..., a_1n, a_21, ..., a_2n,
                                  * ..., a_nn */
                                 WM.PutCoef(i, j, -pda[j]*dCoef);
                         }
                         WM.IncCoef(i, i, 1.);
                 }
         }
 
         return WorkMat;
 }

Here is the call graph for this function:

SubVectorHandler & GenelStateSpaceMIMO::AssRes	(	SubVectorHandler &	WorkVec,
		doublereal	,
		const VectorHandler &	XCurr,
		const VectorHandler &	XPrimeCurr
	)

virtual

Implements Elem.

Definition at line 693 of file genfilt.cc.

References DEBUGCOUT, ScalarNode::dGetX(), DofOwnerOwner::iGetFirstIndex(), Node::iGetFirstRowIndex(), iNumDofs, iNumInputs, iNumOutputs, pdA, pdB, pdC, pdD, pdE, pdX, pdXP, ScalarDof::pNode, VectorHandler::PutCoef(), SubVectorHandler::PutRowIndex(), pvSD_y, VectorHandler::ResizeReset(), SV_u, and WorkSpaceDim().

 {
         DEBUGCOUT("Entering GenelStateSpaceMIMO::AssRes()" << std::endl);
 
         integer iNumRows = 0;
         integer iNumCols = 0;
         WorkSpaceDim(&iNumRows, &iNumCols);
         WorkVec.ResizeReset(iNumRows);
 
         integer iFirstIndex = iGetFirstIndex();
 
         doublereal* pdx = pdX-1;
         doublereal* pdxp = pdXP-1;
         for (unsigned int i = iNumDofs; i > 0; i--) {
                 WorkVec.PutRowIndex(i, iFirstIndex+i);
                 pdx[i] = XCurr(iFirstIndex+i);
                 pdxp[i] = XPrimeCurr(iFirstIndex+i);
         }
 
         doublereal* pdc = pdC + iNumOutputs*iNumDofs - 1;
         if (pdD != 0) {
                 doublereal* pdd = pdD + iNumOutputs*iNumInputs - 1;
                 for (int i = iNumOutputs; i > 0; i--) {
                         integer iRowIndex_y = pvSD_y[i - 1].pNode->iGetFirstRowIndex()+1;
                         WorkVec.PutRowIndex(iNumDofs+i, iRowIndex_y);
                         doublereal y = pvSD_y[i - 1].pNode->dGetX();
                         doublereal d = -y;
                         pdc -= iNumDofs;
                         for (unsigned int j = iNumDofs; j > 0; j--) {
                                 d += pdc[j]*pdx[j];
                         }
                         pdd -= iNumInputs;
                         for (unsigned int j = iNumInputs; j > 0; j--) {
                                 d += pdd[j]*SV_u[j - 1]->dGetValue();
                         }
                         WorkVec.PutCoef(iNumDofs + i, d);
                 }
 
         } else {
                 for (int i = iNumOutputs; i > 0; i--) {
                         integer iRowIndex_y = pvSD_y[i - 1].pNode->iGetFirstRowIndex() + 1;
                         WorkVec.PutRowIndex(iNumDofs + i, iRowIndex_y);
                         doublereal y = pvSD_y[i - 1].pNode->dGetX();
                         doublereal d = -y;
                         pdc -= iNumDofs;
                         for (unsigned int j = iNumDofs; j > 0; j--) {
                                 d += pdc[j]*pdx[j];
                         }
                         WorkVec.PutCoef(iNumDofs + i, d);
                 }
         }
 
         doublereal* pda = pdA + iNumDofs*iNumDofs;
         doublereal* pdb = pdB + iNumDofs*iNumInputs;
         pdxp = pdXP;
         pdx = pdX;
         if (pdE) {
                 doublereal* pde = pdE + iNumDofs*iNumDofs;
                 for (unsigned int i = iNumDofs; i-- > 0; ) {
                         doublereal d = 0.;
                         pdb -= iNumInputs;
                         for (unsigned int j = iNumInputs; j-- > 0; ) {
                                 d += pdb[j]*SV_u[j]->dGetValue();
                         }
                         pde -= iNumDofs;
                         pda -= iNumDofs;
                         for (unsigned int j = iNumDofs; j-- > 0; ) {
                                 d += pda[j]*pdx[j] - pde[j]*pdxp[j];
                         }
                         WorkVec.PutCoef(i + 1, d);
                 }
 
         } else {
                 for (unsigned int i = iNumDofs; i-- > 0; ) {
                         doublereal d = -pdxp[i];
                         pdb -= iNumInputs;
                         for (unsigned int j = iNumInputs; j-- > 0; ) {
                                 d += pdb[j]*SV_u[j]->dGetValue();
                         }
                         pda -= iNumDofs;
                         for (unsigned int j = iNumDofs; j-- > 0; ) {
                                 d += pda[j]*pdx[j];
                         }
                         WorkVec.PutCoef(i + 1, d);
                 }
         }
 
         return WorkVec;
 }

Here is the call graph for this function:

void GenelStateSpaceMIMO::GetConnectedNodes ( std::vector< const Node * > & connectedNodes ) const

virtual

Reimplemented from Elem.

Definition at line 833 of file genfilt.cc.

References iNumOutputs, NodeDof::pNode, ScalarDof::pNode, pvSD_y, and SV_u.

                                                        {
         unsigned i, iNodes = iNumOutputs;
         for (std::vector<ScalarValue *>::const_iterator u = SV_u.begin();
                 u != SV_u.end(); ++u)
         {
                 if (dynamic_cast<NodeDof *>(*u)) {
                         iNodes++;
                 }
         }
 
         connectedNodes.resize(iNodes);
         for (i = 0; i < iNumOutputs; i++) {
                 connectedNodes[i] = pvSD_y[i].pNode;
         }
 
         for (std::vector<ScalarValue *>::const_iterator u = SV_u.begin();
                 u != SV_u.end(); ++u)
         {
                 NodeDof* ndp = dynamic_cast<NodeDof *>(*u);
                 if (ndp) {
                         connectedNodes[i++] = ndp->pNode;
                 }
         }
 }

DofOrder::Order GenelStateSpaceMIMO::GetDofType ( unsigned int i ) const

virtual

Reimplemented from Elem.

Definition at line 570 of file genfilt.cc.

References ASSERT, DofOrder::DIFFERENTIAL, and iNumDofs.

 {
         ASSERT(i < iNumDofs);
         return DofOrder::DIFFERENTIAL;
 }

virtual Genel::Type GenelStateSpaceMIMO::GetGenelType ( void ) const

inlinevirtual

Implements Genel.

Definition at line 165 of file genfilt.h.

References Genel::STATESPACEMIMO.

                                                    {
                 return Genel::STATESPACEMIMO;
         };

unsigned int GenelStateSpaceMIMO::iGetNumDof ( void ) const

virtual

Reimplemented from Elem.

Definition at line 564 of file genfilt.cc.

References iNumDofs.

 {
         return iNumDofs;
 }

void GenelStateSpaceMIMO::Output ( OutputHandler & OH ) const

virtual

Reimplemented from ToBeOutput.

Definition at line 817 of file genfilt.cc.

References ToBeOutput::bToBeOutput(), OutputHandler::Genels(), WithLabel::GetLabel(), iNumDofs, pdX, and pdXP.

 {
         if (bToBeOutput()) {
                 std::ostream& out(OH.Genels());
                 out << std::setw(8) << GetLabel();
                 for (unsigned int i = 0; i < iNumDofs; i++) {
                         out << " " << pdX[i];
                 }
                 for (unsigned int i = 0; i < iNumDofs; i++) {
                         out << " " << pdXP[i];
                 }
                 out << "\n";
         }
 }

Here is the call graph for this function:

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

virtual

Reimplemented from Genel.

Definition at line 577 of file genfilt.cc.

 {
         return out << "GenelStateSpaceMIMO: not implemented yet!" << std::endl;
 }

void GenelStateSpaceMIMO::SetValue	(	DataManager *	pDM,
		VectorHandler &	X,
		VectorHandler &	XP,
		SimulationEntity::Hints *	ph = `0`
	)

virtual

Reimplemented from SimulationEntity.

Definition at line 787 of file genfilt.cc.

References DofOwnerOwner::iGetFirstIndex(), iNumDofs, iNumInputs, pdA, pdB, pdE, pdX, pdXP, and SV_u.

 {
         integer iFirstIndex = iGetFirstIndex() + 1;
 
         if (pdE == 0) {
                 doublereal* pda = pdA + iNumDofs*iNumDofs;
                 doublereal* pdb = pdB + iNumDofs*iNumInputs;
 
                 for (unsigned int i = iNumDofs; i-- > 0; ) {
                         pdXP[i] = 0.;
                         pdb -= iNumInputs;
                         for (unsigned int j = iNumInputs; j-- > 0; ) {
                                 pdXP[i] += pdb[j]*SV_u[j]->dGetValue();
                         }
                         pda -= iNumDofs;
                         for (unsigned int j = iNumDofs; j-- > 0; ) {
                                 pdXP[i] += pda[j]*pdX[j];
                         }
                 }
         }
 
         for (unsigned i = 0; i < iNumDofs; i++) {
                 X(iFirstIndex + i) = pdX[i];
                 XP(iFirstIndex + i) = pdXP[i];
         }
 }

Here is the call graph for this function:

void GenelStateSpaceMIMO::WorkSpaceDim	(	integer *	piNumRows,
		integer *	piNumCols
	)		const

virtual

Implements Elem.

Definition at line 583 of file genfilt.cc.

References iNumDofs, iNumInputs, iNumOutputs, and SV_u.

Referenced by AssJac(), and AssRes().

 {
         *piNumRows = iNumDofs + iNumOutputs;
         *piNumCols = iNumDofs + iNumOutputs;
 
         // inputs may contribute to the Jacobian matrix
         for (unsigned int j = iNumInputs; j-- > 0; ) {
                 if (dynamic_cast<ScalarDofValue *>(SV_u[j]) != 0) {
                         *piNumCols += 1;
                 }
         }
 }