Bond.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 _DEM_Bond_hpp_
#define _DEM_Bond_hpp_
 
#include "GranOO3/3rdParty/Eigen/Dense"
 
#include "GranOO3/Core/Prop.hpp"
#include "GranOO3/Core/SetOf.hpp"
#include "GranOO3/Physic/BodyInteraction.hpp"
#include "GranOO3/Physic/CriticalTimeStep.hpp"
 
#include "GranOO3/DEM/ExtendedSetOf/Bond.hpp"
 
namespace GranOO3
{
  namespace DEM
  {
    class Element;
 
    class Bond : public Physic::BodyInteraction,
         public Core::PropClass<Bond>,
         public Core::Register<Bond> {
 
      GRANOO_CLASS(DEM::Bond, Physic::BodyInteraction);
      GRANOO_CLASS_DEFAULT_COLOR(.8,.0, .1, 1.);
 
    public:
      static double get_disabled_cumulative_surface();
      static double epsilon;
      static double draw_solid_factor;
 
      enum FailureMode {NONE=0, TENSION=1, COMPRESSION=2, SHEAR=3};
      enum DrawMode    {SOLID, LINE, NO};
      static DrawMode  draw_mode;
      
    public:
      // for signal management
      static Core::Signal<Bond&>  disable_signal;
 
    private:
      static double _disabled_cumulative_surface;
 
    public:
      // Constructors and destructor
      Bond(Element& el1, Element& el2, bool contact = false); // use contact == true for bond that comes from contact
      virtual ~Bond() = 0;
 
      // Usefull for internal use only, NOT DOCUMENTED !
      virtual void draw();
      virtual std::string info() const;
 
      GRANOO_ACCESS (linear_damping_factor , double  , _linear_damping_factor  );
      GRANOO_ACCESS (angular_damping_factor, double  , _angular_damping_factor );
      GRANOO_ACCESS (relaxed_length        , double  , _relaxed_length         );
      GRANOO_ACCESS (initial_length        , double  , _initial_length         );
      GRANOO_ACCESS (current_length        , double  , _current_length         );
      GRANOO_ACCESS (max_relative_elongation , double     , _max_relative_elongation );
      GRANOO_ACCESS (surface                 , double     , _surface                 );
      GRANOO_ACCESS (failure_mode            , FailureMode, _failure_mode            );
 
      GRANOO_ACCESS_GET_COPY(current_relative_elongation, double, (_current_length - _initial_length)/_initial_length);
 
      GRANOO_ACCESS_GET(initial_pos1, Geom::Point, _initial_pos1);
      GRANOO_ACCESS_GET(initial_pos2, Geom::Point, _initial_pos2);
      GRANOO_ACCESS_GET(Q1, Geom::Quaternion, _quat_element1);
      GRANOO_ACCESS_GET(Q2, Geom::Quaternion, _quat_element2);
      GRANOO_ACCESS_GET(Q , Geom::Quaternion, _local_quat   );
      GRANOO_ACCESS_GET(F , Geom::Frame     , _local_frame  );
      GRANOO_ACCESS_REF(local_frame         , Geom::Frame, _local_frame         );
      GRANOO_ACCESS_REF(local_frame_element1, Geom::Frame, _local_frame_element1);
      GRANOO_ACCESS_REF(local_frame_element2, Geom::Frame, _local_frame_element2);
      
      // Accessing to discrete elements
      GRANOO_ACCESS_GET_PTR      (element1, Element, _element1);
      GRANOO_ACCESS_REF_PTR      (element1, Element, _element1);
      GRANOO_ACCESS_REF_CONST_PTR(element1, Element, _element1);
 
      GRANOO_ACCESS_GET_PTR      (element2, Element, _element2);
      GRANOO_ACCESS_REF_PTR      (element2, Element, _element2);
      GRANOO_ACCESS_REF_CONST_PTR(element2, Element, _element2);
 
      // for compatibility with ElementPair
      Element& get_item1();
      const Element& get_item1() const;
      Element& get_item2();
      const Element& get_item2() const;
 
      Element& item1();
      Element& item2();
 
      // force
      double get_normal_force_intensity() const;
      double get_tangential_force_intensity() const;
      
      // Access to bonded element
      Element & bonded_element(const Element &);
      const Element & get_bonded_element(const Element &) const;
 
      // Loading management
      virtual void compute_load();
      virtual double get_linear_stiffness() const;
      virtual double get_angular_stiffness() const;
 
      void apply_linear_damping_factor();
      void apply_angular_damping_factor();      
      void apply_load();
 
      // Enabled-disabled management
      void disable(bool manage_slave = true);
      void disable_fast_mode(bool manage_slave = true);
      void enable(bool manage_slave = true);
      bool is_disabled() const;
 
      // Enabled-disabled management
      void crack(bool manage_slave = true);
      void uncrack(bool manage_slave = true);
      bool is_cracked() const;
 
 
      
      // local frame management (must be triggered by child class)
      void init_local_frame(bool update_initial_param = false);
      void update_local_frame();
      void update_current_length();
 
      // Voronoi bond management
      void build_voronoi_bond();
 
      // Update FEM/DEM connection
      virtual void stiffness_matrix(Eigen::MatrixXd &kMatrix) { AssertMsg(0, "Method 'stiffness_matrix()' is not implemented."); };
      virtual void update_dof() { AssertMsg(0, "Method 'update_dof()' is not implemented."); };
      const std::vector<unsigned int>& get_dof() const;
 
      // Compute local displacement
      const Geom::Point& initial_pos(const Element& ) const;
      Geom::Vector get_disp(const Element& ) const;
      Geom::Vector get_disp1() const;
      Geom::Vector get_disp2() const;
 
      // swap element
      void swap(Element& from, Element& to);
      void add_slave(Bond& b);
 
      // IO
      virtual std::ostream& export_to_povray(std::ostream& out) const;
 
    protected:
      //SERIALIZATION
      friend class boost::serialization::access;
      template<class Archive> void save(Archive&, const unsigned int ) const;
      template<class Archive> void load(Archive&, const unsigned int);
      BOOST_SERIALIZATION_SPLIT_MEMBER();
 
    private:
      Bond() = delete;
      Bond(const Bond&) = delete;
      Bond & operator=(const Bond &) = delete;
 
    protected:
      Element* _element1;
      Element* _element2;
 
    private:
      bool        _disabled;
      bool        _cracked;
      FailureMode _failure_mode;
      double      _initial_length;
      Geom::Point _initial_pos1;
      Geom::Point _initial_pos2;
       //Geom Data
      Geom::Quaternion _quat_element1;    // express in de1 local frame
      Geom::Quaternion _quat_element2;    // express in de2 local frame
      Geom::Quaternion _local_quat;       // express in global frame
      Geom::Frame _local_frame;           // local frame (expressed from global frame)
      Geom::Point _local_center_element1; // express in de1 local frame
      Geom::Frame _local_frame_element1;  // from (P1, Q1, de1.local_frame)
      Geom::Point _local_center_element2; // express in de1 local frame
      Geom::Frame _local_frame_element2;  // from (P1, Q1, de1.local_frame)
    protected:
      double _linear_damping_factor;
      double _angular_damping_factor;
      double _relaxed_length;
      double _current_length;
      double _max_relative_elongation;
      double _surface;
      Core::SetOfBase<Bond>     _slave;
      std::vector<unsigned int> _dofs;
      
    };
 
