mbsimcontrol  3.3.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 
00025 namespace MBSim {
00026   template <class Ret, class Arg> class Function1;
00027   template <class Ret, class Arg1, class Arg2> class Function2;
00028 }
00029 
00030 namespace MBSimControl {
00031 
00036   class SignalAddition : public Signal {
00037     public:
00038       SignalAddition(const std::string &name="") : Signal(name) {}
00039       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00040       void init(MBSim::InitStage stage);
00041       void addSignal(Signal * signal, double factor=1.);
00042       fmatvec::Vec getSignal();
00043     private:
00044       std::vector<Signal *> signals;
00045       std::vector<double> factors;
00046       std::vector<std::string> signalString;
00047       std::vector<double> factorsTmp;
00048   };
00049 
00054   class SignalOffset : public Signal {
00055     public:
00056       SignalOffset(const std::string &name="") : Signal(name), signal(0), offset(0, fmatvec::NONINIT), signalString("") {}
00057       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00058       void init(MBSim::InitStage stage);
00059       void setSignal(Signal * s) {signal=s; }
00060       void setOffset(fmatvec::Vec o) {offset=o; }
00061       fmatvec::Vec getSignal();
00062     private:
00063       Signal * signal;
00064       fmatvec::Vec offset;
00065       std::string signalString;
00066   };
00067 
00072   class SignalMultiplication : public Signal {
00073     public:
00074       SignalMultiplication(const std::string &name="") : Signal(name) {}
00075       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00076       void init(MBSim::InitStage stage);
00077       void addSignal(Signal * signal, double exp);
00078       fmatvec::Vec getSignal();
00079     private:
00080       std::vector<Signal *> signals;
00081       std::vector<double> exponents;
00082       std::vector<std::string> signalString;
00083       std::vector<double> exponentsTmp;
00084   };
00085 
00086 
00091   class SignalMux : public Signal {  
00092     public:
00093       SignalMux(const std::string &name="") : Signal(name) {}
00094       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00095       void init(MBSim::InitStage stage);
00096       void addSignal(Signal * signal) {signals.push_back(signal); }
00097       fmatvec::Vec getSignal();
00098     private:
00099       std::vector<Signal *> signals;
00100       std::vector<std::string> signalString;
00101   };
00102 
00103 
00108   class SignalDemux : public Signal {  
00109     public:
00110       SignalDemux(const std::string &name="") : Signal(name), totalSignalSize(0) {}
00111       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00112       void init(MBSim::InitStage stage);
00113       void addSignal(Signal * signal, fmatvec::VecInt index) {signals.push_back(signal); indizes.push_back(index); }
00114       fmatvec::Vec getSignal();
00115     private:
00116       std::vector<Signal *> signals;
00117       std::vector<fmatvec::VecInt > indizes;
00118       std::vector<fmatvec::Vec> indizesTmp;
00119       std::vector<std::string> signalString;
00120       int totalSignalSize;
00121   };
00122 
00123 
00128   class SignalLimitation : public Signal {  
00129     public:
00130       SignalLimitation(const std::string &name="") : Signal(name), s(NULL), minValue(), maxValue(), signalString("") {}
00131       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00132       void init(MBSim::InitStage stage);
00133       void setMinimalValue(fmatvec::Vec minValue_) {minValue=minValue_; }
00134       void setMaximalValue(fmatvec::Vec maxValue_) {maxValue=maxValue_; }
00135       void setSignal(Signal * signal_) {s=signal_; }
00136       fmatvec::Vec getSignal();
00137     private:
00138       Signal * s;
00139       fmatvec::Vec minValue, maxValue;
00140       std::string signalString;
00141   };
00142 
00143 
00148   class SignalTimeDiscretization : public Signal {  
00149     public:
00150       SignalTimeDiscretization(const std::string &name="") : Signal(name), s(NULL), y(), tOld(-99e99), signalString("") {}
00151       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00152       void init(MBSim::InitStage stage);
00153       void setSignal(Signal * signal_) {s=signal_; }
00154       void updateg(double t);
00155       fmatvec::Vec getSignal();
00156     private:
00157       Signal * s;
00158       fmatvec::Vec y;
00159       double tOld;
00160       std::string signalString;
00161   };
00162 
00163 
00168   class SignalOperation : public Signal {  
00169     public:
00170       SignalOperation(const std::string &name="") : Signal(name), s(NULL), s2(NULL), signalString(""), signal2String(""), op(0), s2values(0, fmatvec::NONINIT) {}
00171       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00172       void init(MBSim::InitStage stage);
00173       void setSignal(Signal * signal_) {s=signal_; }
00174       void setSecondSignal(Signal * signal_) {s2=signal_; }
00175       void setSecondSignalValues(fmatvec::Vec s2_) {s2values=s2_; }
00176       void setOperator(unsigned int op_) {op=op_; };
00177       fmatvec::Vec getSignal();
00178     private:
00179       Signal * s;
00180       Signal * s2;
00181       std::string signalString;
00182       std::string signal2String;
00183       unsigned int op;
00184       fmatvec::Vec s2values;
00185   };
00186 
00187 
00192   class SpecialSignalOperation : public Signal {  
00193     public:
00194       SpecialSignalOperation(const std::string &name="") : Signal(name), s(NULL), s2(NULL), signalString(""), signal2String(""), op(0), s2values(0, fmatvec::NONINIT) {}
00195       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00196       void init(MBSim::InitStage stage);
00197       void setSignal(Signal * signal_) {s=signal_; }
00198       void setSecondSignal(Signal * signal_) {s2=signal_; }
00199       void setSecondSignalValues(fmatvec::Vec s2_) {s2values=s2_; }
00200       void setOperator(unsigned int op_) {op=op_; };
00201       fmatvec::Vec getSignal();
00202     private:
00203       Signal * s;
00204       Signal * s2;
00205       std::string signalString;
00206       std::string signal2String;
00207       unsigned int op;
00208       fmatvec::Vec s2values;
00209   };
00210 
00215   class PIDController : public Signal {
00216 
00217     public:   
00218       PIDController(const std::string& name="") : Signal(name), s(NULL), sd(NULL) {}
00219       void initializeUsingXML(MBXMLUtils::TiXmlElement * element);
00220       
00221       void calcxSize() {xSize=getSignalMethod==&PIDController::getSignalPD?0:1;}
00222       
00223       void init(MBSim::InitStage stage);
00224 
00225       void updatedx(double t, double dt);
00226       void updatexd(double t);
00227       
00228       void plot(double t,double dt);
00229      
00230       void setPID(double P_, double I_, double D_);
00231       void setInputSignal(Signal *inputSignal_) {s=inputSignal_; }
00232       void setDerivativeOfInputSignal(Signal *inputSignal_) {sd=inputSignal_; }
00233 
00234       fmatvec::Vec getSignal();
00235 
00236     protected:
00237       double P,I,D;
00238       Signal *s, *sd;
00239       std::string sString, sdString;
00240       fmatvec::Vec (PIDController::*getSignalMethod)();
00241       fmatvec::Vec getSignalPD();
00242       fmatvec::Vec getSignalPID();
00243   };
00244 
00249   class UnarySignalOperation : public Signal {  
00250     public:
00251       UnarySignalOperation(const std::string &name="") : Signal(name), s(NULL), signalString(""), f(0) {}
00252       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00253       void init(MBSim::InitStage stage);
00254       void setSignal(Signal *signal_) {s=signal_; }
00255       void setFunction(MBSim::Function1<fmatvec::Vec,fmatvec::Vec> *f_) {f=f_; };
00256       fmatvec::Vec getSignal();
00257     private:
00258       Signal *s;
00259       std::string signalString;
00260       MBSim::Function1<fmatvec::Vec,fmatvec::Vec> *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(MBXMLUtils::TiXmlElement *element);
00271       void init(MBSim::InitStage stage);
00272       void setSignal1(Signal *signal_) {s1=signal_; }
00273       void setSignal2(Signal *signal_) {s2=signal_; }
00274       void setFunction(MBSim::Function2<fmatvec::Vec,fmatvec::Vec,fmatvec::Vec> *f_) {f=f_; };
00275       fmatvec::Vec getSignal();
00276     private:
00277       Signal *s1, *s2;
00278       std::string signal1String, signal2String;
00279       MBSim::Function2<fmatvec::Vec,fmatvec::Vec,fmatvec::Vec> *f;
00280   };
00281 
00282 }
00283 
00284 #endif /* _SIGNAL_MANIPULATION_H_ */
00285