FlatBond_Ortho.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>
//                - Harikeshava RANGANATHAN     IRCER, Limoges France/IMERYS, Lyon France
//                  <harikeshava.ranganathan@unilim.fr>
//
// Copyright (C) 2008-2016 JL. CHARLES, D. ANDRE, I. IORDANOFF, J. GIRARDOT
// Copyright (C) 2023 H. RANGANATHAN
//
//
//
//
// 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_FlatBond_Ortho_hpp_
#define _libDEM_FlatBond_Ortho_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/SymTensor.hpp"
#include "GranOO3/Geom/Point.hpp" 
 
namespace GranOO3
{
  namespace DEM
  {
 
    
    class FlatBond_Ortho : public Bond,
               public Core::Register<FlatBond_Ortho >,
               public Physic::CriticalTimeStep
    {
 
      GRANOO_CLASS(DEM::FlatBond_Ortho, Bond);
 
    public:
      //CONSTRUCTORS & DESTRUCTORS
      FlatBond_Ortho(Element& el1, Element& el2, bool build_voronoi_bond = true);
      FlatBond_Ortho(Element& el1, Element& el2, double Ex, double Ey, double Ez, double C11, double C12, double C13, double C21, double C22, double C23, double C31, double C32, double C33, double C44, double C55, double C66, bool build_voronoi_bond = true);
      virtual ~FlatBond_Ortho();
 
      //USEFULL
      void update_strain_tensor_and_compute_reaction_force_and_torque();
      virtual void compute_load();
      double get_linear_stiffness() const;
      double get_angular_stiffness() const;
      virtual double compute_critical_time_step() const;
      virtual std::string info() const;
 
      //ACCESSORS
      GRANOO_ACCESS(Ex                        , double         , _Ex                         );
      GRANOO_ACCESS(Ey                        , double         , _Ey                         );
      GRANOO_ACCESS(Ez                        , double         , _Ez                         );
      GRANOO_ACCESS(C11                       , double         , _C11                        );
      GRANOO_ACCESS(C12                       , double         , _C12                        );
      GRANOO_ACCESS(C13                       , double         , _C13                        );
      GRANOO_ACCESS(C21                       , double         , _C21                        );
      GRANOO_ACCESS(C22                       , double         , _C22                        );
      GRANOO_ACCESS(C23                       , double         , _C23                        );
      GRANOO_ACCESS(C31                       , double         , _C31                        );
      GRANOO_ACCESS(C32                       , double         , _C32                        );
      GRANOO_ACCESS(C33                       , double         , _C33                        );
      GRANOO_ACCESS(C44                       , double         , _C44                        );
      GRANOO_ACCESS(C55                       , double         , _C55                        );
      GRANOO_ACCESS(C66                       , double         , _C66                        );
      GRANOO_ACCESS(current_stress_vector     , Geom::Vector   , _current_stress_vector      );
      GRANOO_ACCESS(current_normal_stress     , double         , _current_normal_stress      );
    
      
    private:
      FlatBond_Ortho() = delete;      
      FlatBond_Ortho(const FlatBond_Ortho&) = delete;
      FlatBond_Ortho & operator=(const FlatBond_Ortho &) = delete;
 
    private:
      //BOOST SERIALIZATION
      friend class boost::serialization::access;
      template<class Archive> void serialize(Archive&, const unsigned int);
      
    private:
      VoronoiBond*    _voronoi_bond;
      double          _Ex;
      double          _Ey;
      double          _Ez;
      double          _C11;
      double          _C12;
      double          _C13;
      double          _C21;
      double          _C22;
      double          _C23;
      double          _C31;
      double          _C32;
      double          _C33;
      double          _C44;
      double          _C55;
      double          _C66;
      // keep it
      Geom::Point     _FC1;
      Geom::Point     _FC2;
      Geom::Vector    _current_stress_vector;
      double          _current_normal_stress;
    };    
 
    //BOOST SERIALIZATION 
    template<class Archive> void 
    FlatBond_Ortho::serialize(Archive & ar, const unsigned int version) {
      ar & boost::serialization::base_object<Bond>(*this);
      ar & _Ex;
      ar & _Ey;
      ar & _Ez;
      ar & _C11;
      ar & _C12;
      ar & _C13;
      ar & _C21;
      ar & _C22;
      ar & _C23;
      ar & _C31;
      ar & _C32;
      ar & _C33;
      ar & _C44;
      ar & _C55;
      ar & _C66;
      ar & _current_stress_vector;
      ar & _current_normal_stress;
      ar & _FC1;
      ar & _FC2;
    }
    
  } 
}
 
 
#include <boost/serialization/version.hpp>
BOOST_CLASS_VERSION(GranOO3::DEM::FlatBond_Ortho, 1)
 
 
// need placement new snippet because no default constructor exist
namespace boost 
{ 
  namespace serialization 
  {
    
    template<class Archive>
    inline void save_construct_data(Archive & ar, 
                    const GranOO3::DEM::FlatBond_Ortho * 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>
    inline void load_construct_data(Archive & ar, 
                    GranOO3::DEM::FlatBond_Ortho * t, 
                    const unsigned int) {
      GranOO3::DEM::Element* de1 = nullptr;
      GranOO3::DEM::Element* de2 = nullptr;
      ar >> de1;
      ar >> de2;
      ::new(t)GranOO3::DEM::FlatBond_Ortho(*de1, *de2, false);
    }
  }
} 
 
 
namespace GranOO3{
  GRANOO_CLASS_DECLARE_TPL(DEM::FlatBond_Ortho);
}
 
 
#endif