ContactDetection.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_ContactDetection_hpp_
#define _libDEM_ContactDetection_hpp_
 
#include "GranOO3/Core/Macro.hpp"
#include "GranOO3/Math/Stat.hpp"
#include "GranOO3/DEM/ContactLaw.hpp"
#include "GranOO3/DEM/DiscreteElement.hpp"
#include "GranOO3/Core/NeedSetOf.hpp"
#include "GranOO3/Collision/Manager.hpp"
#include "GranOO3/Physic/CriticalTimeStep.hpp"
#include "GranOO3/FEM/Surface.hpp"
 
//
// Base class for detection method
//
 
namespace GranOO3
{
  namespace DEM
  {
 
    template<class T>
    class ContactDetection : public Collision::BroadPhase<DEM::DiscreteElement, T>,
                 public Core::NeedSetOf< DiscreteElement>
    {
    public:
      static ContactDetection& get_ByUniqueId(const std::string& id);
      static std::string class_ID() {return "DEM::ContactDetection_" + T::class_ID() + "_";}
 
    private:
      static std::map<std::string, ContactDetection *> UniqueIdMap_;
 
    protected:
      ContactDetection();
      virtual ~ContactDetection();
 
    public:
      virtual void parse_xml();
      virtual void init() {};
      void detect_contact(std::function<void(DEM::DiscreteElement&, T&)>&);
 
      ContactLaw<T>& get_ContactLaw();
      const ContactLaw<T>& get_ContactLaw() const;
      void set_ContactLaw(ContactLaw<T>& law);
      unsigned int get_Contactnumber() const;
 
      const std::vector<double>& get_InterpenetrationValues() const;
 
      void get_Contactinfo(unsigned int& number, double & ave, double & std, double & min, double & max) const;
 
      Core::SetOf<DiscreteElement >& get_RecordContactSet();
 
      double get_interactionCoeff() const;
      void   set_InteractionCoeff(double c) {interactionCoeff_ = c;};
 
      bool is_bonded(DiscreteElement& de1, T& de2);
      void RecordContact(DiscreteElement& de1, T& de2);
 
    protected:
      virtual void detect_contact() = 0;
 
      void Process(DiscreteElement& de1, T& de2, const Geom::Vector& normal, const double& penetration);
 
    private:
      void RegisterWithUniqueId(const std::string& id);
      ContactDetection(const ContactDetection&)            = delete;
      ContactDetection& operator=(const ContactDetection&) = delete;
 
    private:
      ContactLaw<T> *law_;
      unsigned int contactNumber_;
      std::vector<double> interpenetrationValues_;
      bool recordInterpenetrationValues_;
      bool excludedBondedDiscreteElement_;
      std::string recordContactIn_;
      double interactionCoeff_;
    };
 
 
    template<class T> std::map<std::string, ContactDetection<T> *>
    ContactDetection<T>::UniqueIdMap_ = std::map<std::string, ContactDetection *>();
 
    template<class T>
    ContactDetection<T>::ContactDetection()
      : Core::NeedSetOf< DiscreteElement>(false),
      law_(nullptr),
      contactNumber_(0),
      interpenetrationValues_(),
      recordInterpenetrationValues_(false),
      excludedBondedDiscreteElement_(false),
      recordContactIn_(""),
      interactionCoeff_(1.) {
    }
 
    template<class T>
    ContactDetection<T>::~ContactDetection() {
    }
 
    template<class T>  void
    ContactDetection<T>::parse_xml() {
      Core::NeedSetOf< DiscreteElement >::parse_xml();
 
      Core::XmlParser& parser = Core::XmlParser::get();
      parser.read_attribute(Attr::GRANOO_OPTIONAL, "RecordInterpenetrationValues",
                            recordInterpenetrationValues_);
      parser.read_attribute(Attr::GRANOO_OPTIONAL, "ExcludedBondedDiscreteElement",
                            excludedBondedDiscreteElement_);
 
      // Register it, if the user want
      std::string uniqueId = "";
      parser.read_attribute(Attr::GRANOO_OPTIONAL, "UniqueId", uniqueId);
      if (uniqueId != "")
        RegisterWithUniqueId(uniqueId);
 
      parser.read_attribute(Attr::GRANOO_OPTIONAL, "RecordContactIn", recordContactIn_);
      parser.read_attribute(Attr::GRANOO_OPTIONAL, "InteractionCoeff", interactionCoeff_);
      XmlAssert(interactionCoeff_ > 0., "The interaction coeff must be positive");
 
      // Affect law pointer (hack between 1.0 and 2.0 collision detection management)
      Collision::Manager<DEM::DiscreteElement, T>* manager =
        Collision::BroadPhase<DEM::DiscreteElement, T>::get_manager();
      Collision::CallBack<DEM::DiscreteElement, T>* callBack = manager->get_callback();
      law_ = dynamic_cast<ContactLaw<T> *>(callBack);
      AssertMsg(law_ != 0, "Problem while reading ContactDetection, the given CallBack can't be casted to a ContactLaw");
    }
 
