solide.hpp

Go to the documentation of this file.

//Copyright 2017 Laurent Monasse

/*
  This file is part of CELIA3D.
  
  CELIA3D 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.
  
  CELIA3D 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 CELIA3D.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "intersections.hpp"
#ifndef SOLIDE_HPP
#define SOLIDE_HPP

class Vertex 
{
public:
  Vertex();
  Vertex(const Point_3 p, std::vector<int> & parts);
  Vertex & operator=(const  Vertex &V);
  Point_3 pos; 
  int num;
  
  int size(){
    return particules.size();
  }
  std::vector<int> particules; 
};

class Face
{
public:
  Face();
  Face(std::vector<Vertex> & v, int part);
  Face(std::vector<Vertex> & v, int part, double dist);
  Face & operator=(const  Face &F); 
  int size(){
    return vertex.size();
  }
  void compFaceIntegrals(double &Fa, double &Fb, double &Fc, double &Faa, double &Fbb, double &Fcc, double &Faaa, double &Fbbb, double &Fccc, double &Faab, double &Fbbc, double &Fcca, double na,double nb, double nc, int a, int b, int c);
  void compProjectionIntegrals(double &P1, double &Pa, double &Pb, double &Paa, double &Pab, double &Pbb, double &Paaa, double &Paab, double &Pabb, double &Pbbb, int a, int b, int c);
  void Inertie();
  Point_3 centre; 
  Vector_3 normale; 
  double S; //Face area
  double Is; 
  double It; 
  Vector_3 s; 
  Vector_3 t; 
  std::vector<Vertex> vertex; 
  int voisin; 
  double D0; 
};

  
class Particule
{

public:
   
  Particule();
  
  Particule(const double x_min, const double y_min, const double z_min, 
        const double x_max, const double y_max,const double z_max);
  
  Particule(Point_3 c, const double x_min, const double y_min, const double z_min, 
        const double x_max, const double y_max,const double z_max, 
        std::vector<Face> & F);
  ~Particule();
  Particule & operator=(const Particule &P); 
  void Affiche();  
  double volume(); 
  void CompVolumeIntegrals(double &T1, double &Tx, double &Ty, double &Tz, double &Txx, double &Tyy, double &Tzz, double &Txy, double &Tyz, double &Tzx);
  void Inertie();
  void Volume_libre();
  void solve_position(double dt);
  void solve_vitesse(double dt);
  Vector_3 vitesse_parois(const Point_3& X_f);  
  Vector_3 vitesse_parois_prev(const Point_3& X_f);
  bool cube; 
  Bbox bbox; 
  
  std::vector<Face> faces; 

  std::vector<Point_3> vertices;
  
  Triangles triangles; 
    
  Triangles triangles_prev; 
    
  std::vector<Vector_3> normales; 
    
  std::vector<Vector_3> normales_prev; 
    
  std::vector<bool> vide; 

  std::vector<bool> fluide; 
    
  std::vector<bool> fluide_prev; 

  std::vector< std::vector<Point_3> > Points_interface; 
    
  std::vector< std::vector<Point_3> > Points_interface_prev; 

  std::vector< std::vector<Triangle_3> > Triangles_interface; 
    
  std::vector< std::vector< std::vector<int> > > Position_Triangles_interface; 
    
  std::vector< std::vector<Triangle_3> > Triangles_interface_prev; 
    
  std::vector< std::vector<std::vector<int> > > Position_Triangles_interface_prev; 

  int fixe; 
  double m; 
  double V; 
  double Vl; 
  double epsilon; 
  double I[3]; 
  double rotref[3][3]; 
  Point_3 x0; 
  Vector_3 Dx; 
  Vector_3 Dxprev; 
  Vector_3 Fi; 

  Vector_3 Ff; 

  Vector_3 Ffprev; 
  Vector_3 Mi; 

  Vector_3 Mf; 

  Vector_3 Mfprev; 
  Vector_3 u; 
  Vector_3 u_half; 
  Vector_3 omega; 
  Vector_3 omega_half;
  Vector_3 e; 
  Vector_3 eprev; 
  Aff_transformation_3 mvt_t; 
  Aff_transformation_3 mvt_tprev; 
}; 

class Solide
{
    
public:
  
  Solide();
  Solide(std::vector<Particule> & Part);
  ~Solide();
  Solide & operator=(const Solide &S); 
  void Affiche();  
  int size(){
    return solide.size();
  }
  void Impression(int n);
  void Init(const char* s);
  void Solve_position(double dt);
  void Solve_vitesse(double dt);
  void Forces_internes();
  void update_triangles();
  void breaking_criterion();
  double Energie();
  double Energie_potentielle();
  double Energie_cinetique();
  double pas_temps(double t, double T);
  // private :
  std::vector<Particule> solide; 
};

bool inside_box(const Bbox& cell, const Point_3& P);
bool box_inside_convex_polygon(const Particule& S, const Bbox& cell);  
bool inside_convex_polygon(const Particule& S, const Point_3& P);  
double Error(Solide& S1, Solide& S2);
void Copy_f_m(Solide& S1, Solide& S2);
bool box_inside_tetra(const Tetrahedron &tetra, const Bbox& cell);
bool inside_tetra(const Tetrahedron &tetra, const Point_3& P);
#endif