All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Pages
signal_manipulation.h
1 /* Copyright (C) 2004-2009 MBSim Development Team
2  *
3  * This library is free software; you can redistribute it and/or
4  * modify it under the terms of the GNU Lesser General Public
5  * License as published by the Free Software Foundation; either
6  * version 2.1 of the License, or (at your option) any later version.
7  *
8  * This library is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11  * Lesser General Public License for more details.
12  *
13  * You should have received a copy of the GNU Lesser General Public
14  * License along with this library; if not, write to the Free Software
15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16  *
17  * Contact: markus.ms.schneider@gmail.com
18  */
19 
20 #ifndef _SIGNAL_MANIPULATION_H_
21 #define _SIGNAL_MANIPULATION_H_
22 
23 #include "mbsimControl/signal_.h"
24 #include <mbsim/functions/function.h>
25 
26 namespace MBSimControl {
27 
32  class SignalMux : public Signal {
33  public:
34  SignalMux(const std::string &name="") : Signal(name) {}
35  void initializeUsingXML(xercesc::DOMElement *element);
36  void init(InitStage stage);
37  void addInputSignal(Signal * signal) {signals.push_back(signal); }
38  void updateSignal();
39  int getSignalSize() const { return signals[0]->getSignalSize(); }
40  private:
41  std::vector<Signal *> signals;
42  std::vector<std::string> signalString;
43  };
44 
49  class SignalDemux : public Signal {
50  public:
51  SignalDemux(const std::string &name="") : Signal(name) {}
52  void initializeUsingXML(xercesc::DOMElement *element);
53  void init(InitStage stage);
54  void setInputSignal(Signal * signal_) { signal=signal_; }
55  void setIndices(const fmatvec::VecInt &indices_) { indices = indices_; }
56  void updateSignal();
57  int getSignalSize() const { return signal->getSignalSize(); }
58  private:
59  Signal *signal;
60  fmatvec::VecInt indices;
61  fmatvec::VecV indicesTmp;
62  std::string signalString;
63  };
64 
69  class SignalTimeDiscretization : public Signal {
70  public:
71  SignalTimeDiscretization(const std::string &name="") : Signal(name), s(NULL), tOld(-99e99), signalString("") {}
72  void initializeUsingXML(xercesc::DOMElement *element);
73  void init(InitStage stage);
74  void setInputSignal(Signal * signal_) {s=signal_; }
75  void updateSignal();
76  int getSignalSize() const { return s->getSignalSize(); }
77  private:
78  Signal * s;
79  double tOld;
80  std::string signalString;
81  };
82 
87  class PIDController : public Signal {
88 
89  public:
90  PIDController(const std::string& name="") : Signal(name), s(NULL), sd(NULL) {}
91  void initializeUsingXML(xercesc::DOMElement * element);
92 
93  void calcxSize() {xSize=updateSignalMethod==&PIDController::updateSignalPD?0:1;}
94 
95  void init(InitStage stage);
96 
97  void updatedx();
98  void updatexd();
99 
100  void setPID(double P_, double I_, double D_);
101  void setInputSignal(Signal *inputSignal_) {s=inputSignal_; }
102  void setDerivativeOfInputSignal(Signal *inputSignal_) {sd=inputSignal_; }
103 
104  void updateSignal();
105  int getSignalSize() const { return s->getSignalSize(); }
106 
107  protected:
108  double P,I,D;
109  Signal *s, *sd;
110  std::string sString, sdString;
111  void (PIDController::*updateSignalMethod)();
112  void updateSignalPD();
113  void updateSignalPID();
114  };
115 
120  class UnarySignalOperation : public Signal {
121  public:
122  UnarySignalOperation(const std::string &name="") : Signal(name), s(NULL), signalString(""), f(0) { }
123  ~UnarySignalOperation() { delete f; }
124  void initializeUsingXML(xercesc::DOMElement *element);
125  void init(InitStage stage);
126  void setInputSignal(Signal *signal_) {s=signal_; }
127  void setFunction(MBSim::Function<fmatvec::VecV(fmatvec::VecV)> *f_) {
128  f=f_;
129  f->setParent(this);
130  f->setName("Function");
131  };
132  void updateSignal();
133  int getSignalSize() const { return s->getSignalSize(); }
134  private:
135  Signal *s;
136  std::string signalString;
138  };
139 
144  class BinarySignalOperation : public Signal {
145  public:
146  BinarySignalOperation(const std::string &name="") : Signal(name), s1(NULL), s2(NULL), signal1String(""), signal2String(""), f(0) { }
147  ~BinarySignalOperation() { delete f; }
148  void initializeUsingXML(xercesc::DOMElement *element);
149  void init(InitStage stage);
150  void setFirstInputSignal(Signal *signal_) {s1=signal_; }
151  void setSecondInputSignal(Signal *signal_) {s2=signal_; }
152  void setFunction(MBSim::Function<fmatvec::VecV(fmatvec::VecV,fmatvec::VecV)> *f_) {
153  f=f_;
154  f->setParent(this);
155  f->setName("Function");
156  };
157  void updateSignal();
158  int getSignalSize() const { return s1->getSignalSize(); }
159  private:
160  Signal *s1, *s2;
161  std::string signal1String, signal2String;
163  };
164 
165 }
166 
167 #endif /* _SIGNAL_MANIPULATION_H_ */
168 
SignalTimeDiscretization.
Definition: signal_manipulation.h:69
SignalMux.
Definition: signal_manipulation.h:32
BinarySignalOperation.
Definition: signal_manipulation.h:144
Signal.
Definition: signal_.h:37
UnarySignalOperation.
Definition: signal_manipulation.h:120
SignalDemux.
Definition: signal_manipulation.h:49
PID controller.
Definition: signal_manipulation.h:87

Impressum / Disclaimer / Datenschutz Generated by doxygen 1.8.5 Valid HTML