mbsimcontrol  4.0.0
signal_manipulation.h
00001 /* Copyright (C) 2004-2009 MBSim Development Team
00002  *
00003  * This library is free software; you can redistribute it and/or 
00004  * modify it under the terms of the GNU Lesser General Public 
00005  * License as published by the Free Software Foundation; either 
00006  * version 2.1 of the License, or (at your option) any later version. 
00007  *  
00008  * This library is distributed in the hope that it will be useful, 
00009  * but WITHOUT ANY WARRANTY; without even the implied warranty of 
00010  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
00011  * Lesser General Public License for more details. 
00012  *  
00013  * You should have received a copy of the GNU Lesser General Public 
00014  * License along with this library; if not, write to the Free Software 
00015  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
00016  *
00017  * Contact: markus.ms.schneider@gmail.com
00018  */
00019 
00020 #ifndef _SIGNAL_MANIPULATION_H_
00021 #define _SIGNAL_MANIPULATION_H_
00022 
00023 #include "mbsimControl/signal_.h"
00024 #include <mbsim/functions/function.h>
00025 
00026 namespace MBSimControl {
00027 
00032   class SignalAddition : public Signal {
00033     public:
00034       SignalAddition(const std::string &name="") : Signal(name) {}
00035       void initializeUsingXML(xercesc::DOMElement *element);
00036       void init(InitStage stage);
00037       void addSignal(Signal * signal, double factor=1.);
00038       fmatvec::VecV getSignal();
00039     private:
00040       std::vector<Signal *> signals;
00041       std::vector<double> factors;
00042       std::vector<std::string> signalString;
00043       std::vector<double> factorsTmp;
00044   };
00045 
00050   class SignalOffset : public Signal {
00051     public:
00052       SignalOffset(const std::string &name="") : Signal(name), signal(0), offset(0, fmatvec::NONINIT), signalString("") {}
00053       void initializeUsingXML(xercesc::DOMElement *element);
00054       void init(InitStage stage);
00055       void setSignal(Signal * s) {signal=s; }
00056       void setOffset(fmatvec::VecV o) {offset=o; }
00057       fmatvec::VecV getSignal();
00058     private:
00059       Signal * signal;
00060       fmatvec::VecV offset;
00061       std::string signalString;
00062   };
00063 
00068   class SignalMultiplication : public Signal {
00069     public:
00070       SignalMultiplication(const std::string &name="") : Signal(name) {}
00071       void initializeUsingXML(xercesc::DOMElement *element);
00072       void init(InitStage stage);
00073       void addSignal(Signal * signal, double exp);
00074       fmatvec::VecV getSignal();
00075     private:
00076       std::vector<Signal *> signals;
00077       std::vector<double> exponents;
00078       std::vector<std::string> signalString;
00079       std::vector<double> exponentsTmp;
00080   };
00081 
00082 
00087   class SignalMux : public Signal {  
00088     public:
00089       SignalMux(const std::string &name="") : Signal(name) {}
00090       void initializeUsingXML(xercesc::DOMElement *element);
00091       void init(InitStage stage);
00092       void addSignal(Signal * signal) {signals.push_back(signal); }
00093       fmatvec::VecV getSignal();
00094     private:
00095       std::vector<Signal *> signals;
00096       std::vector<std::string> signalString;
00097   };
00098 
00099 
00104   class SignalDemux : public Signal {  
00105     public:
00106       SignalDemux(const std::string &name="") : Signal(name), totalSignalSize(0) {}
00107       void initializeUsingXML(xercesc::DOMElement *element);
00108       void init(InitStage stage);
00109       void addSignal(Signal * signal, fmatvec::VecInt index) {signals.push_back(signal); indizes.push_back(index); }
00110       fmatvec::VecV getSignal();
00111     private:
00112       std::vector<Signal *> signals;
00113       std::vector<fmatvec::VecInt > indizes;
00114       std::vector<fmatvec::Vec> indizesTmp;
00115       std::vector<std::string> signalString;
00116       int totalSignalSize;
00117   };
00118 
00119 
00124   class SignalLimitation : public Signal {  
00125     public:
00126       SignalLimitation(const std::string &name="") : Signal(name), s(NULL), minValue(), maxValue(), signalString("") {}
00127       void initializeUsingXML(xercesc::DOMElement *element);
00128       void init(InitStage stage);
00129       void setMinimalValue(fmatvec::VecV minValue_) {minValue=minValue_; }
00130       void setMaximalValue(fmatvec::VecV maxValue_) {maxValue=maxValue_; }
00131       void setSignal(Signal * signal_) {s=signal_; }
00132       fmatvec::VecV getSignal();
00133     private:
00134       Signal * s;
00135       fmatvec::VecV minValue, maxValue;
00136       std::string signalString;
00137   };
00138 
00139 
00144   class SignalTimeDiscretization : public Signal {  
00145     public:
00146       SignalTimeDiscretization(const std::string &name="") : Signal(name), s(NULL), y(), tOld(-99e99), signalString("") {}
00147       void initializeUsingXML(xercesc::DOMElement *element);
00148       void init(InitStage stage);
00149       void setSignal(Signal * signal_) {s=signal_; }
00150       void updateg(double t);
00151       fmatvec::VecV getSignal();
00152     private:
00153       Signal * s;
00154       fmatvec::VecV y;
00155       double tOld;
00156       std::string signalString;
00157   };
00158 
00159 
00164   class SignalOperation : public Signal {  
00165     public:
00166       SignalOperation(const std::string &name="") : Signal(name), s(NULL), s2(NULL), signalString(""), signal2String(""), op(0), s2values(0, fmatvec::NONINIT) {}
00167       void initializeUsingXML(xercesc::DOMElement *element);
00168       void init(InitStage stage);
00169       void setSignal(Signal * signal_) {s=signal_; }
00170       void setSecondSignal(Signal * signal_) {s2=signal_; }
00171       void setSecondSignalValues(fmatvec::VecV s2_) {s2values=s2_; }
00172       void setOperator(unsigned int op_) {op=op_; };
00173       fmatvec::VecV getSignal();
00174     private:
00175       Signal * s;
00176       Signal * s2;
00177       std::string signalString;
00178       std::string signal2String;
00179       unsigned int op;
00180       fmatvec::VecV s2values;
00181   };
00182 
00183 
00188   class SpecialSignalOperation : public Signal {  
00189     public:
00190       SpecialSignalOperation(const std::string &name="") : Signal(name), s(NULL), s2(NULL), signalString(""), signal2String(""), op(0), s2values(0, fmatvec::NONINIT) {}
00191       void initializeUsingXML(xercesc::DOMElement *element);
00192       void init(InitStage stage);
00193       void setSignal(Signal * signal_) {s=signal_; }
00194       void setSecondSignal(Signal * signal_) {s2=signal_; }
00195       void setSecondSignalValues(fmatvec::VecV s2_) {s2values=s2_; }
00196       void setOperator(unsigned int op_) {op=op_; };
00197       fmatvec::VecV getSignal();
00198     private:
00199       Signal * s;
00200       Signal * s2;
00201       std::string signalString;
00202       std::string signal2String;
00203       unsigned int op;
00204       fmatvec::VecV s2values;
00205   };
00206 
00211   class PIDController : public Signal {
00212 
00213     public:   
00214       PIDController(const std::string& name="") : Signal(name), s(NULL), sd(NULL) {}
00215       void initializeUsingXML(xercesc::DOMElement * element);
00216       
00217       void calcxSize() {xSize=getSignalMethod==&PIDController::getSignalPD?0:1;}
00218       
00219       void init(InitStage stage);
00220 
00221       void updatedx(double t, double dt);
00222       void updatexd(double t);
00223       
00224       void plot(double t,double dt);
00225      
00226       void setPID(double P_, double I_, double D_);
00227       void setInputSignal(Signal *inputSignal_) {s=inputSignal_; }
00228       void setDerivativeOfInputSignal(Signal *inputSignal_) {sd=inputSignal_; }
00229 
00230       fmatvec::VecV getSignal();
00231 
00232     protected:
00233       double P,I,D;
00234       Signal *s, *sd;
00235       std::string sString, sdString;
00236       fmatvec::VecV (PIDController::*getSignalMethod)();
00237       fmatvec::VecV getSignalPD();
00238       fmatvec::VecV getSignalPID();
00239   };
00240 
00245   class UnarySignalOperation : public Signal {  
00246     public:
00247       UnarySignalOperation(const std::string &name="") : Signal(name), s(NULL), signalString(""), f(0) {}
00248       void initializeUsingXML(xercesc::DOMElement *element);
00249       void init(InitStage stage);
00250       void setSignal(Signal *signal_) {s=signal_; }
00251       void setFunction(MBSim::Function<fmatvec::VecV(fmatvec::VecV)> *f_) {
00252         f=f_;
00253         f->setParent(this);
00254         f->setName("Function");
00255       };
00256       fmatvec::VecV getSignal();
00257     private:
00258       Signal *s;
00259       std::string signalString;
00260       MBSim::Function<fmatvec::VecV(fmatvec::VecV)> *f;
00261   };
00262 
00267   class BinarySignalOperation : public Signal {  
00268     public:
00269       BinarySignalOperation(const std::string &name="") : Signal(name), s1(NULL), s2(NULL), signal1String(""), signal2String(""), f(0) {}
00270       void initializeUsingXML(xercesc::DOMElement *element);
00271       void init(InitStage stage);
00272       void setSignal1(Signal *signal_) {s1=signal_; }
00273       void setSignal2(Signal *signal_) {s2=signal_; }
00274       void setFunction(MBSim::Function<fmatvec::VecV(fmatvec::VecV,fmatvec::VecV)> *f_) {
00275         f=f_;
00276         f->setParent(this);
00277         f->setName("Function");
00278       };
00279       fmatvec::VecV getSignal();
00280     private:
00281       Signal *s1, *s2;
00282       std::string signal1String, signal2String;
00283       MBSim::Function<fmatvec::VecV(fmatvec::VecV,fmatvec::VecV)> *f;
00284   };
00285 
00286 }
00287 
00288 #endif /* _SIGNAL_MANIPULATION_H_ */
00289