actuator.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of ACADO Toolkit.
3  *
4  * ACADO Toolkit -- A Toolkit for Automatic Control and Dynamic Optimization.
5  * Copyright (C) 2008-2014 by Boris Houska, Hans Joachim Ferreau,
6  * Milan Vukov, Rien Quirynen, KU Leuven.
7  * Developed within the Optimization in Engineering Center (OPTEC)
8  * under supervision of Moritz Diehl. All rights reserved.
9  *
10  * ACADO Toolkit is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 3 of the License, or (at your option) any later version.
14  *
15  * ACADO Toolkit is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with ACADO Toolkit; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  *
24  */
25 
26 
34 #include <acado/transfer_device/actuator.hpp>
35 
36 
37 
38 BEGIN_NAMESPACE_ACADO
39 
40 
41 
42 //
43 // PUBLIC MEMBER FUNCTIONS:
44 //
45 
46 Actuator::Actuator( ) : TransferDevice( BN_ACTUATOR )
47 {
48  nU = 0;
49  nP = 0;
50 }
51 
52 
53 Actuator::Actuator( uint _nU,
54  uint _nP,
55  double _samplingTime
56  ) : TransferDevice( _nU+_nP,BN_ACTUATOR,_samplingTime )
57 {
58  nU = _nU;
59  nP = _nP;
60 }
61 
62 
63 Actuator::Actuator( const Actuator& rhs ) : TransferDevice( rhs )
64 {
65  nU = rhs.nU;
66  nP = rhs.nP;
67 }
68 
69 
70 Actuator::~Actuator( )
71 {
72 }
73 
74 
75 Actuator& Actuator::operator=( const Actuator& rhs )
76 {
77  if ( this != &rhs )
78  {
79  TransferDevice::operator=( rhs );
80 
81  nU = rhs.nU;
82  nP = rhs.nP;
83  }
84 
85  return *this;
86 }
87 
88 
89 returnValue Actuator::setControlNoise( const Noise& _noise,
90  double _noiseSamplingTime
91  )
92 {
93  if ( _noise.getDim( ) != getNU( ) )
94  return ACADOERROR( RET_INVALID_ARGUMENTS );
95 
96  for( uint i=0; i<getNU( ); ++i )
97  {
98  if ( additiveNoise[i] != 0 )
99  delete additiveNoise[i];
100 
101  additiveNoise[i] = _noise.clone( i );
102  }
103 
104  noiseSamplingTimes.setAll( _noiseSamplingTime );
105 
106  return SUCCESSFUL_RETURN;
107 }
108 
109 
110 returnValue Actuator::setControlNoise( uint idx,
111  const Noise& _noise,
112  double _noiseSamplingTime
113  )
114 {
115  if ( ( idx >= getNU( ) ) || ( _noise.getDim( ) != 1 ) )
116  return ACADOERROR( RET_INVALID_ARGUMENTS );
117 
118  if ( additiveNoise[idx] != 0 )
119  delete additiveNoise[idx];
120 
121  additiveNoise[idx] = _noise.clone( );
122 
123  if ( ( idx > 0 ) && ( acadoIsEqual( _noiseSamplingTime, noiseSamplingTimes(0) ) == BT_FALSE ) )
124  ACADOWARNING( RET_NO_DIFFERENT_NOISE_SAMPLING_FOR_DISCRETE );
125 
126  noiseSamplingTimes.setAll( _noiseSamplingTime ); // should be changed later
127 
128  return SUCCESSFUL_RETURN;
129 }
130 
131 
132 returnValue Actuator::setParameterNoise( const Noise& _noise,
133  double _noiseSamplingTime
134  )
135 {
136  if ( _noise.getDim( ) != getNP( ) )
137  return ACADOERROR( RET_INVALID_ARGUMENTS );
138 
139  for( uint i=0; i<getNP( ); ++i )
140  {
141  if ( additiveNoise[ getNU()+i ] != 0 )
142  delete additiveNoise[ getNU()+i ];
143 
144  additiveNoise[ getNU()+i ] = _noise.clone( i );
145  }
146 
147  noiseSamplingTimes.setAll( _noiseSamplingTime );
148 
149  return SUCCESSFUL_RETURN;
150 }
151 
152 
153 returnValue Actuator::setParameterNoise( uint idx,
154  const Noise& _noise,
155  double _noiseSamplingTime
156  )
157 {
158  if ( ( idx >= getNP( ) ) || ( _noise.getDim( ) != 1 ) )
159  return ACADOERROR( RET_INVALID_ARGUMENTS );
160 
161  if ( additiveNoise[ getNU()+idx ] != 0 )
162  delete additiveNoise[ getNU()+idx ];
163 
164  additiveNoise[ getNU()+idx ] = _noise.clone( );
165 
166  if ( ( idx > 0 ) && ( acadoIsEqual( _noiseSamplingTime, noiseSamplingTimes(0) ) == BT_FALSE ) )
167  ACADOWARNING( RET_NO_DIFFERENT_NOISE_SAMPLING_FOR_DISCRETE );
168 
169  noiseSamplingTimes.setAll( _noiseSamplingTime ); // should be changed later
170 
171  return SUCCESSFUL_RETURN;
172 }
173 
174 
175 
176 returnValue Actuator::setControlDeadTimes( const DVector& _deadTimes
177  )
178 {
179  if ( _deadTimes.getDim( ) != getNU( ) )
180  return ACADOERROR( RET_INVALID_ARGUMENTS );
181 
182  if ( _deadTimes.getMin( ) < 0.0 )
183  return ACADOERROR( RET_INVALID_ARGUMENTS );
184 
185  if ( deadTimes.getDim( ) == 0 )
186  return ACADOERROR( RET_MEMBER_NOT_INITIALISED );
187 
188  for( uint i=0; i<getNU(); ++i )
189  deadTimes( i ) = _deadTimes( i );
190 
191  return SUCCESSFUL_RETURN;
192 }
193 
194 
195 returnValue Actuator::setControlDeadTimes( double _deadTime
196  )
197 {
198  if ( _deadTime < 0.0 )
199  return ACADOERROR( RET_INVALID_ARGUMENTS );
200 
201  if ( deadTimes.getDim( ) == 0 )
202  return ACADOERROR( RET_MEMBER_NOT_INITIALISED );
203 
204  for( uint i=0; i<getNU(); ++i )
205  deadTimes( i ) = _deadTime;
206 
207  return SUCCESSFUL_RETURN;
208 }
209 
210 
211 returnValue Actuator::setControlDeadTime( uint idx,
212  double _deadTime
213  )
214 {
215  if ( idx >= getNU( ) )
216  return ACADOERROR( RET_INVALID_ARGUMENTS );
217 
218  if ( _deadTime < 0.0 )
219  return ACADOERROR( RET_INVALID_ARGUMENTS );
220 
221  if ( deadTimes.getDim( ) == 0 )
222  return ACADOERROR( RET_MEMBER_NOT_INITIALISED );
223 
224  deadTimes( idx ) = _deadTime;
225 
226  return SUCCESSFUL_RETURN;
227 }
228 
229 
230 
231 returnValue Actuator::setParameterDeadTimes( const DVector& _deadTimes
232  )
233 {
234  if ( _deadTimes.getDim( ) != getNP( ) )
235  return ACADOERROR( RET_INVALID_ARGUMENTS );
236 
237  if ( _deadTimes.getMin( ) < 0.0 )
238  return ACADOERROR( RET_INVALID_ARGUMENTS );
239 
240  if ( deadTimes.getDim( ) == 0 )
241  return ACADOERROR( RET_MEMBER_NOT_INITIALISED );
242 
243  for( uint i=0; i<getNP(); ++i )
244  deadTimes( getNU()+i ) = _deadTimes( i );
245 
246  return SUCCESSFUL_RETURN;
247 }
248 
249 
250 returnValue Actuator::setParameterDeadTimes( double _deadTime
251  )
252 {
253  if ( _deadTime < 0.0 )
254  return ACADOERROR( RET_INVALID_ARGUMENTS );
255 
256  if ( deadTimes.getDim( ) == 0 )
257  return ACADOERROR( RET_MEMBER_NOT_INITIALISED );
258 
259  for( uint i=0; i<getNP(); ++i )
260  deadTimes( getNU()+i ) = _deadTime;
261 
262  return SUCCESSFUL_RETURN;
263 }
264 
265 
266 returnValue Actuator::setParameterDeadTime( uint idx,
267  double _deadTime
268  )
269 {
270  if ( idx >= getNP( ) )
271  return ACADOERROR( RET_INVALID_ARGUMENTS );
272 
273  if ( _deadTime < 0.0 )
274  return ACADOERROR( RET_INVALID_ARGUMENTS );
275 
276  if ( deadTimes.getDim( ) == 0 )
277  return ACADOERROR( RET_MEMBER_NOT_INITIALISED );
278 
279  deadTimes( getNU()+idx ) = _deadTime;
280 
281  return SUCCESSFUL_RETURN;
282 }
283 
284 
285 
286 returnValue Actuator::init( double _startTime,
287  const DVector& _startValueU,
288  const DVector& _startValueP
289  )
290 {
291  DVector tmp;
292 
293  if ( _startValueU.isEmpty( ) == BT_FALSE )
294  tmp.append( _startValueU );
295 
296  if ( _startValueP.isEmpty( ) == BT_FALSE )
297  tmp.append( _startValueP );
298 
299  if ( TransferDevice::init( _startTime,tmp ) != SUCCESSFUL_RETURN )
300  return ACADOERROR( RET_ACTUATOR_INIT_FAILED );
301 
302  return SUCCESSFUL_RETURN;
303 }
304 
305 
306 
307 returnValue Actuator::step( VariablesGrid& _u,
308  VariablesGrid& _p
309  )
310 {
311  // consistency checks
312  if ( getStatus( ) != BS_READY )
313  return ACADOERROR( RET_BLOCK_NOT_READY );
314 
315  if ( checkInputConsistency( _u,_p ) != SUCCESSFUL_RETURN )
316  return ACADOERROR( RET_ACTUATOR_STEP_FAILED );
317 
318  if ( acadoIsEqual( _u.getFirstTime( ),lastSignal.getLastTime( ) ) == BT_FALSE )
319  return ACADOERROR( RET_INVALID_ARGUMENTS );
320 
321  // delay inputs and store last signal
322  if ( delayActuatorInput( _u,_p ) != SUCCESSFUL_RETURN )
323  return ACADOERROR( RET_ACTUATOR_STEP_FAILED );
324 
325  // add actuator noise
326  if ( addActuatorNoise( _u,_p ) != SUCCESSFUL_RETURN )
327  return ACADOERROR( RET_ACTUATOR_STEP_FAILED );
328 
329  return SUCCESSFUL_RETURN;
330 }
331 
332 
333 
334 //
335 // PROTECTED MEMBER FUNCTIONS:
336 //
337 
338 
339 /* identitical to same function within the class Process! */
340 returnValue Actuator::checkInputConsistency( const VariablesGrid& _u,
341  const VariablesGrid& _p
342  ) const
343 {
344  if ( _u.getNumPoints( ) < 2 )
345  return ACADOERROR( RET_INVALID_ARGUMENTS );
346 
347  if ( _u.getNumRows( ) != getNU( ) )
348  return ACADOERROR( RET_CONTROL_DIMENSION_MISMATCH );
349 
350  if ( _p.isEmpty( ) == BT_TRUE )
351  {
352  if ( getNP( ) > 0 )
353  return ACADOERROR( RET_PARAMETER_DIMENSION_MISMATCH );
354  }
355  else
356  {
357  if ( _p.getNumPoints( ) < 2 )
358  return ACADOERROR( RET_INVALID_ARGUMENTS );
359 
360  if ( _p.getNumRows( ) != getNP( ) )
361  return ACADOERROR( RET_PARAMETER_DIMENSION_MISMATCH );
362 
363  if ( acadoIsEqual( _u.getFirstTime( ),_p.getFirstTime( ) ) == BT_FALSE )
364  return ACADOERROR( RET_INVALID_ARGUMENTS );
365 
366  if ( acadoIsEqual( _u.getLastTime( ),_p.getLastTime( ) ) == BT_FALSE )
367  return ACADOERROR( RET_INVALID_ARGUMENTS );
368  }
369 
370  return SUCCESSFUL_RETURN;
371 }
372 
373 
374 
375 returnValue Actuator::delayActuatorInput( VariablesGrid& _u,
376  VariablesGrid& _p
377  )
378 {
379  if ( hasDeadTime( ) == BT_FALSE )
380  {
381  // store last signal
382  DVector tmp = _u.getLastVector( );
383  if ( _p.isEmpty( ) == BT_FALSE )
384  tmp.append( _p.getLastVector( ) );
385 
386  lastSignal.init( tmp );
387  lastSignal.setTime( 0,_u.getLastTime( ) );
388 
389  return SUCCESSFUL_RETURN;
390  }
391  else
392  {
393  double startTime = _u.getFirstTime( );
394  double endTime = _u.getLastTime( );
395 
396  // determine variables grid of delayed input
397  VariablesGrid uDelayed, pDelayed;
398  if ( getDelayedInputGrids( _u,_p, uDelayed,pDelayed ) != SUCCESSFUL_RETURN )
399  return ACADOERROR( RET_DELAYING_INPUTS_FAILED );
400 
401  // store last signal
402  lastSignal = uDelayed.getTimeSubGrid( uDelayed.getFloorIndex( endTime ),uDelayed.getLastIndex( ) );
403  if ( _p.isEmpty( ) == BT_FALSE )
404  lastSignal.appendValues( pDelayed.getTimeSubGrid( pDelayed.getFloorIndex( endTime ),pDelayed.getLastIndex( ) ) );
405 
406 /* printf("u:\n");
407  _u.print();
408  printf("p:\n");
409  _p.print();
410 
411  printf("uDelayed:\n");
412  uDelayed.print();
413  printf("pDelayed:\n");
414  pDelayed.print();*/
415 //
416 // printf("last:\n");
417 // lastSignal.print();
418 
419  // crop delayed signal to current horizon
420  _u = uDelayed.getTimeSubGrid( uDelayed.getFloorIndex( startTime ),uDelayed.getFloorIndex( endTime ) );
421  if ( _p.isEmpty( ) == BT_FALSE )
422  _p = pDelayed.getTimeSubGrid( pDelayed.getFloorIndex( startTime ),pDelayed.getFloorIndex( endTime ) );
423 
424 // printf("u:\n");
425 // _u.print();
426 // printf("p:\n");
427 // _p.print();
428 
429  return SUCCESSFUL_RETURN;
430  }
431 }
432 
433 
434 returnValue Actuator::getDelayedInputGrids( const VariablesGrid& _u,
435  const VariablesGrid& _p,
436  VariablesGrid& _uDelayed,
437  VariablesGrid& _pDelayed
438  ) const
439 {
440  // determine common time grid for delayed inputs:
441  Grid delayedInputTimeGrid = lastSignal.getTimePoints( );
442 
443  // make sure that last time instant of horizon lies within the grid
444  if ( acadoIsEqual( lastSignal.getLastTime(),_u.getLastTime( ) ) == BT_FALSE )
445  delayedInputTimeGrid.addTime( _u.getLastTime( ) );
446 
447 // delayedInputTimeGrid.print();
448 
449  // add grids of all delayed input components
450  for( uint i=0; i<getNU( ); ++i )
451  delayedInputTimeGrid = delayedInputTimeGrid & ( _u.getTimePoints( ).shiftTimes( deadTimes(i) ) );
452 
453 // _u.getTimePoints( ).print();
454 // _u.getTimePoints( ).shiftTimes( deadTimes(0) ).print();
455 // delayedInputTimeGrid.print();
456 
457  if ( _p.isEmpty( ) == BT_FALSE )
458  {
459  for( uint i=0; i<getNP( ); ++i )
460  delayedInputTimeGrid = delayedInputTimeGrid & ( _p.getTimePoints( ).shiftTimes( deadTimes(getNU()+i) ) );
461  }
462 
463  VariablesGrid tmp;
464 
465  // setup common variables grid for delayed inputs
466  _uDelayed.init( );
467  _pDelayed.init( );
468 
469  for( uint i=0; i<getNU( ); ++i )
470  {
471 // tmp.print("tmp");
472  tmp = lastSignal( i );
473 // tmp.print("tmp");
474  tmp.merge( _u( i ).shiftTimes( deadTimes(i) ),MM_REPLACE,BT_FALSE );
475 // tmp.print("tmp");
476  tmp.refineGrid( delayedInputTimeGrid );
477 // tmp.print("tmp");
478 
479  _uDelayed.appendValues( tmp );
480  }
481 
482  if ( _p.isEmpty( ) == BT_FALSE )
483  {
484  for( uint i=0; i<getNP( ); ++i )
485  {
486  tmp = lastSignal( getNU()+i );
487  tmp.merge( _p( i ).shiftTimes( deadTimes(getNU()+i) ),MM_REPLACE,BT_FALSE );
488  tmp.refineGrid( delayedInputTimeGrid );
489 
490  _pDelayed.appendValues( tmp );
491  }
492  }
493 
494  return SUCCESSFUL_RETURN;
495 }
496 
497 
498 returnValue Actuator::addActuatorNoise( VariablesGrid& _u,
499  VariablesGrid& _p
500  ) const
501 {
502  if ( hasNoise( ) == BT_FALSE )
503  return SUCCESSFUL_RETURN;
504 
505  // generate current noise
506  VariablesGrid currentNoise;
507 
508  if ( generateNoise( _u.getFirstTime(),_u.getLastTime(),currentNoise ) != SUCCESSFUL_RETURN )
509  return ACADOERROR( RET_GENERATING_NOISE_FAILED );
510 
511  // determine common grid
512  Grid commonGrid, tmpGrid;
513  currentNoise.getGrid( tmpGrid );
514  _u.getGrid( commonGrid );
515  commonGrid & tmpGrid;
516 
517 
518  // adapt input grids and add noise
519  _u.refineGrid( commonGrid );
520  currentNoise.refineGrid( commonGrid );
521  _u += currentNoise.getValuesSubGrid( 0,getNU()-1 );
522 
523  if ( _p.isEmpty( ) == BT_FALSE )
524  {
525  _p.refineGrid( commonGrid );
526  _p += currentNoise.getValuesSubGrid( getNU(),getNU()+getNP()-1 );
527  }
528 
529  return SUCCESSFUL_RETURN;
530 }
531 
532 
533 
534 
535 CLOSE_NAMESPACE_ACADO
536 
537 /*
538  * end of file
539  */
RET_ACTUATOR_STEP_FAILED
Definition: acado_types.hpp:930
Grid::getNumPoints
uint getNumPoints() const
Actuator::setParameterNoise
returnValue setParameterNoise(const Noise &_noise, double _noiseSamplingTime)
Definition: actuator.cpp:132
Actuator::getNP
uint getNP() const
Grid::setTime
returnValue setTime(double _time)
Definition: grid.cpp:307
VariablesGrid::getLastVector
DVector getLastVector() const
Definition: variables_grid.cpp:325
Actuator::getDelayedInputGrids
returnValue getDelayedInputGrids(const VariablesGrid &_u, const VariablesGrid &_p, VariablesGrid &_uDelayed, VariablesGrid &_pDelayed) const
Definition: actuator.cpp:434
Actuator::delayActuatorInput
returnValue delayActuatorInput(VariablesGrid &_u, VariablesGrid &_p)
Definition: actuator.cpp:375
Grid::getLastTime
double getLastTime() const
SUCCESSFUL_RETURN
Definition: acado_types.hpp:836
acadoIsEqual
BooleanType acadoIsEqual(double x, double y, double TOL)
Definition: acado_utils.cpp:88
TransferDevice::hasNoise
BooleanType hasNoise() const
Actuator::setParameterDeadTime
returnValue setParameterDeadTime(uint idx, double _deadTime)
Definition: actuator.cpp:266
Actuator::setParameterDeadTimes
returnValue setParameterDeadTimes(const DVector &_deadTimes)
Definition: actuator.cpp:231
RET_INVALID_ARGUMENTS
Definition: acado_types.hpp:839
VariablesGrid
Provides a time grid consisting of vector-valued optimization variables at each grid point...
Definition: variables_grid.hpp:56
RET_DELAYING_INPUTS_FAILED
Definition: acado_types.hpp:934
returnValue
Allows to pass back messages to the calling function.
Definition: acado_types.hpp:1139
VariablesGrid::getTimeSubGrid
VariablesGrid getTimeSubGrid(uint startIdx, uint endIdx) const
Definition: variables_grid.cpp:542
RET_BLOCK_NOT_READY
Definition: acado_types.hpp:912
Grid::isEmpty
BooleanType isEmpty() const
Noise::getDim
uint getDim() const
Noise
Base class for generating pseudo-random noise for simulating the Process.
Definition: noise.hpp:56
MM_REPLACE
Definition: acado_types.hpp:119
uint
BEGIN_NAMESPACE_ACADO typedef unsigned int uint
Definition: acado_types.hpp:42
Actuator::nP
uint nP
Definition: actuator.hpp:390
Grid
Allows to conveniently handle (one-dimensional) grids consisting of time points.
Definition: grid.hpp:58
Actuator::checkInputConsistency
returnValue checkInputConsistency(const VariablesGrid &_u, const VariablesGrid &_p) const
Definition: actuator.cpp:340
RET_GENERATING_NOISE_FAILED
Definition: acado_types.hpp:933
CLOSE_NAMESPACE_ACADO
#define CLOSE_NAMESPACE_ACADO
Definition: acado_namespace_macros.hpp:58
VariablesGrid::appendValues
returnValue appendValues(const VariablesGrid &arg)
Definition: variables_grid.cpp:421
RET_MEMBER_NOT_INITIALISED
Definition: acado_types.hpp:851
Actuator::operator=
Actuator & operator=(const Actuator &rhs)
Definition: actuator.cpp:75
Grid::getFirstTime
double getFirstTime() const
Grid::getFloorIndex
uint getFloorIndex(double time) const
Definition: grid.cpp:593
TransferDevice::generateNoise
virtual returnValue generateNoise(double startTime, double endTime, VariablesGrid &currentNoise) const
Definition: transfer_device.cpp:194
VariablesGrid::merge
returnValue merge(const VariablesGrid &arg, MergeMethod _mergeMethod=MM_DUPLICATE, BooleanType keepOverlap=BT_TRUE)
Definition: variables_grid.cpp:446
TransferDevice::lastSignal
VariablesGrid lastSignal
Definition: transfer_device.hpp:175
UserInteraction::getStatus
BlockStatus getStatus() const
Definition: user_interaction.cpp:125
BS_READY
Definition: acado_types.hpp:714
TransferDevice::init
virtual returnValue init(double _startTime=0.0, const DVector &_startValue=emptyConstVector)
Definition: transfer_device.cpp:158
MatrixVariablesGrid::refineGrid
returnValue refineGrid(const Grid &arg, InterpolationMode mode=IM_CONSTANT)
Definition: matrix_variables_grid.cpp:538
VariablesGrid::init
returnValue init()
Definition: variables_grid.cpp:208
Actuator::setControlDeadTime
returnValue setControlDeadTime(uint idx, double _deadTime)
Definition: actuator.cpp:211
GenericVector::isEmpty
bool isEmpty() const
Definition: vector.hpp:176
rhs
void rhs(const real_t *x, real_t *f)
Definition: examples/code_generation/simulation/externModel_export/model.c:5
Actuator::init
virtual returnValue init(double _startTime=0.0, const DVector &_startValueU=emptyConstVector, const DVector &_startValueP=emptyConstVector)
Definition: actuator.cpp:286
Actuator::getNU
uint getNU() const
Noise::clone
virtual Noise * clone() const =0
Actuator::addActuatorNoise
returnValue addActuatorNoise(VariablesGrid &_u, VariablesGrid &_p) const
Definition: actuator.cpp:498
Grid::getLastIndex
uint getLastIndex() const
BT_TRUE
#define BT_TRUE
Definition: acado_types.hpp:47
GenericVector::append
GenericVector & append(const GenericVector &_arg)
Definition: vector.cpp:42
BN_ACTUATOR
Definition: acado_types.hpp:700
Grid::shiftTimes
Grid & shiftTimes(double timeShift)
Definition: grid.cpp:449
Grid::addTime
returnValue addTime(double _time)
Definition: grid.cpp:339
RET_PARAMETER_DIMENSION_MISMATCH
Definition: acado_types.hpp:870
GenericVector::setAll
void setAll(const T &_value)
Definition: vector.hpp:160
MatrixVariablesGrid::getGrid
returnValue getGrid(Grid &_grid) const
Definition: matrix_variables_grid.cpp:1609
GenericVector::getDim
unsigned getDim() const
Definition: vector.hpp:172
ACADOWARNING
#define ACADOWARNING(retval)
Definition: acado_message_handling.hpp:122
Actuator::nU
uint nU
Definition: actuator.hpp:389
TransferDevice::hasDeadTime
BooleanType hasDeadTime() const
TransferDevice::noiseSamplingTimes
DVector noiseSamplingTimes
Definition: transfer_device.hpp:178
BEGIN_NAMESPACE_ACADO
#define BEGIN_NAMESPACE_ACADO
Definition: acado_namespace_macros.hpp:57
Actuator::setControlNoise
returnValue setControlNoise(const Noise &_noise, double _noiseSamplingTime)
Definition: actuator.cpp:89
BT_FALSE
#define BT_FALSE
Definition: acado_types.hpp:49
Actuator
Allows to simulate the behaviour of actuators within the Process.
Definition: actuator.hpp:54
VariablesGrid::getValuesSubGrid
VariablesGrid getValuesSubGrid(uint startIdx, uint endIdx) const
Definition: variables_grid.cpp:593
Actuator::~Actuator
virtual ~Actuator()
Definition: actuator.cpp:70
Actuator::step
virtual returnValue step(VariablesGrid &_u, VariablesGrid &_p=emptyVariablesGrid)
Definition: actuator.cpp:307
RET_NO_DIFFERENT_NOISE_SAMPLING_FOR_DISCRETE
Definition: acado_types.hpp:938
RET_ACTUATOR_INIT_FAILED
Definition: acado_types.hpp:929
Actuator::Actuator
Actuator()
Definition: actuator.cpp:46
RET_CONTROL_DIMENSION_MISMATCH
Definition: acado_types.hpp:869
TransferDevice::operator=
TransferDevice & operator=(const TransferDevice &rhs)
Definition: transfer_device.cpp:111
GenericVector::getMin
T getMin() const
Definition: vector.hpp:184
ACADOERROR
#define ACADOERROR(retval)
Definition: acado_message_handling.hpp:106
TransferDevice
Base class for simulating Actuator and Sensor behaviour wihtin the Process.
Definition: transfer_device.hpp:61
Actuator::setControlDeadTimes
returnValue setControlDeadTimes(const DVector &_deadTimes)
Definition: actuator.cpp:176

acado
Author(s): Milan Vukov, Rien Quirynen
autogenerated on Mon Feb 28 2022 21:31:50