#include <discctrl.h>

Inheritance diagram for DiscreteControlARXProcess_Debug:

Collaboration diagram for DiscreteControlARXProcess_Debug:

Public Member Functions
	DiscreteControlARXProcess_Debug (integer iNumOut, integer iNumIn, integer iOrdA, integer iOrdB, const std::string &infile)

virtual	~DiscreteControlARXProcess_Debug (void)

void	GetInput (std::vector< doublereal > &dIn)

void	PutOutput (const std::vector< doublereal > &dOut, const std::vector< doublereal > &dIn, const std::vector< doublereal > &dDesiredOut)

Public Member Functions inherited from DiscreteControlProcess
virtual	~DiscreteControlProcess (void)

Protected Member Functions
int	ReadMatrix (std::istream &In, doublereal pd, unsigned int iRows, unsigned int iCols, unsigned int iNumSubMats, const char sMatName)

Protected Attributes
integer	iNumOutputs

integer	iNumInputs

integer	iOrderA

integer	iOrderB

doublereal *	pdA

doublereal *	pdY

doublereal *	pdB

doublereal *	pdU

doublereal *	pdU0

integer	iRefA

integer	iRefB

const std::string	infile

Additional Inherited Members
Public Types inherited from DiscreteControlProcess
enum	{ DISCPROC_UNKNOWN = -1, DISCPROC_AR = 0x1U, DISCPROC_MA = 0x2U, DISCPROC_X = 0x4U, DISCPROC_ARX = (DISCPROC_AR \| DISCPROC_X), DISCPROC_ARMA = (DISCPROC_AR \| DISCPROC_MA), DISCPROC_ARMAX = (DISCPROC_AR \| DISCPROC_MA \| DISCPROC_X), DISCPROC_LAST }

Detailed Description

Definition at line 131 of file discctrl.h.

Constructor & Destructor Documentation

DiscreteControlARXProcess_Debug::DiscreteControlARXProcess_Debug	(	integer	iNumOut,
		integer	iNumIn,
		integer	iOrdA,
		integer	iOrdB,
		const std::string &	infile
	)

Definition at line 95 of file discctrl.cc.

