Lodestar
An integrated real-time control package in C++
SimplePIDBlock.hpp
1 //
2 // Created by Hamza El-Kebir on 2/20/22.
3 //
4 
5 #ifndef LODESTAR_SIMPLEPIDBLOCK_HPP
6 #define LODESTAR_SIMPLEPIDBLOCK_HPP
7 
8 
9 #include "Lodestar/blocks/Block.hpp"
10 #include "Lodestar/aux/CompileTimeQualifiers.hpp"
11 #include "Eigen/Dense"
12 
13 namespace ls {
14  namespace blocks {
15  namespace std {
16  enum class SimplePIDBlockOperator {
17  Scalar,
18  Elementwise
19  };
20 
21  enum class SimplePIDBlockParameter {
22  Parametric,
23  AdditionalInput
24  };
25 
26  template<typename TType,
27  SimplePIDBlockOperator TOps = SimplePIDBlockOperator::Scalar,
28  SimplePIDBlockParameter TPar = SimplePIDBlockParameter::Parametric>
29  class SimplePIDBlock {
30  static_assert(!::std::is_same<TType, TType>::value,
31  "SimplePIDBlock not defined for this type.");
32  };
33 
34  template<typename TType, SimplePIDBlockOperator TOps>
35  class SimplePIDBlock<
36  TType,
37  TOps,
38  SimplePIDBlockParameter::Parametric
39  > :
40  public Block<
41  ::std::tuple<TType>,
42  ::std::tuple<TType>,
43  ::std::tuple<TType, TType, TType, TType>
44  > {
45  public:
46  using type =
47  SimplePIDBlock<
48  TType,
49  TOps,
50  SimplePIDBlockParameter::Parametric
51  >;
52 
53  using Base =
54  Block<
55  ::std::tuple<TType>,
56  ::std::tuple<TType>,
57  ::std::tuple<TType, TType, TType, TType>
58  >;
59 
60  SimplePIDBlock()
61  {
62  bindEquation();
63  }
64 
65  TType &pGain()
66  {
67  return this->template p<0>();
68  }
69 
70  TType &pGain(const TType Kp)
71  {
72  this->template p<0>() = Kp;
73  return this->template p<0>();
74  }
75 
76  TType pGain() const
77  {
78  return this->template p<0>();
79  }
80 
81  TType &iGain()
82  {
83  return this->template p<1>();
84  }
85 
86  TType &iGain(const TType Ki)
87  {
88  this->template p<1>() = Ki;
89  return this->template p<1>();
90  }
91 
92  TType iGain() const
93  {
94  return this->template p<1>();
95  }
96 
97  TType &dGain()
98  {
99  return this->template p<2>();
100  }
101 
102  TType &dGain(const TType Kd)
103  {
104  this->template p<2>() = Kd;
105  return this->template p<2>();
106  }
107 
108  TType dGain() const
109  {
110  return this->template p<2>();
111  }
112 
113  TType &samplingPeriod()
114  {
115  return this->template p<3>();
116  }
117 
118  TType &samplingPeriod(const TType t)
119  {
120  this->template p<3>() = t;
121  return this->template p<3>();
122  }
123 
124  TType samplingPeriod() const
125  {
126  return this->template p<3>();
127  }
128 
129  protected:
130  void bindEquation()
131  {
132  this->equation = ::std::bind(
133  &type::triggerFunction,
134  this,
135  ::std::placeholders::_1
136  );
137  }
138 
139  TType pid(const TType x) const
140  {
141  static TType lastX = 0;
142  static TType intX = 0;
143 
144  TType res = pGain() * x + iGain() * intX + dGain() * (x - lastX)/samplingPeriod();
145 
146  intX += x * samplingPeriod();
147  lastX = x;
148 
149  return res;
150  }
151 
152  void triggerFunction(Base &b)
153  {
154  b.template o<0>() = pid(b.template i<0>().object);
155  }
156  };
157 
158  template<typename TType, SimplePIDBlockOperator TOps>
159  class SimplePIDBlock<
160  TType,
161  TOps,
162  SimplePIDBlockParameter::AdditionalInput
163  > :
164  public Block<
165  ::std::tuple<TType, TType, TType, TType>,
166  ::std::tuple<TType>,
167  ::std::tuple<TType>
168  > {
169  public:
170  using type =
171  SimplePIDBlock<
172  TType,
173  TOps,
174  SimplePIDBlockParameter::AdditionalInput
175  >;
176 
177  using Base =
178  Block<
179  ::std::tuple<TType, TType, TType, TType>,
180  ::std::tuple<TType>,
181  ::std::tuple<TType>
182  >;
183 
184  SimplePIDBlock()
185  {
186  bindEquation();
187  }
188 
189  Signal<TType> &pGain()
190  {
191  return this->template i<1>();
192  }
193 
194  Signal<TType> &pGain(const TType &Kp)
195  {
196  this->template i<1>() = Kp;
197  return this->template i<1>();
198  }
199 
200  Signal<TType> &pGain(const Signal<TType> &Kp)
201  {
202  this->template i<1>() = Kp;
203  return this->template i<1>();
204  }
205 
206  const Signal<TType> &pGain() const
207  {
208  return this->template i<1>();
209  }
210 
211  Signal<TType> &iGain()
212  {
213  return this->template i<2>();
214  }
215 
216  Signal<TType> &iGain(const TType &Ki)
217  {
218  this->template i<2>() = Ki;
219  return this->template i<2>();
220  }
221 
222  Signal<TType> &iGain(const Signal<TType> Ki)
223  {
224  this->template i<2>() = Ki;
225  return this->template i<2>();
226  }
227 
228  const Signal<TType> &iGain() const
229  {
230  return this->template i<2>();
231  }
232 
233  Signal<TType> &dGain()
234  {
235  return this->template i<3>();
236  }
237 
238  Signal<TType> &dGain(const TType &Kd)
239  {
240  this->template i<3>() = Kd;
241  return this->template i<3>();
242  }
243 
244  Signal<TType> &dGain(const Signal<TType> Kd)
245  {
246  this->template i<3>() = Kd;
247  return this->template i<3>();
248  }
249 
250  const Signal<TType> &dGain() const
251  {
252  return this->template i<3>();
253  }
254 
255  TType &samplingPeriod()
256  {
257  return this->template p<0>();
258  }
259 
260  TType &samplingPeriod(const TType t)
261  {
262  this->template p<0>() = t;
263  return this->template p<0>();
264  }
265 
266  TType samplingPeriod() const
267  {
268  return this->template p<0>();
269  }
270  protected:
271  void bindEquation()
272  {
273  this->equation = ::std::bind(
274  &type::triggerFunction,
275  this,
276  ::std::placeholders::_1
277  );
278  }
279 
280  TType pid(const TType x) const
281  {
282  static TType lastX = 0;
283  static TType intX = 0;
284 
285  TType res = pGain() * x + iGain() * intX + dGain() * (x - lastX)/samplingPeriod();
286 
287  intX += x * samplingPeriod();
288  lastX = x;
289 
290  return res;
291  }
292 
293  void triggerFunction(Base &b)
294  {
295  b.template o<0>() = pid(b.template i<0>().object);
296  }
297  };
298 
299  template<typename TScalar, int TRows, int TCols>
300  class SimplePIDBlock<
301  Eigen::Matrix<TScalar, TRows, TCols>,
302  SimplePIDBlockOperator::Scalar,
303  SimplePIDBlockParameter::Parametric
304  > :
305  public Block<
306  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>>,
307  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>>,
308  ::std::tuple<TScalar, TScalar, TScalar, TScalar>
309  > {
310  public:
311  using type =
312  SimplePIDBlock<
313  Eigen::Matrix<TScalar, TRows, TCols>,
314  SimplePIDBlockOperator::Scalar,
315  SimplePIDBlockParameter::Parametric
316  >;
317 
318  using Base =
319  Block<
320  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>>,
321  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>>,
322  ::std::tuple<TScalar, TScalar, TScalar, TScalar>
323  >;
324 
325  SimplePIDBlock()
326  {
327  bindEquation();
328  }
329 
330  TScalar &pGain()
331  {
332  return this->template p<0>();
333  }
334 
335  TScalar &pGain(const TScalar Kp)
336  {
337  this->template p<0>() = Kp;
338  return this->template p<0>();
339  }
340 
341  TScalar pGain() const
342  {
343  return this->template p<0>();
344  }
345 
346  TScalar &iGain()
347  {
348  return this->template p<1>();
349  }
350 
351  TScalar &iGain(const TScalar Ki)
352  {
353  this->template p<1>() = Ki;
354  return this->template p<1>();
355  }
356 
357  TScalar iGain() const
358  {
359  return this->template p<1>();
360  }
361 
362  TScalar &dGain()
363  {
364  return this->template p<2>();
365  }
366 
367  TScalar &dGain(const TScalar Kd)
368  {
369  this->template p<2>() = Kd;
370  return this->template p<2>();
371  }
372 
373  TScalar dGain() const
374  {
375  return this->template p<2>();
376  }
377 
378  TScalar &samplingPeriod()
379  {
380  return this->template p<3>();
381  }
382 
383  TScalar &samplingPeriod(const TScalar t)
384  {
385  this->template p<3>() = t;
386  return this->template p<3>();
387  }
388 
389  TScalar samplingPeriod() const
390  {
391  return this->template p<3>();
392  }
393 
394  protected:
395  void bindEquation()
396  {
397  this->equation = ::std::bind(
398  &type::triggerFunction,
399  this,
400  ::std::placeholders::_1
401  );
402  }
403 
404  Eigen::Matrix<TScalar, TRows, TCols> pid(Eigen::Matrix<TScalar, TRows, TCols> &x) const
405  {
406  static Eigen::Matrix<TScalar, TRows, TCols> lastX = Eigen::Matrix<TScalar, TRows, TCols>::Zero();
407  static Eigen::Matrix<TScalar, TRows, TCols> intX = Eigen::Matrix<TScalar, TRows, TCols>::Zero();
408 
409  Eigen::Matrix<TScalar, TRows, TCols> res = pGain() * x + iGain() * intX + dGain() * (x - lastX)/samplingPeriod();
410 
411  intX += samplingPeriod() * x;
412  lastX = x;
413 
414  return res;
415  }
416 
417  void triggerFunction(Base &b)
418  {
419  b.template o<0>() = pid(b.template i<0>().object);
420  }
421  };
422 
423  template<typename TScalar, int TRows, int TCols>
424  class SimplePIDBlock<
425  Eigen::Matrix<TScalar, TRows, TCols>,
426  SimplePIDBlockOperator::Scalar,
427  SimplePIDBlockParameter::AdditionalInput
428  > :
429  public Block<
430  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>, TScalar, TScalar, TScalar>,
431  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>>,
432  ::std::tuple<TScalar>
433  > {
434  public:
435  using type =
436  SimplePIDBlock<
437  Eigen::Matrix<TScalar, TRows, TCols>,
438  SimplePIDBlockOperator::Scalar,
439  SimplePIDBlockParameter::AdditionalInput
440  >;
441 
442  using Base =
443  Block<
444  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>, TScalar, TScalar, TScalar>,
445  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>>,
446  ::std::tuple<TScalar>
447  >;
448 
449  SimplePIDBlock()
450  {
451  bindEquation();
452  }
453 
454  Signal<TScalar> &pGain()
455  {
456  return this->template i<1>();
457  }
458 
459  Signal<TScalar> &pGain(const TScalar &Kp)
460  {
461  this->template i<1>() = Kp;
462  return this->template i<1>();
463  }
464 
465  Signal<TScalar> &pGain(const Signal<TScalar> &Kp)
466  {
467  this->template i<1>() = Kp;
468  return this->template i<1>();
469  }
470 
471  const Signal<TScalar> &pGain() const
472  {
473  return this->template i<1>();
474  }
475 
476  Signal<TScalar> &iGain()
477  {
478  return this->template i<2>();
479  }
480 
481  Signal<TScalar> &iGain(const TScalar &Ki)
482  {
483  this->template i<2>() = Ki;
484  return this->template i<2>();
485  }
486 
487  Signal<TScalar> &iGain(const Signal<TScalar> Ki)
488  {
489  this->template i<2>() = Ki;
490  return this->template i<2>();
491  }
492 
493  const Signal<TScalar> &iGain() const
494  {
495  return this->template i<2>();
496  }
497 
498  Signal<TScalar> &dGain()
499  {
500  return this->template i<3>();
501  }
502 
503  Signal<TScalar> &dGain(const TScalar &Kd)
504  {
505  this->template i<3>() = Kd;
506  return this->template i<3>();
507  }
508 
509  Signal<TScalar> &dGain(const Signal<TScalar> Kd)
510  {
511  this->template i<3>() = Kd;
512  return this->template i<3>();
513  }
514 
515  const Signal<TScalar> &dGain() const
516  {
517  return this->template i<3>();
518  }
519 
520  TScalar &samplingPeriod()
521  {
522  return this->template p<0>();
523  }
524 
525  TScalar &samplingPeriod(const TScalar t)
526  {
527  this->template p<0>() = t;
528  return this->template p<0>();
529  }
530 
531  TScalar samplingPeriod() const
532  {
533  return this->template p<0>();
534  }
535 
536  protected:
537  void bindEquation()
538  {
539  this->equation = ::std::bind(
540  &type::triggerFunction,
541  this,
542  ::std::placeholders::_1
543  );
544  }
545 
546  void triggerFunction(Base &b)
547  {
548  b.template o<0>() = pid(b.template i<0>().object);
549  }
550 
551  Eigen::Matrix<TScalar, TRows, TCols> pid(Eigen::Matrix<TScalar, TRows, TCols> &x) const
552  {
553  static Eigen::Matrix<TScalar, TRows, TCols> lastX = Eigen::Matrix<TScalar, TRows, TCols>::Zero();
554  static Eigen::Matrix<TScalar, TRows, TCols> intX = Eigen::Matrix<TScalar, TRows, TCols>::Zero();
555 
556  Eigen::Matrix<TScalar, TRows, TCols> res = pGain() * x + iGain() * intX + dGain() * (x - lastX)/samplingPeriod();
557 
558  intX += samplingPeriod() * x;
559  lastX = x;
560 
561  return res;
562  }
563  };
564 
565  template<typename TScalar, int TRows, int TCols>
566  class SimplePIDBlock<
567  Eigen::Matrix<TScalar, TRows, TCols>,
568  SimplePIDBlockOperator::Elementwise,
569  SimplePIDBlockParameter::Parametric
570  > :
571  public Block<
572  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>>,
573  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>>,
574  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>, Eigen::Matrix<TScalar, TRows, TCols>, Eigen::Matrix<TScalar, TRows, TCols>, TScalar>
575  > {
576  public:
577  using type =
578  SimplePIDBlock<
579  Eigen::Matrix<TScalar, TRows, TCols>,
580  SimplePIDBlockOperator::Elementwise,
581  SimplePIDBlockParameter::Parametric
582  >;
583 
584  using Base =
585  Block<
586  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>>,
587  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>>,
588  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>, Eigen::Matrix<TScalar, TRows, TCols>, Eigen::Matrix<TScalar, TRows, TCols>, TScalar>
589  >;
590 
591  using GainMatrix = Eigen::Matrix<TScalar, TRows, TCols>;
592 
593  SimplePIDBlock()
594  {
595  bindEquation();
596  }
597 
598  GainMatrix &pGain()
599  {
600  return this->template p<0>();
601  }
602 
603  GainMatrix &pGain(const GainMatrix &Kp)
604  {
605  this->template p<0>() = Kp;
606  return this->template p<0>();
607  }
608 
609  GainMatrix pGain() const
610  {
611  return this->template p<0>();
612  }
613 
614  GainMatrix &iGain()
615  {
616  return this->template p<1>();
617  }
618 
619  GainMatrix &iGain(const GainMatrix &Ki)
620  {
621  this->template p<1>() = Ki;
622  return this->template p<1>();
623  }
624 
625  GainMatrix iGain() const
626  {
627  return this->template p<1>();
628  }
629 
630  GainMatrix &dGain()
631  {
632  return this->template p<2>();
633  }
634 
635  GainMatrix &dGain(const GainMatrix &Kd)
636  {
637  this->template p<2>() = Kd;
638  return this->template p<2>();
639  }
640 
641  GainMatrix dGain() const
642  {
643  return this->template p<2>();
644  }
645 
646  TScalar &samplingPeriod()
647  {
648  return this->template p<3>();
649  }
650 
651  TScalar &samplingPeriod(const TScalar t)
652  {
653  this->template p<3>() = t;
654  return this->template p<3>();
655  }
656 
657  TScalar samplingPeriod() const
658  {
659  return this->template p<3>();
660  }
661 
662  protected:
663  void bindEquation()
664  {
665  this->equation = ::std::bind(
666  &type::triggerFunction,
667  this,
668  ::std::placeholders::_1
669  );
670  }
671 
672  Eigen::Matrix<TScalar, TRows, TCols> pid(Eigen::Matrix<TScalar, TRows, TCols> &x) const
673  {
674  static Eigen::Matrix<TScalar, TRows, TCols> lastX = Eigen::Matrix<TScalar, TRows, TCols>::Zero();
675  static Eigen::Matrix<TScalar, TRows, TCols> intX = Eigen::Matrix<TScalar, TRows, TCols>::Zero();
676 
677  Eigen::Matrix<TScalar, TRows, TCols> res = pGain().array() * x.array() + iGain().array() * intX.array() + dGain().array() * ((x - lastX)/samplingPeriod()).array();
678 
679  intX += samplingPeriod() * x;
680  lastX = x;
681 
682  return res;
683  }
684 
685  void triggerFunction(Base &b)
686  {
687  b.template o<0>() = pid(b.template i<0>().object);
688  }
689  };
690 
691  template<typename TScalar, int TRows, int TCols>
692  class SimplePIDBlock<
693  Eigen::Matrix<TScalar, TRows, TCols>,
694  SimplePIDBlockOperator::Elementwise,
695  SimplePIDBlockParameter::AdditionalInput
696  > :
697  public Block<
698  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>, Eigen::Matrix<TScalar, TRows, TCols>, Eigen::Matrix<TScalar, TRows, TCols>, Eigen::Matrix<TScalar, TRows, TCols>>,
699  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>>,
700  ::std::tuple<TScalar>
701  > {
702  public:
703  using type =
704  SimplePIDBlock<
705  Eigen::Matrix<TScalar, TRows, TCols>,
706  SimplePIDBlockOperator::Elementwise,
707  SimplePIDBlockParameter::AdditionalInput
708  >;
709 
710  using Base =
711  Block<
712  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>, Eigen::Matrix<TScalar, TRows, TCols>, Eigen::Matrix<TScalar, TRows, TCols>, Eigen::Matrix<TScalar, TRows, TCols>>,
713  ::std::tuple<Eigen::Matrix<TScalar, TRows, TCols>>,
714  ::std::tuple<TScalar>
715  >;
716 
717  using GainMatrix = Eigen::Matrix<TScalar, TRows, TCols>;
718 
719  SimplePIDBlock()
720  {
721  bindEquation();
722  }
723 
724  Signal<GainMatrix> &pGain()
725  {
726  return this->template i<1>();
727  }
728 
729  Signal<GainMatrix> &pGain(const GainMatrix &Kp)
730  {
731  this->template i<1>() = Kp;
732  return this->template i<1>();
733  }
734 
735  Signal<GainMatrix> &pGain(const Signal<GainMatrix> &Kp)
736  {
737  this->template i<1>() = Kp;
738  return this->template i<1>();
739  }
740 
741  const Signal<GainMatrix> &pGain() const
742  {
743  return this->template i<1>();
744  }
745 
746  Signal<GainMatrix> &iGain()
747  {
748  return this->template i<2>();
749  }
750 
751  Signal<GainMatrix> &iGain(const GainMatrix &Ki)
752  {
753  this->template i<2>() = Ki;
754  return this->template i<2>();
755  }
756 
757  Signal<GainMatrix> &iGain(const Signal<GainMatrix> &Ki)
758  {
759  this->template i<2>() = Ki;
760  return this->template i<2>();
761  }
762 
763  const Signal<GainMatrix> &iGain() const
764  {
765  return this->template i<2>();
766  }
767 
768  Signal<GainMatrix> &dGain()
769  {
770  return this->template i<3>();
771  }
772 
773  Signal<GainMatrix> &dGain(const GainMatrix &Kd)
774  {
775  this->template i<3>() = Kd;
776  return this->template i<3>();
777  }
778 
779  Signal<GainMatrix> &dGain(const Signal<GainMatrix> &Kd)
780  {
781  this->template i<3>() = Kd;
782  return this->template i<3>();
783  }
784 
785  const Signal<GainMatrix> &dGain() const
786  {
787  return this->template i<3>();
788  }
789 
790  TScalar &samplingPeriod()
791  {
792  return this->template p<0>();
793  }
794 
795  TScalar &samplingPeriod(const TScalar t)
796  {
797  this->template p<0>() = t;
798  return this->template p<0>();
799  }
800 
801  TScalar samplingPeriod() const
802  {
803  return this->template p<0>();
804  }
805 
806  protected:
807  void bindEquation()
808  {
809  this->equation = ::std::bind(
810  &type::triggerFunction,
811  this,
812  ::std::placeholders::_1
813  );
814  }
815 
816  Eigen::Matrix<TScalar, TRows, TCols> pid(Eigen::Matrix<TScalar, TRows, TCols> &x) const
817  {
818  static Eigen::Matrix<TScalar, TRows, TCols> lastX{};
819  static Eigen::Matrix<TScalar, TRows, TCols> intX{};
820 
821  Eigen::Matrix<TScalar, TRows, TCols> res = pGain().object.array() * x.array() + iGain().object.array() * intX.array() + dGain().object.array() * ((x - lastX)/samplingPeriod()).array();
822 
823  intX += samplingPeriod() * x;
824  lastX = x;
825 
826  return res;
827  }
828 
829  void triggerFunction(Base &b)
830  {
831  b.template o<0>() = pid(b.template i<0>().object);
832  }
833  };
834 
835  template<typename TType, SimplePIDBlockOperator TOps>
836  using SimplePIDBlockDynamic = SimplePIDBlock<TType, TOps, SimplePIDBlockParameter::AdditionalInput>;
837  }
838 
839  // FIXME: Add additional specializations.
840  template<typename TType>
841  class BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::Parametric>> {
842  public:
843  static constexpr const BlockType blockType = BlockType::SimplePIDBlock;
844  enum {
845  directFeedthrough = true
846  };
847 
848  using type = std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::Parametric>;
849  using Base = typename type::Base;
850 
851  enum {
852  kIns = Base::kIns,
853  kOuts = Base::kOuts,
854  kPars = Base::kPars
855  };
856 
857  static const ::std::array<::std::string, kIns> inTypes;
858  static const ::std::array<::std::string, kOuts> outTypes;
859  static const ::std::array<::std::string, kPars> parTypes;
860 
861  static const ::std::array<::std::string, 3> templateTypes;
862  };
863 
864  template<typename TType>
865  const ::std::array<::std::string, BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::Parametric>>::kIns>
866  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::Parametric>>::inTypes =
867  {demangle(typeid(TType).name())};
868 
869  template<typename TType>
870  const ::std::array<::std::string, BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::Parametric>>::kOuts>
871  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::Parametric>>::outTypes =
872  {demangle(typeid(TType).name())};
873 
874  template<typename TType>
875  const ::std::array<::std::string, BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::Parametric>>::kPars>
876  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::Parametric>>::parTypes =
877  {demangle(typeid(TType).name()), demangle(typeid(TType).name()), demangle(typeid(TType).name()), demangle(typeid(TType).name())};
878 
879  template<typename TType>
880  const ::std::array<::std::string, 3>
881  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::Parametric>>::templateTypes =
882  {demangle(typeid(TType).name()), demangle(typeid(std::SimplePIDBlockOperator).name()), demangle(typeid(std::SimplePIDBlockParameter).name())};
883 
884  template<typename TType>
885  class BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::Parametric>> {
886  public:
887  static constexpr const BlockType blockType = BlockType::SimplePIDBlock;
888  enum {
889  directFeedthrough = true
890  };
891 
892  using type = std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::Parametric>;
893  using Base = typename type::Base;
894 
895  enum {
896  kIns = Base::kIns,
897  kOuts = Base::kOuts,
898  kPars = Base::kPars
899  };
900 
901  static const ::std::array<::std::string, kIns> inTypes;
902  static const ::std::array<::std::string, kOuts> outTypes;
903  static const ::std::array<::std::string, kPars> parTypes;
904 
905  static const ::std::array<::std::string, 3> templateTypes;
906  };
907 
908  template<typename TType>
909  const ::std::array<::std::string, BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::Parametric>>::kIns>
910  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::Parametric>>::inTypes =
911  {demangle(typeid(TType).name())};
912 
913  template<typename TType>
914  const ::std::array<::std::string, BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::Parametric>>::kOuts>
915  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::Parametric>>::outTypes =
916  {demangle(typeid(TType).name())};
917 
918  template<typename TType>
919  const ::std::array<::std::string, BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::Parametric>>::kPars>
920  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::Parametric>>::parTypes =
921  {demangle(typeid(TType).name()), demangle(typeid(TType).name()), demangle(typeid(TType).name()), demangle(typeid(TType).name())};
922 
923  template<typename TType>
924  const ::std::array<::std::string, 3>
925  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::Parametric>>::templateTypes =
926  {demangle(typeid(TType).name()), demangle(typeid(std::SimplePIDBlockOperator).name()), demangle(typeid(std::SimplePIDBlockParameter).name())};
927 
928  template<typename TType>
929  class BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::AdditionalInput>> {
930  public:
931  static constexpr const BlockType blockType = BlockType::SimplePIDBlock;
932  enum {
933  directFeedthrough = true
934  };
935 
936  using type = std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::AdditionalInput>;
937  using Base = typename type::Base;
938 
939  enum {
940  kIns = Base::kIns,
941  kOuts = Base::kOuts,
942  kPars = Base::kPars
943  };
944 
945  static const ::std::array<::std::string, kIns> inTypes;
946  static const ::std::array<::std::string, kOuts> outTypes;
947  static const ::std::array<::std::string, kPars> parTypes;
948 
949  static const ::std::array<::std::string, 3> templateTypes;
950  };
951 
952  template<typename TType>
953  const ::std::array<::std::string, BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::AdditionalInput>>::kIns>
954  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::AdditionalInput>>::inTypes =
955  {demangle(typeid(TType).name()), demangle(typeid(TType).name()), demangle(typeid(TType).name()), demangle(typeid(TType).name())};
956 
957  template<typename TType>
958  const ::std::array<::std::string, BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::AdditionalInput>>::kOuts>
959  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::AdditionalInput>>::outTypes =
960  {demangle(typeid(TType).name())};
961 
962  template<typename TType>
963  const ::std::array<::std::string, BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::AdditionalInput>>::kPars>
964  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::AdditionalInput>>::parTypes =
965  {demangle(typeid(TType).name())};
966 
967  template<typename TType>
968  const ::std::array<::std::string, 3>
969  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Scalar, std::SimplePIDBlockParameter::AdditionalInput>>::templateTypes =
970  {demangle(typeid(TType).name()), demangle(typeid(std::SimplePIDBlockOperator).name()), demangle(typeid(std::SimplePIDBlockParameter).name())};
971 
972  template<typename TType>
973  class BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::AdditionalInput>> {
974  public:
975  static constexpr const BlockType blockType = BlockType::SimplePIDBlock;
976  enum {
977  directFeedthrough = true
978  };
979 
980  using type = std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::AdditionalInput>;
981  using Base = typename type::Base;
982 
983  enum {
984  kIns = Base::kIns,
985  kOuts = Base::kOuts,
986  kPars = Base::kPars
987  };
988 
989  static const ::std::array<::std::string, kIns> inTypes;
990  static const ::std::array<::std::string, kOuts> outTypes;
991  static const ::std::array<::std::string, kPars> parTypes;
992 
993  static const ::std::array<::std::string, 3> templateTypes;
994  };
995 
996  template<typename TType>
997  const ::std::array<::std::string, BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::AdditionalInput>>::kIns>
998  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::AdditionalInput>>::inTypes =
999  {demangle(typeid(TType).name()), demangle(typeid(TType).name()), demangle(typeid(TType).name()), demangle(typeid(TType).name())};
1000 
1001  template<typename TType>
1002  const ::std::array<::std::string, BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::AdditionalInput>>::kOuts>
1003  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::AdditionalInput>>::outTypes =
1004  {demangle(typeid(TType).name())};
1005 
1006  template<typename TType>
1007  const ::std::array<::std::string, BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::AdditionalInput>>::kPars>
1008  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::AdditionalInput>>::parTypes =
1009  {demangle(typeid(TType).name())};
1010 
1011  template<typename TType>
1012  const ::std::array<::std::string, 3>
1013  BlockTraits<std::SimplePIDBlock<TType, std::SimplePIDBlockOperator::Elementwise, std::SimplePIDBlockParameter::AdditionalInput>>::templateTypes =
1014  {demangle(typeid(TType).name()), demangle(typeid(std::SimplePIDBlockOperator).name()), demangle(typeid(std::SimplePIDBlockParameter).name())};
1015  }
1016 }
1017 
1018 #endif //LODESTAR_SIMPLEPIDBLOCK_HPP
ls::blocks::BlockTraits::directFeedthrough
static constexpr const bool directFeedthrough
Whether or not the block has direct feedthrough.
Definition: BlockTraits.hpp:44
ls::blocks::BlockTraits
A traits object that exposes information about TBlock.
Definition: BlockTraits.hpp:37
ls::blocks::BlockTraits::inTypes
static const ::std::array<::std::string, kIns > inTypes
Input types (as strings).
Definition: BlockTraits.hpp:59
ls::blocks::BlockType
BlockType
Block type information.
Definition: BlockType.hpp:25
ls
Main Lodestar code.
Definition: BilinearTransformation.hpp:12
ls::blocks::std::SimplePIDBlock< Eigen::Matrix< TScalar, TRows, TCols >, SimplePIDBlockOperator::Elementwise, SimplePIDBlockParameter::AdditionalInput >
Definition: SimplePIDBlock.hpp:692
ls::blocks::Signal
Definition: Signal.hpp:22
ls::blocks::BlockType::SimplePIDBlock
@ SimplePIDBlock
Simple PID controller block.
ls::blocks::std::SimplePIDBlock< Eigen::Matrix< TScalar, TRows, TCols >, SimplePIDBlockOperator::Scalar, SimplePIDBlockParameter::Parametric >
Definition: SimplePIDBlock.hpp:300
ls::blocks::BlockTraits::outTypes
static const ::std::array<::std::string, kOuts > outTypes
Output types (as strings).
Definition: BlockTraits.hpp:61
ls::blocks::BlockTraits::blockType
static constexpr const BlockType blockType
Block type.
Definition: BlockTraits.hpp:42
ls::blocks::BlockTraits::templateTypes
static const ::std::array<::std::string, 1 > templateTypes
Template parameter types (as strings).
Definition: BlockTraits.hpp:66
ls::blocks::Block
Generic base template class for all tuple-based Block instances.
Definition: Block.hpp:45
ls::blocks::BlockTraits::kIns
static const constexpr int kIns
Number of input slots.
Definition: BlockTraits.hpp:52
ls::blocks::std::SimplePIDBlock< TType, TOps, SimplePIDBlockParameter::AdditionalInput >
Definition: SimplePIDBlock.hpp:159
ls::blocks::std::SimplePIDBlock< TType, TOps, SimplePIDBlockParameter::Parametric >
Definition: SimplePIDBlock.hpp:35
ls::blocks::std::SimplePIDBlock< Eigen::Matrix< TScalar, TRows, TCols >, SimplePIDBlockOperator::Scalar, SimplePIDBlockParameter::AdditionalInput >
Definition: SimplePIDBlock.hpp:424
ls::blocks::BlockTraits::parTypes
static const ::std::array<::std::string, kPars > parTypes
Parameter types (as strings).
Definition: BlockTraits.hpp:63
ls::blocks::std::SimplePIDBlock< Eigen::Matrix< TScalar, TRows, TCols >, SimplePIDBlockOperator::Elementwise, SimplePIDBlockParameter::Parametric >
Definition: SimplePIDBlock.hpp:566
ls::blocks::std::SimplePIDBlock
Definition: SimplePIDBlock.hpp:29
ls::blocks::BlockTraits::kPars
static const constexpr int kPars
Number of parameters.
Definition: BlockTraits.hpp:56
ls::blocks::BlockTraits::kOuts
static const constexpr int kOuts
Number of output slots.
Definition: BlockTraits.hpp:54