    template<class T>  void
    ContactDetection<T>::detect_contact(std::function<void(DEM::DiscreteElement&, T&)>& f) {
      contactNumber_ = 0;
 
      if (recordInterpenetrationValues_)
        interpenetrationValues_.clear();
 
      if (recordContactIn_ != "")
        get_RecordContactSet().clear();
 
      get_ContactLaw().pre_contact_detection();
      detect_contact();
      get_ContactLaw().post_contact_detection();
    }
 
    template<> inline
    bool ContactDetection<DiscreteElement>::is_bonded(DiscreteElement& de1, DiscreteElement& de2) {
      return de1.is_bonded(de2);
    }
 
    template<class T>
    bool ContactDetection<T>::is_bonded(DiscreteElement& de1, T& de2) {
      return false;
    }
 
    template<> inline
    void ContactDetection<DiscreteElement>::RecordContact(DiscreteElement& de1, DiscreteElement& de2) {
      get_RecordContactSet().add_item(de1);
      get_RecordContactSet().add_item(de2);
    }
 
    template<class T>
    void ContactDetection<T>::RecordContact(DiscreteElement& de1, T& de2) {
      get_RecordContactSet().add_item(de1);
    }
 
    template<class T>
    void ContactDetection<T>::Process(DiscreteElement& de1, T& de2, const Geom::Vector& normal, const double& penetration) {
 
      if (excludedBondedDiscreteElement_)
        if (is_bonded(de1, de2))
          return;
 
      contactNumber_++;
      get_ContactLaw().compute_reaction(de1, de2, normal, penetration);
 
      if (recordInterpenetrationValues_)
        interpenetrationValues_.push_back(penetration);
 
      if (recordContactIn_ != "")
        RecordContact(de1, de2);
 
 
    }
 
    template<class T> unsigned int
    ContactDetection<T>::get_Contactnumber() const {
      return contactNumber_;
    }
 
    template<class T> const std::vector<double>&
    ContactDetection<T>::get_InterpenetrationValues() const {
      return interpenetrationValues_;
    }
 
    template<class T> void
    ContactDetection<T>::get_Contactinfo(unsigned int& number, double & ave, double & std, double & min, double & max) const {
      InternAssert(recordInterpenetrationValues_ == true);
      number = contactNumber_;
      Math::Stat::All(interpenetrationValues_, ave, std, min, max);
    }
 
    template<class T> void
    ContactDetection<T>::RegisterWithUniqueId(const std::string& id) {
      InternAssert(UniqueIdMap_.count(id) == 0);
      UniqueIdMap_[id] = this;
    }
 
    template<class T> ContactDetection<T>&
    ContactDetection<T>::get_ByUniqueId(const std::string& id) {
      InternAssert(UniqueIdMap_.count(id) == 1);
      return *UniqueIdMap_[id];
    }
 
    template<class T> Core::SetOf<DiscreteElement >&
    ContactDetection<T>::get_RecordContactSet() {
      InternAssert(recordContactIn_ != "");
      if (!Core::SetOf<DiscreteElement >::exist(recordContactIn_))
        new Core::SetOf<DiscreteElement >(recordContactIn_);
      return Core::SetOf<DiscreteElement >::get(recordContactIn_);
    }
 
    template<class T> double
    ContactDetection<T>::get_interactionCoeff() const {
      return interactionCoeff_;
    }
 
    template<class T> ContactLaw<T>&
    ContactDetection<T>::get_ContactLaw() {
      return *law_;
    }
 
    template<class T> const ContactLaw<T>&
    ContactDetection<T>::get_ContactLaw() const {
      return *law_;
    }
 
    template<class T> void
    ContactDetection<T>::set_ContactLaw(ContactLaw<T>& law) {
      law_ = &law;
    }
 
  }
}
 
 
#endif