ContactBond.hpp

Go to the documentation of this file.

// This file is part of GranOO, a workbench for DEM simulation.
//
// Author(s)    : - Jean-luc CHARLES I2M-DuMAS/ENSAM Talence France
//                  <jean-luc.charles@ensam.eu>
//                - Damien ANDRE     SPCTS/ENS Ceramique industrielle, Limoges France
//                  <damien.andre@unilim.fr>
//                - Jeremie GIRARDOT I2M-DuMAS/ENSAM Talence France
//                  <jeremie.girardot@ensam.eu>
//                - Cedric Hubert    LAMIH/UVHC Valenciennes France
//                  <cedric.hubert@univ-valenciennes.fr>
//                - Ivan IORDANOFF   I2M-DuMAS-MPI/ENSAM Talence France
//                  <ivan.iordanoff@ensam.eu>
//
// Copyright (C) 2008-2016 JL. CHARLES, D. ANDRE, I. IORDANOFF, J. GIRARDOT
//
//
//
//
//
// 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_ContactBond_hpp_
#define _libDEM_ContactBond_hpp_
 
#include <string>
#include <vector>
 
 
 
#include "GranOO3/DEM/Bond.hpp"
#include "GranOO3/Core/SetOf.hpp"
#include "GranOO3/DEM/Element.hpp"
#include "GranOO3/DEM/Prop/VoronoiBond.hpp"
 
#include "GranOO3/Geom/Point.hpp" 
#include "GranOO3/Collision/Contact.hpp"
 
namespace GranOO3
{
  namespace DEM
  {
 
    
    class ContactBond : public Bond,
            public Core::Register<ContactBond >,
            public Physic::CriticalTimeStep
    {
 
      GRANOO_CLASS(DEM::ContactBond, Bond);
 
    public:
      template<class T1, class T2> static void init_contact_detection_step();
      template<class T1, class T2> static void manage_contact(T1& t1, T2 &t2);
      template<class T1, class T2> static void apply_contact_load(T1& t1, T2 &t2, const Geom::Vector& force, const Geom::Vector& torque, const Geom::Point& contact, const double surface=0.);
 
    private:
      static std::map<unsigned long long int, ContactBond*> _all_map;
      
    public:
      //CONSTRUCTORS & DESTRUCTORS
      ContactBond(Element& el1, Element& el2);
      virtual ~ContactBond();
 
      //USEFULL
      void init();
      virtual void update();
      virtual void compute_load();
      virtual double compute_critical_time_step() const;
      virtual std::string info() const;
       
    private:
      ContactBond() = delete;      
      ContactBond(const ContactBond&) = delete;
      ContactBond & operator=(const ContactBond&) = delete; 
 
    private:
      //BOOST SERIALIZATION
      friend class boost::serialization::access;
      template<class Archive> void serialize(Archive&, const unsigned int);
 
    private:
      const unsigned long long int _numID;
    };    
 
    //BOOST SERIALIZATION
     
    template<class Archive> void 
    ContactBond::serialize(Archive & ar, const unsigned int version) {
      ar &boost::serialization::base_object<Bond>(*this);
    }
 
    template<class T1, class T2>
    inline void
    ContactBond::init_contact_detection_step() {
      if constexpr (std::is_base_of<T1, Physic::Body>::value && std::is_base_of<T2, Physic::Body>::value) {
      for (auto& b : ContactBond::all()) {
        b->clear_force();
        b->clear_torque();
        b->disable_fast_mode();
      }
    }
    }
 
    template<class T1, class T2>
    inline void
    ContactBond::manage_contact(T1& t1, T2 &t2) {
      if constexpr (std::is_base_of<T1, Physic::Body>::value && std::is_base_of<T2, Physic::Body>::value) {
      const unsigned long long int numID = Collision::Contact<T1, T2>::compute_ID(t1,t2);
      if (_all_map.count(numID) == 0) {
        Element* el1 = dynamic_cast<Element*>(&t1);
        Element* el2 = dynamic_cast<Element*>(&t2);
        InternAssert(el1 != nullptr);
        InternAssert(el2 != nullptr);
        
        ContactBond* b = new ContactBond(*el1, *el2);
        b->clear_force();
        b->clear_torque();
        InternAssert(_all_map.count(numID) == 1);
      }  else {
        InternAssert(_all_map.count(numID) == 1);
        _all_map[numID]->enable();
      }
    }
    }
     template<class T1, class T2>
     inline void
     ContactBond::apply_contact_load(T1& t1, T2 &t2, const Geom::Vector& force,
                     const Geom::Vector& torque, const Geom::Point& contact_point, const double surface) {
       if constexpr (std::is_base_of<T1, Physic::Body>::value && std::is_base_of<T2, Physic::Body>::value) {
       const unsigned long long int numID = Collision::Contact<T1, T2>::compute_ID(t1,t2);
       InternAssert(_all_map.count(numID) == 1);
       ContactBond* b = _all_map[numID];
       InternAssert(b->is_disabled() == false);
 
       const DEM::Element& el1 = b->get_element1();
       const DEM::Element& el2 = b->get_element2();
       const bool inverse = !t1.is_same(b->get_element1());
       
       //Check
       if (inverse)
         InternAssert(t2.is_same(el1) && t1.is_same(el2));
       else
         InternAssert(t1.is_same(el1) && t2.is_same(el2));
                
       Geom::Vector f = (inverse == false) ? force  : -force ;
       Geom::Vector t = (inverse == false) ? torque : -torque;
       
       b->_force_on1 =  f;
       b->_force_on2 = -f;
 
       b->_torque_on1 =  t + (Geom::Vector(b->get_element1().get_center(), contact_point) ^  f);
       b->_torque_on2 = -t + (Geom::Vector(b->get_element2().get_center(), contact_point) ^ -f);
 
       b->set_surface(surface);
       
     }
     }
    
  } 
}
 
 
#include <boost/serialization/version.hpp>
BOOST_CLASS_VERSION(GranOO3::DEM::ContactBond, 0)
 
 
// need placement new snippet because no default constructor exist
namespace boost 
{ 
  namespace serialization 
  {
    
    template<class Archive> void
    save_construct_data(Archive & ar, 
            const GranOO3::DEM::ContactBond * t, 
            const unsigned int) {
      const GranOO3::DEM::Element* de1 = &t->get_element1();
      const GranOO3::DEM::Element* de2 = &t->get_element2();
      ar << de1;
      ar << de2;
    }
    
 
    template<class Archive> void
    load_construct_data(Archive & ar, 
            GranOO3::DEM::ContactBond * t, 
            const unsigned int) {
      GranOO3::DEM::Element* de1 = nullptr;
      GranOO3::DEM::Element* de2 = nullptr;
      ar >> de1;
      ar >> de2;
      ::new(t)GranOO3::DEM::ContactBond(*de1,*de2);
    }
    
  }
} 
 
 
namespace GranOO3{
  GRANOO_CLASS_DECLARE_TPL(DEM::ContactBond);
}
 
 
#endif