Element.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 _LibDEM_Element_T
#define _LibDEM_Element_T
 
 
 
#include <boost/serialization/version.hpp>
#include <boost/serialization/map.hpp>
 
#include "GranOO3/DEM/ExtendedSetOf/Bond.hpp"
#include "GranOO3/DEM/NeighbourManager.hpp"
#include "GranOO3/Physic/Body.hpp"
#include "GranOO3/DEM/ExtendedSetOf/Element.hpp"
#include "GranOO3/Core/PropClass.hpp"
 
namespace GranOO3
{
  namespace DEM
  {
    class Bond;
    template<class T> class ElementT;
 
 
    class Element : public Physic::Body,
            public Core::PropClass< Element >,
            public Core::Register< Element >
    {
 
      GRANOO_CLASS(DEM::Element, Physic::Body);
      GRANOO_CLASS_DEFAULT_COLOR(.8, .0, .1, 1.);
 
    public:
      static Element* new_object(const TiXmlElement* el);
 
    public:
      // Constructors and destructor
      Element(Shape::Volume& shape, const Geom::Point & point);
      Element(Shape::Volume& shape);
 
      virtual ~Element() = 0;
 
      //INTERNAL USE (Not documented)
      virtual std::string shape_class_ID() const = 0;
 
      // Bond management
      void add_bond  (Bond& b);
      void erase_bond(Bond& b);
 
 
      // Bond management
      bool is_bonded(const Element& el) const;
      bool is_bonded(const Element& el, Bond*& commonBond);
      bool is_bonded(const Element& el, const Bond*& commonBond) const;
      bool is_bonded(const Bond& bond) const;
      Bond& common_bond(const Element& el);
      const Bond& common_bond(const Element& el) const;
      void delete_all_bond();
      Core::SetOfBase< Bond >& get_bond_set();
      size_t get_bond_number() const;
      Core::SetOfBase< Element > get_bonded_element();
      bool is_unbonded() const;
      bool is_bonded() const;
 
      double compute_kinetic_energy() const;
 
      // Bonded cluster management
      void compute_bond_cluster(Core::SetOfBase< DEM::Element >& cluster_set,
                                Core::SetOfBase< DEM::Bond >& parsed_bond);
 
      virtual std::string info() const;
 
      NeighbourManager<Element>& neighbour();
      const NeighbourManager<Element>& neighbour() const;
 
      Core::SetOfBase< Element >& neighbour_set();
      const Core::SetOfBase< Element >& neighbour_set() const;
 
      // cloning
      void make_equal_to(const Element& el);
 
      // IO
      virtual std::ostream& write_ascii (std::ostream& os) const;
      virtual std::istream& read_ascii (std::istream& is);
 
      // SHAPE CASTING
      virtual bool is_spherical_element() const = 0;
      virtual bool is_polyhedral_element() const = 0;
 
    private:
      Element(const Element&) = delete;
      Element & operator=(const Element &) = delete;
 
      //BOOST SERIALIZATION
      friend class boost::serialization::access;
      template<class Archive> void serialize(Archive&, const unsigned int);
 
    protected:
      Core::SetOfBase<Bond>      _bondset;
      NeighbourManager<Element> _neighbour;
    };
 
 
    inline Core::SetOfBase< Bond >&
    Element::get_bond_set() {
      return _bondset;
    }
 
    inline size_t
    Element::get_bond_number() const {
      return _bondset.size();
    }
 
    inline double
    Element::compute_kinetic_energy() const {
      const double V = get_linear_velocity().norm();
      const double W = get_angular_velocity().norm();
      return 0.5*( (get_mass()*V*V) + (get_inertia_tensor().xx()*W*W));
    }
 
    inline NeighbourManager<Element>&
    Element::neighbour() {
      return _neighbour;
    }
 
    inline const NeighbourManager<Element>&
    Element::neighbour() const {
      return _neighbour;
    }
 
    inline Core::SetOfBase< Element >&
    Element::neighbour_set() {
      return _neighbour.set();
    }
 
    inline const Core::SetOfBase< Element >&
    Element::neighbour_set() const {
      return _neighbour.set();
    }
 
 
    template<class Archive> void
    Element::serialize(Archive & ar, const unsigned int version) {
      ar & boost::serialization::base_object<Physic::Body>(*this);
      ar & boost::serialization::base_object<Core::PropClass<Element> >(*this);
    }
 
  }
}
 
#include <boost/serialization/version.hpp>
BOOST_CLASS_VERSION(GranOO3::DEM::Element, 0)
 
 
namespace GranOO3
{
  GRANOO_CLASS_DECLARE_TPL(DEM::Element);
  extern template class Core::PropClass< DEM::Element >;
}
 
 
 
#endif