element.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 _ELEMENT_H_
#define _ELEMENT_H_
 
#include "fmatvec/fmatvec.h"
#include "fmatvec/atom.h"
#include "mbsim/objectfactory.h"
#include "mbsim/utils/plotfeatureenum.h"
#include "mbsim/utils/initconfigenum.h"
#include "mbsim/namespace.h"
#include "mbsim/mbsim_event.h"
#include <hdf5serie/vectorserie.h>
 
namespace OpenMBV {
  class Group;
}
 
namespace H5 {
  class Group;
}
 
namespace MBSim {
 
  extern const PlotFeatureEnum plotRecursive, openMBV, debug;
 
  class DynamicSystemSolver;
  class Frame;
 
  class Element : virtual public fmatvec::Atom {
    public:
      enum InitStage {
        resolveStringRef=0, 
        preInit, 
        plotting, 
        unknownStage, 
        LASTINITSTAGE
      };
 
      Element(const std::string &name);
 
      ~Element() override = default;
 
#ifndef SWIG
      [[noreturn]]
#endif
      void throwError(const std::string &msg) const {
        throw MBSimError(this, msg);
      }
 
      virtual void setDynamicSystemSolver(DynamicSystemSolver *sys) { ds = sys; }
 
      virtual void plot();
 
      virtual void plotAtSpecialEvent() { }
 
      const std::string& getName() const { return name; }
 
      void setName(const std::string &str) { name = str; }
 
      // internal function do not use
      void setPath(const std::string &str) { path=str; }
 
      DynamicSystemSolver* getDynamicSystemSolver() { return ds; }
 
      virtual void init(InitStage stage, const InitConfigSet &config=InitConfigSet());
 
      virtual void createPlotGroup();
 
      H5::GroupBase *getPlotGroup() { return plotGroup; }
      virtual H5::GroupBase *getFramesPlotGroup() { return nullptr; }
      virtual H5::GroupBase *getContoursPlotGroup() { return nullptr; }
      virtual H5::GroupBase *getGroupsPlotGroup() { return nullptr; }
      virtual H5::GroupBase *getObjectsPlotGroup() { return nullptr; }
      virtual H5::GroupBase *getLinksPlotGroup() { return nullptr; }
      virtual H5::GroupBase *getConstraintsPlotGroup() { return nullptr; }
      virtual H5::GroupBase *getObserversPlotGroup() { return nullptr; }
 
      bool getPlotFeature(const PlotFeatureEnum &pf) {
        auto it=plotFeature.find(std::ref(pf));
        if(it==plotFeature.end())
          return false;
        return it->second;
      }
 
      virtual void setPlotFeature(const PlotFeatureEnum &pf, bool value);
 
      void setPlotFeatureForChildren(const PlotFeatureEnum &pf, bool value);
 
      void setPlotFeatureRecursive(const PlotFeatureEnum &pf, bool value) { setPlotFeature(pf,value); setPlotFeatureForChildren(pf,value); }
 
      template<class T>
      void setPlotAttribute(const std::string &name, const T &value) {
        plotAttribute[name] = value;
      }
      void setPlotAttribute(const std::string &name) {
        plotAttribute[name] = std::monostate();
      }
 
      virtual void initializeUsingXML(xercesc::DOMElement *element);
 
      template<class T> T* getByPath(const std::string &path, bool initialCaller=true) const;
 
      std::string getPath(const Element *relTo=nullptr, std::string sep="/") const;
 
      virtual Element* getChildByContainerAndName(const std::string &container, const std::string &name) const {
        throwError("This element has no containers with childs.");
      }
 
      virtual std::shared_ptr<OpenMBV::Group> getOpenMBVGrp() { return std::shared_ptr<OpenMBV::Group>(); }
      virtual std::shared_ptr<OpenMBV::Group> getFramesOpenMBVGrp() { return std::shared_ptr<OpenMBV::Group>(); }
      virtual std::shared_ptr<OpenMBV::Group> getContoursOpenMBVGrp() { return std::shared_ptr<OpenMBV::Group>(); }
      virtual std::shared_ptr<OpenMBV::Group> getGroupsOpenMBVGrp() { return std::shared_ptr<OpenMBV::Group>(); }
      virtual std::shared_ptr<OpenMBV::Group> getObjectsOpenMBVGrp() { return std::shared_ptr<OpenMBV::Group>(); }
      virtual std::shared_ptr<OpenMBV::Group> getLinksOpenMBVGrp() { return std::shared_ptr<OpenMBV::Group>(); }
      virtual std::shared_ptr<OpenMBV::Group> getConstraintsOpenMBVGrp() { return std::shared_ptr<OpenMBV::Group>(); }
      virtual std::shared_ptr<OpenMBV::Group> getObserversOpenMBVGrp() { return std::shared_ptr<OpenMBV::Group>(); }
 
      virtual Element* getParent() {return parent;}
      virtual const Element* getParent() const {return parent;}
      virtual void setParent(Element* parent_) {parent = parent_;}
 
      std::vector<Element*> getDependencies() const { return dependency; }
 
      void addDependency(Element* ele) { if(ele) dependency.push_back(ele); }
 
      int computeLevel();
 
      virtual void updatePositions(Frame *frame) { }
      virtual void updateVelocities(Frame *frame) { }
      virtual void updateAccelerations(Frame *frame) { }
      virtual void updateJacobians(Frame *frame, int j=0) { }
      virtual void updateGyroscopicAccelerations(Frame *frame) { }
 
      virtual void resetUpToDate() { }
 
      const double& getTime() const;
      double getStepSize() const;
 
#ifndef SWIG
      const MBXMLUtils::DOMEvalException& getDOMEvalError() const { return domEvalError; };
#endif
 
    protected:
      Element *parent { nullptr };
 
      std::string name;
 
      std::string path;
 
#ifndef SWIG
      MBXMLUtils::DOMEvalException domEvalError;
#endif
 
      DynamicSystemSolver *ds { nullptr };
 
      H5::VectorSerie<double> *plotVectorSerie { nullptr };
 
      std::vector<double> plotVector;
 
      std::vector<std::string> plotColumns;
 
      H5::GroupBase *plotGroup { nullptr };
 
      void updatePlotFeatures();
 
      std::vector<Element*> dependency;
 
      PlotFeatureMap plotFeature, plotFeatureForChildren;
 
      std::map<std::string, std::variant<
        std::monostate,
        int,
        double,
        std::string,
        std::vector<int>,
        std::vector<double>,
        std::vector<std::vector<double>>
      >> plotAttribute;
 
      void addToPlot(const std::string &name);
      void addToPlot(const std::string &name, int size);
      void addToPlot(const std::string &name, const std::vector<std::string> &iname);
 
      template<class AT> void plot(const AT &x) {
    plotVector.push_back(x);
      }
      template<class Type, class AT> void plot(const fmatvec::Vector<Type,AT> &x) {
    for(int i=0; i<x.size(); i++)
      plotVector.push_back(x(i));
      }
    private:
      Element* getByPathElement(const std::string &path, bool initialCaller=true) const;
  };
 
  template<class T>
  T* Element::getByPath(const std::string &path, bool initialCaller) const {
    Element *e = getByPathElement(path, initialCaller);
    auto *t=dynamic_cast<T*>(e);
    if(t)
      return t;
    else
       throwError(std::string("Cannot cast this element to type ")+typeid(T).name()+".");
  }
 
}
 
#endif