EnergyBalance.hpp

Go to the documentation of this file.

// This file is part of GranOO, a workbench for DEM simulation.
//
// Author(s)    : - Damien Andre       IRCER/UNILIM, Limoges France
//                  <damien.andre@unilim.fr>
//                - Jean-luc Charles   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jean-luc.charles@ensam.eu>
//                - Jeremie Girardot   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jeremie.girardot@ensam.eu>
//                - Cedric Hubert      LAMIH/UPHF, Valenciennes France
//                  <cedric.hubert@uphf.fr>
//                - Ivan Iordanoff     Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <ivan.iordanoff@ensam.eu>
//
// Copyright (C) 2008-2019 D. Andre, JL. Charles, J. Girardot, C. Hubert, I. Iordanoff
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
#ifndef _LibPhysic_EnergyBalance_H
#define _LibPhysic_EnergyBalance_H
 
#include <map>
 
#include "GranOO3/Core/Singleton.hpp"
#include "GranOO3/Physic/Body.hpp"
#include "GranOO3/Physic/BodyInteraction.hpp"
#include "GranOO3/Physic/Node.hpp"
#include "GranOO3/Physic/NodeInteraction.hpp"
 
 
namespace GranOO3
{
 
  namespace Physic
  {
 
 
    class EnergyBalance : public Core::Singleton<EnergyBalance>
    {
    public:
      GRANOO_SINGLETON_CLASS(EnergyBalance);
 
    public:
      EnergyBalance();
      ~EnergyBalance();
 
      void enable();
      void disable();
      bool is_enable() const;
 
      void clear();
 
      template<typename T> void clear_map(T& map);
 
      void add_force_on (const Node&, const std::string& label, const Geom::Vector& force);
      void add_torque_on(const Body&, const std::string& label, const Geom::Vector& torque);
 
 
      void collect_interaction_force(const NodeInteraction &inter,
                                     const std::map<std::string, Geom::Vector>& map_forceOn1,
                                     const std::map<std::string, Geom::Vector>& map_forceOn2);
 
      void collect_interaction_torque(const BodyInteraction& inter,
                                      const std::map<std::string, Geom::Vector>& map_torque_on1,
                                      const std::map<std::string, Geom::Vector>& map_torque_on2);
 
 
 
      double compute_kinetic_energy() const;
      void update();
      std::vector<double>      value() const;
      std::vector<std::string> label() const;
 
      const std::map<std::string, double>&  get_energy() const;
      const std::map<std::string, double>&  get_energy_for(const Node&) const;
      const std::map<std::string, double>&  get_energy_for(const NodeInteraction&) const;
      double get_total_energy_for(const Node&) const;
      double get_total_energy_for(const NodeInteraction&) const;
 
      void manage_disabled_interaction(const NodeInteraction& inter);
 
    private:
      EnergyBalance(const EnergyBalance&) = delete;
      EnergyBalance & operator=(const EnergyBalance &) = delete;
 
    private:
      std::map<const Node*, std::map<std::string, Geom::Vector> > _force;
      std::map<const Body*, std::map<std::string, Geom::Vector> > _torque;
 
      std::map<const NodeInteraction*, const std::map<std::string, Geom::Vector>*> _force_on1;
      std::map<const NodeInteraction*, const std::map<std::string, Geom::Vector>*> _force_on2;
      std::map<const BodyInteraction*, const std::map<std::string, Geom::Vector>*> _torque_on1;
      std::map<const BodyInteraction*, const std::map<std::string, Geom::Vector>*> _torque_on2;
 
      std::map<const Node*, std::map<std::string, double> > _node_energy;
      std::map<const NodeInteraction*, std::map<std::string, double> > _interaction_energy;
 
      std::map<std::string, double> _total_energy;
 
    private:
      bool _enable;
    };
 
    template<typename T> void
    EnergyBalance::clear_map(T& map) {
      for (auto& it1: map)
        for (auto& it2: it1.second)
          it2.second.clear();
    }
  }
}
 
#endif