object.h

/* Copyright (C) 2004-2014 MBSim Development Team
 *
 * This library is free software; you can redistribute it and/or 
 * modify it under the terms of the GNU Lesser General Public 
 * License as published by the Free Software Foundation; either 
 * version 2.1 of the License, or (at your option) any later version. 
 *  
 * This library is distributed in the hope that it will be useful, 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
 * Lesser General Public License for more details. 
 *  
 * You should have received a copy of the GNU Lesser General Public 
 * License along with this library; if not, write to the Free Software 
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 *
 * Contact: martin.o.foerg@googlemail.com
 */
 
#ifndef _OBJECT_H_
#define _OBJECT_H_
 
#include "mbsim/element.h"
 
namespace MBSim {
 
  extern const PlotFeatureEnum generalizedPosition, generalizedVelocity, derivativeOfGeneralizedPosition, generalizedAcceleration;
 
  class DynamicSystem;
  class Link;
 
  class Object : public Element {
    public: 
      Object(const std::string &name);
 
      virtual void calcSize() { }
      int getGeneralizedPositionSize() { if(updSize) calcSize(); return nq; }
      int getGeneralizedVelocitySize() { if(updSize) calcSize(); return nu; }
 
      virtual void updateT() { }
      virtual void updateh(int j=0) { }
      virtual void updateM() { }
      virtual void updatedhdz();
      virtual void updatedq();
      virtual void updatedu();
      virtual void updateud();
      virtual void updateqd();
      virtual void sethSize(int hSize_, int i=0) { hSize[i] = hSize_; }
      int gethSize(int i=0) const { return hSize[i]; }
      int getqSize() const { return qSize; }
      int getuSize(int i=0) const { return uSize[i]; }
      virtual void calcqSize() { }
      virtual void calcuSize(int j) { }
      int getqInd() { return qInd; }
      int getuInd(int i=0) { return uInd[i]; }
      virtual void setqInd(int qInd_) { qInd = qInd_; }
      virtual void setuInd(int uInd_, int i=0) { uInd[i] = uInd_; }
      const fmatvec::Vec& getq() const { return q; }
      const fmatvec::Vec& getu() const { return u; }
      virtual H5::GroupBase *getPlotGroup() { return plotGroup; }
 
      /* INHERITED INTERFACE OF ELEMENT */
      void plot() override;
      /*******************************************************/ 
 
      virtual void updateqRef(fmatvec::Vec& qRef);
 
      virtual void updateqdRef(fmatvec::Vec& qdRef);
 
      virtual void updatedqRef(fmatvec::Vec& dqRef);
 
      virtual void updateuRef(fmatvec::Vec& uRef);
 
      virtual void updateuallRef(fmatvec::Vec& uallRef);
 
      virtual void updateudRef(fmatvec::Vec& udRef);
 
      virtual void updateduRef(fmatvec::Vec& duRef);
 
      virtual void updateudallRef(fmatvec::Vec& udallRef);
 
      virtual void updatehRef(fmatvec::Vec& hRef, int i=0);
 
      virtual void updatedhdqRef(fmatvec::Mat& dhdqRef, int i=0);
 
      virtual void updatedhduRef(fmatvec::SqrMat& dhduRef, int i=0);
 
      virtual void updatedhdtRef(fmatvec::Vec& dhdtRef, int i=0);
 
      virtual void updaterRef(fmatvec::Vec& ref, int i=0);
 
      virtual void updaterdtRef(fmatvec::Vec& ref);
 
      virtual void updateTRef(fmatvec::Mat &ref);
 
      virtual void updateMRef(fmatvec::SymMat &ref);
 
      virtual void updateLLMRef(fmatvec::SymMat &ref);
 
      void init(InitStage stage, const InitConfigSet &config) override;
 
      virtual void initz();
 
      virtual void writez(H5::GroupBase *group);
 
      virtual void readz0(H5::GroupBase *group);
 
      virtual void updateLLM() { LLM = facLL(evalM()); }
 
      virtual void setUpInverseKinetics() { }
      /*******************************************************/ 
 