References ASSERT, iNumInputs, iNumOutputs, iOrderA, iOrderB, MBDYN_EXCEPT_ARGS, pdA, pdB, pdU, pdU0, pdY, ReadMatrix(), and SAFENEWARR.

 : iNumOutputs(iNumOut),
 iNumInputs(iNumIn),
 iOrderA(iOrdA),
 iOrderB(iOrdB),
 pdA(0),
 pdY(0),
 pdB(0),
 pdU(0),
 pdU0(0),
 iRefA(0),
 iRefB(0)
 {
         /* The control model is handled as follows:
          * the outputs and inputs are stored in two vector:
          * Y = [y(k-1), ..., y(k-pa)], U = [u(k-1), ..., u(k-pb)]
          * as soon as new y, u are available, the oldes values are replaced by
          * the newest and the vector is used as a queue, i.e. it starts from
          * a floating reference and goes back to the beginning when it's
          * over.
          * Mathices alpha, beta are stacked in two big matrtices:
          * A = [alpha_1, ..., alpha_pa], B = [beta_1, ..., beta_pb]
          * the input is calculated as A*Y + B*U
          */
 
         // At present at least one input and one output are required
         ASSERT(iNumInputs > 0);
         ASSERT(iNumOutputs > 0);
         ASSERT(iOrderA > 0);
         ASSERT(iOrderB > 0);
 
         // Size of working area
         int iSize = iNumInputs*iNumOutputs*iOrderA      // Matrix A
                 + iNumInputs*iNumInputs*iOrderB         // Matrix B
                 + iNumOutputs*iOrderA                   // Vector Y
                 + iNumInputs*iOrderB                    // Vector U
                 + iNumInputs;                           // Vector u(k)
 
         doublereal *pd = 0;
         SAFENEWARR(pd, doublereal, iSize);
 
         pdA = pd;
         pd += iNumInputs*iNumOutputs*iOrderA;
 
         pdB = pd;
         pd += iNumInputs*iNumInputs*iOrderB;
 
         pdY = pd;
         pd += iNumOutputs*iOrderA;
 
         pdU = pd;
         pd += iNumInputs*iOrderB;
 
         pdU0 = pd;
 
         for (int i = iSize; i-- > 0; ) {
                 pdA[i] = 0.;
         }
 
         /* In the input file, for human readability matrices are written as:
          * alpha_1,
          * alpha_2,
          * ...
          * alpha_p,
          * beta_1,
          * ...
          * beta_p
          */
 
         std::ifstream In(infile.c_str());
         if (!In) {
                 silent_cerr("DiscreteControlARXProcess_Debug: "
                         "unable to open control data file \"" << infile << "\""
                         << std::endl);
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         ReadMatrix(In, pdA, iNumInputs, iNumOutputs, iOrderA, "alpha");
         ReadMatrix(In, pdB, iNumInputs, iNumInputs, iOrderB, "beta");
 }

Here is the call graph for this function:

DiscreteControlARXProcess_Debug::~DiscreteControlARXProcess_Debug ( void )

virtual

Definition at line 180 of file discctrl.cc.

References pdA, and SAFEDELETEARR.

 {
         /* It must be non-null;
          * matrices and arrays come from one allocation only */
         if (pdA != 0) {
                 SAFEDELETEARR(pdA);
         }
 }

Member Function Documentation

void DiscreteControlARXProcess_Debug::GetInput ( std::vector< doublereal > & dIn )

virtual

Implements DiscreteControlProcess.

Definition at line 190 of file discctrl.cc.

References iNumInputs, and pdU0.

 {
         for (int i = iNumInputs; i-- > 0; ) {
                 dIn[i] = pdU0[i];
         }
 }

void DiscreteControlARXProcess_Debug::PutOutput	(	const std::vector< doublereal > &	dOut,
		const std::vector< doublereal > &	dIn,
		const std::vector< doublereal > &	dDesiredOut
	)

virtual

Implements DiscreteControlProcess.

Definition at line 198 of file discctrl.cc.

References iNumInputs, iNumOutputs, iOrderA, iOrderB, iRefA, iRefB, pdA, pdB, pdU, pdU0, and pdY.

 {
         /* At present dDesiredOutput is not used;
          * it will be when the system is controlled
          * and ID'd at the same time */
 
         // Moves reference backwards
         if (iRefA == 0) {
                 iRefA = iOrderA;
         }
         iRefA--;
 
         doublereal* pdOff = pdY + iNumOutputs*iRefA;
         for (int i = iNumOutputs; i-- > 0; ) {
                 pdOff[i] = dOut[i];
         }
 
         // Moves reference backwards
         if (iRefB == 0) {
                 iRefB = iOrderB;
         }
         iRefB--;
 
         pdOff = pdU + iNumInputs*iRefB;
         for (int i = iNumInputs; i-- > 0; ) {
                 /* dIn contiene la somma dell'ingresso esogeno e dell'ingresso
                  * di controllo, ovvero l'ingresso totale applicato al sistema;
                  * pdU0 contiene il solo ingresso generato dal controllore */
                 pdOff[i] = dIn[i];
                 pdU0[i] = 0.;
         }
 
         // Matrices are row-oriented
         doublereal* pdMatOff = pdA + iOrderA*iNumOutputs*iNumInputs;
         // Y shiftato di iRefA
         doublereal* pdVecOff = pdY + iRefA*iNumOutputs;
         for (int i = iNumInputs; i-- > 0; ) {
                 for (int j = iRefA*iNumOutputs; j-- > 0; ) {
                         pdMatOff--;
                         pdU0[i] += pdMatOff[0]*pdY[j];
                 }
                 for (int j = (iOrderA-iRefA)*iNumOutputs; j-- > 0; ) {
                         pdMatOff--;
                         pdU0[i] += pdMatOff[0]*pdVecOff[j];
                 }
         }
 
         pdMatOff = pdB + iOrderB*iNumInputs*iNumInputs;
         pdVecOff = pdU + iRefB*iNumInputs;
         for (int i = iNumInputs; i-- > 0; ) {
                 for (int j = iRefB*iNumInputs; j-- > 0; ) {
                         pdMatOff--;
                         pdU0[i] += pdMatOff[0]*pdU[j];
                 }
                 for (int j = (iOrderB-iRefB)*iNumInputs; j-- > 0; ) {
                         pdMatOff--;
                         pdU0[i] += pdMatOff[0]*pdVecOff[j];
                 }
         }
 }

int DiscreteControlARXProcess_Debug::ReadMatrix	(	std::istream &	In,
		doublereal *	pd,
		unsigned int	iRows,
		unsigned int	iCols,
		unsigned int	iNumSubMats,
		const char *	sMatName
	)

protected

Definition at line 56 of file discctrl.cc.

References DEBUGLCOUT, MBDYN_EXCEPT_ARGS, and MYDEBUG_INIT.

Referenced by DiscreteControlARXProcess_Debug().

 {
         // Matrices alpha_i
 
         // for every k + 1 = 1->p (every matrix)
         for (unsigned int k = 0; k < iNumSubMats; k++) {
                 int iShift = iNumCols*k;
 
                 // for every row
                 for (unsigned int i = 0; i < iNumRows; i++) {
                         doublereal* pdTmp = pd + iShift + iNumSubMats*iNumCols*i;
 
                         // for every column
                         for (unsigned int j = 0; j < iNumCols; j++) {
                                 In >> pdTmp[j];
                                 if (!In) {
                                         silent_cerr("Error: unexpected end of stream while reading "
                                                 << sMatName << '_' << k + 1
                                                 << '(' << i + 1 << ',' << j + 1 << ')'
                                                 << std::endl);
 
                                         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                                 }
 
                                 DEBUGLCOUT(MYDEBUG_INIT, sMatName << '_' << k + 1
                                         << "(" << i << "," << j << ") = " << pdTmp[j]
                                         << std::endl);
                         }
                 }
         }
 
         return 0;
 }