    inline Element &
    Bond::bonded_element(const Element & de) {
      if (&de == _element1)
        return *_element2;
 
      SafeModeAssert(&de == _element2, "can't find de");
 
      return *_element1;
    }
 
    inline const Element &
    Bond::get_bonded_element(const Element & de) const {
      if (&de == _element1)
        return *_element2;
 
      SafeModeAssert(&de == _element2, "can't find de");
 
      return *_element1;
    }
 
    inline bool
    Bond::is_disabled() const {
      return _disabled;
    }
 
    inline bool
    Bond::is_cracked() const {
      return _cracked;
    }
 
    
    inline const std::vector<unsigned int> &
    Bond::get_dof() const {
      return _dofs;
    }
 
 
    // for compatibility with ElementPair
    inline Element& Bond::get_item1() {
      return *_element1;
    }
    
    inline const Element& Bond::get_item1() const {
      return *_element1;
    }
    
    inline Element& Bond::get_item2() {
      return *_element2;
    }
    
    inline const Element& Bond::get_item2() const {
      return *_element2;
    }
    
    inline Element& Bond::item1() {
      return *_element1;
    }
    
    inline Element& Bond::item2() {
      return *_element2;
    }
 
    //BOOST SERIALIZATION
    template<class Archive> void
    Bond::save(Archive & ar, const unsigned int version) const{
      ar << boost::serialization::base_object<Physic::BodyInteraction>(*this);
      ar << boost::serialization::base_object<Core::PropClass<Bond> >(*this);
      ar << _initial_length;
 
      ar << _initial_pos1;
      ar << _initial_pos2;
      ar << _quat_element1;
      ar << _quat_element2;
      ar << _local_quat; 
      ar << _local_center_element1;
      
      ar << _linear_damping_factor;
      ar << _angular_damping_factor;
      ar << _relaxed_length;
      ar << _current_length;
      ar << _max_relative_elongation;
      ar << _surface;
 
      if (version >= 1)
    ar << _failure_mode;
 
      if (version >= 2)
    ar << _cracked;
    }
 
    template<class Archive> void
    Bond::load(Archive & ar, const unsigned int version) {
      ar >> boost::serialization::base_object<Physic::BodyInteraction>(*this);
      ar >> boost::serialization::base_object<Core::PropClass<Bond> >(*this);
      ar >> _initial_length;
    
      ar >> _initial_pos1;
      ar >> _initial_pos2;
      ar >> _quat_element1;
      ar >> _quat_element2;
      ar >> _local_quat; 
      ar >> _local_center_element1;
      
      ar >> _linear_damping_factor;
      ar >> _angular_damping_factor;
      ar >> _relaxed_length;
      ar >> _current_length;
      ar >> _max_relative_elongation;
      ar >> _surface;
 
      if (version >= 1)
    ar >> _failure_mode;
 
      if (version >= 2)
    ar >> _cracked;
 
      _local_frame.update_glMatrix();
    }
 
  }
}
 
#include <boost/serialization/version.hpp>
BOOST_CLASS_VERSION(GranOO3::DEM::Bond, 2)
 
namespace GranOO3
{
  GRANOO_CLASS_DECLARE_TPL(DEM::Bond);
  extern template class Core::PropClass< DEM::Bond >;
}
 
#endif