      /* GETTER / SETTER */
      void setqSize(int qSize_) { qSize = qSize_; }
      void setuSize(int uSize_, int i=0) { uSize[i] = uSize_; }
      int getzSize() const { return qSize + uSize[0]; }
 
      virtual void sethInd(int hInd_, int i=0) { hInd[i] = hInd_; }
      int gethInd(int i=0) { return hInd[i]; }
 
      const fmatvec::SymMat& getM(bool check=true) const;
      fmatvec::SymMat& getM(bool check=true);
      const fmatvec::Vec& geth(int i=0, bool check=true) const;
      fmatvec::Vec& geth(int i=0, bool check=true);
 
      fmatvec::Vec& getq() { return q; };
      fmatvec::Vec& getu() { return u; };
 
      const fmatvec::Vec& getq0() const { return q0; };
      const fmatvec::Vec& getu0() const { return u0; };
      fmatvec::Vec& getq0() { return q0; };
      fmatvec::Vec& getu0() { return u0; };
 
      const fmatvec::Mat& evalT();
      const fmatvec::Vec& evalh(int i=0);
      const fmatvec::SymMat& evalM();
      const fmatvec::SymMat& evalLLM();
      const fmatvec::Vec& evalr(int i=0);
      const fmatvec::Vec& evalrdt();
      const fmatvec::Vec& evalqd();
      const fmatvec::Vec& evalud();
      const fmatvec::Vec& evaludall();
 
      fmatvec::Vec& getud(bool check=true);
      fmatvec::Vec& getudall(bool check=true);
 
      void resetUpToDate() override { updq = true; updu = true; updqd = true; updud = true; }
 
      virtual void updateGeneralizedPositions();
      virtual void updateGeneralizedVelocities();
      virtual void updateGeneralizedAccelerations();
      virtual void updateDerivativeOfGeneralizedPositions();
 
      const fmatvec::VecV& evalGeneralizedPosition() { if(updq) updateGeneralizedPositions(); return qRel; }
      const fmatvec::VecV& evalGeneralizedVelocity() { if(updu) updateGeneralizedVelocities(); return uRel; }
      const fmatvec::VecV& evalDerivativeOfGeneralizedPosition() { if(updqd) updateDerivativeOfGeneralizedPositions(); return qdRel; }
      const fmatvec::VecV& evalGeneralizedAcceleration() { if(updud) updateGeneralizedAccelerations(); return udRel; }
      fmatvec::VecV& getGeneralizedPosition(bool check=true) {  assert((not check) or (not updq)); return qRel; }
      fmatvec::VecV& getGeneralizedVelocity(bool check=true) {  assert((not check) or (not updu)); return uRel; }
      fmatvec::VecV& getDerivativeOfGeneralizedPosition(bool check=true) {  assert((not check) or (not updqd)); return qdRel; }
      fmatvec::VecV& getGeneralizedAcceleration(bool check=true) {  assert((not check) or (not updud)); return udRel; }
 
      void setq(const fmatvec::Vec &q_) { q = q_; }
      void setu(const fmatvec::Vec &u_) { u = u_; }
 
      bool hasNonCostantMassMatrix() { return nonConstantMassMatrix; }
      /*******************************************************/ 
 
      void initializeUsingXML(xercesc::DOMElement *element) override;
 
      void createPlotGroup() override;
 
    protected:
      int nq, nu;
 
      int qSize;
 
      int uSize[2];
 
      int hSize[2];
 
      int qInd, uInd[2], hInd[2];
 
      fmatvec::Vec q, u, uall;
 
      fmatvec::Vec q0, u0;
 
      fmatvec::Vec qd, ud, dq, du, udall;
 
      fmatvec::Vec h[2], r[2], rdt;
 
      fmatvec::Mat W[2], V[2];
 
      fmatvec::Mat    dhdq;
      fmatvec::SqrMat dhdu;
      fmatvec::Vec    dhdt;
 
      fmatvec::Mat T;
 
      fmatvec::SymMat M;
 
      fmatvec::SymMat LLM;
 
      fmatvec::VecV qRel, uRel, qdRel, udRel;
 
      bool updSize, updq, updu, updqd, updud;
 
      bool nonConstantMassMatrix{true};
  };
 
}
 
#endif /* _OBJECT_H_ */