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 SignalAddition : public Signal {
33  public:
34  SignalAddition(const std::string &name="") : Signal(name) {}
35  void initializeUsingXML(xercesc::DOMElement *element);
36  void init(InitStage stage);
37  void addSignal(Signal * signal, double factor=1.);
38  fmatvec::VecV getSignal();
39  private:
40  std::vector<Signal *> signals;
41  std::vector<double> factors;
42  std::vector<std::string> signalString;
43  std::vector<double> factorsTmp;
44  };
45 
50  class SignalOffset : public Signal {
51  public:
52  SignalOffset(const std::string &name="") : Signal(name), signal(0), offset(0, fmatvec::NONINIT), signalString("") {}
53  void initializeUsingXML(xercesc::DOMElement *element);
54  void init(InitStage stage);
55  void setSignal(Signal * s) {signal=s; }
56  void setOffset(fmatvec::VecV o) {offset=o; }
57  fmatvec::VecV getSignal();
58  private:
59  Signal * signal;
60  fmatvec::VecV offset;
61  std::string signalString;
62  };
63 
68  class SignalMultiplication : public Signal {
69  public:
70  SignalMultiplication(const std::string &name="") : Signal(name) {}
71  void initializeUsingXML(xercesc::DOMElement *element);
72  void init(InitStage stage);
73  void addSignal(Signal * signal, double exp);
74  fmatvec::VecV getSignal();
75  private:
76  std::vector<Signal *> signals;
77  std::vector<double> exponents;
78  std::vector<std::string> signalString;
79  std::vector<double> exponentsTmp;
80  };
81 
82 
87  class SignalMux : public Signal {
88  public:
89  SignalMux(const std::string &name="") : Signal(name) {}
90  void initializeUsingXML(xercesc::DOMElement *element);
91  void init(InitStage stage);
92  void addSignal(Signal * signal) {signals.push_back(signal); }
93  fmatvec::VecV getSignal();
94  private:
95  std::vector<Signal *> signals;
96  std::vector<std::string> signalString;
97  };
98 
99 
104  class SignalDemux : public Signal {
105  public:
106  SignalDemux(const std::string &name="") : Signal(name), totalSignalSize(0) {}
107  void initializeUsingXML(xercesc::DOMElement *element);
108  void init(InitStage stage);
109  void addSignal(Signal * signal, fmatvec::VecInt index) {signals.push_back(signal); indizes.push_back(index); }
110  fmatvec::VecV getSignal();
111  private:
112  std::vector<Signal *> signals;
113  std::vector<fmatvec::VecInt > indizes;
114  std::vector<fmatvec::Vec> indizesTmp;
115  std::vector<std::string> signalString;
116  int totalSignalSize;
117  };
118 
119 
124  class SignalLimitation : public Signal {
125  public:
126  SignalLimitation(const std::string &name="") : Signal(name), s(NULL), minValue(), maxValue(), signalString("") {}
127  void initializeUsingXML(xercesc::DOMElement *element);
128  void init(InitStage stage);
129  void setMinimalValue(fmatvec::VecV minValue_) {minValue=minValue_; }
130  void setMaximalValue(fmatvec::VecV maxValue_) {maxValue=maxValue_; }
131  void setSignal(Signal * signal_) {s=signal_; }
132  fmatvec::VecV getSignal();
133  private:
134  Signal * s;
135  fmatvec::VecV minValue, maxValue;
136  std::string signalString;
137  };
138 
139 
145  public:
146  SignalTimeDiscretization(const std::string &name="") : Signal(name), s(NULL), y(), tOld(-99e99), signalString("") {}
147  void initializeUsingXML(xercesc::DOMElement *element);
148  void init(InitStage stage);
149  void setSignal(Signal * signal_) {s=signal_; }
150  void updateg(double t);
151  fmatvec::VecV getSignal();
152  private:
153  Signal * s;
154  fmatvec::VecV y;
155  double tOld;
156  std::string signalString;
157  };
158 
159 
164  class SignalOperation : public Signal {
165  public:
166  SignalOperation(const std::string &name="") : Signal(name), s(NULL), s2(NULL), signalString(""), signal2String(""), op(0), s2values(0, fmatvec::NONINIT) {}
167  void initializeUsingXML(xercesc::DOMElement *element);
168  void init(InitStage stage);
169  void setSignal(Signal * signal_) {s=signal_; }
170  void setSecondSignal(Signal * signal_) {s2=signal_; }
171  void setSecondSignalValues(fmatvec::VecV s2_) {s2values=s2_; }
172  void setOperator(unsigned int op_) {op=op_; };
173  fmatvec::VecV getSignal();
174  private:
175  Signal * s;
176  Signal * s2;
177  std::string signalString;
178  std::string signal2String;
179  unsigned int op;
180  fmatvec::VecV s2values;
181  };
182 
183 
188  class SpecialSignalOperation : public Signal {
189  public:
190  SpecialSignalOperation(const std::string &name="") : Signal(name), s(NULL), s2(NULL), signalString(""), signal2String(""), op(0), s2values(0, fmatvec::NONINIT) {}
191  void initializeUsingXML(xercesc::DOMElement *element);
192  void init(InitStage stage);
193  void setSignal(Signal * signal_) {s=signal_; }
194  void setSecondSignal(Signal * signal_) {s2=signal_; }
195  void setSecondSignalValues(fmatvec::VecV s2_) {s2values=s2_; }
196  void setOperator(unsigned int op_) {op=op_; };
197  fmatvec::VecV getSignal();
198  private:
199  Signal * s;
200  Signal * s2;
201  std::string signalString;
202  std::string signal2String;
203  unsigned int op;
204  fmatvec::VecV s2values;
205  };
206 
211  class PIDController : public Signal {
212 
213  public:
214  PIDController(const std::string& name="") : Signal(name), s(NULL), sd(NULL) {}
215  void initializeUsingXML(xercesc::DOMElement * element);
216 
217  void calcxSize() {xSize=getSignalMethod==&PIDController::getSignalPD?0:1;}
218 
219  void init(InitStage stage);
220 
221  void updatedx(double t, double dt);
222  void updatexd(double t);
223 
224  void plot(double t,double dt);
225 
226  void setPID(double P_, double I_, double D_);
227  void setInputSignal(Signal *inputSignal_) {s=inputSignal_; }
228  void setDerivativeOfInputSignal(Signal *inputSignal_) {sd=inputSignal_; }
229 
230  fmatvec::VecV getSignal();
231 
232  protected:
233  double P,I,D;
234  Signal *s, *sd;
235  std::string sString, sdString;
236  fmatvec::VecV (PIDController::*getSignalMethod)();
237  fmatvec::VecV getSignalPD();
238  fmatvec::VecV getSignalPID();
239  };
240 
245  class UnarySignalOperation : public Signal {
246  public:
247  UnarySignalOperation(const std::string &name="") : Signal(name), s(NULL), signalString(""), f(0) {}
248  void initializeUsingXML(xercesc::DOMElement *element);
249  void init(InitStage stage);
250  void setSignal(Signal *signal_) {s=signal_; }
251  void setFunction(MBSim::Function<fmatvec::VecV(fmatvec::VecV)> *f_) {
252  f=f_;
253  f->setParent(this);
254  f->setName("Function");
255  };
256  fmatvec::VecV getSignal();
257  private:
258  Signal *s;
259  std::string signalString;
260  MBSim::Function<fmatvec::VecV(fmatvec::VecV)> *f;
261  };
262 
267  class BinarySignalOperation : public Signal {
268  public:
269  BinarySignalOperation(const std::string &name="") : Signal(name), s1(NULL), s2(NULL), signal1String(""), signal2String(""), f(0) {}
270  void initializeUsingXML(xercesc::DOMElement *element);
271  void init(InitStage stage);
272  void setSignal1(Signal *signal_) {s1=signal_; }
273  void setSignal2(Signal *signal_) {s2=signal_; }
274  void setFunction(MBSim::Function<fmatvec::VecV(fmatvec::VecV,fmatvec::VecV)> *f_) {
275  f=f_;
276  f->setParent(this);
277  f->setName("Function");
278  };
279  fmatvec::VecV getSignal();
280  private:
281  Signal *s1, *s2;
282  std::string signal1String, signal2String;
283  MBSim::Function<fmatvec::VecV(fmatvec::VecV,fmatvec::VecV)> *f;
284  };
285 
286 }
287 
288 #endif /* _SIGNAL_MANIPULATION_H_ */
289 
SignalTimeDiscretization.
Definition: signal_manipulation.h:144
SignalAddition.
Definition: signal_manipulation.h:32
SignalMux.
Definition: signal_manipulation.h:87
BinarySignalOperation.
Definition: signal_manipulation.h:267
SignalOperation according &lt;cmath&gt;
Definition: signal_manipulation.h:164
Signal.
Definition: signal_.h:37
SignalLimitation.
Definition: signal_manipulation.h:124
SpecialSignalOperation with advanced functionality.
Definition: signal_manipulation.h:188
UnarySignalOperation.
Definition: signal_manipulation.h:245
SignalMultiplication.
Definition: signal_manipulation.h:68
SignalDemux.
Definition: signal_manipulation.h:104
SignalOffset.
Definition: signal_manipulation.h:50
PID controller.
Definition: signal_manipulation.h:211

Impressum / Disclaimer / Datenschutz Generated by doxygen 1.8.5 Valid HTML