solide.hpp

Go to the documentation of this file.

//Copyright 2017 Laurent Monasse

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

#ifndef SOLIDE_HPP
#define SOLIDE_HPP

#include "geometry.hpp"



class Vertex 
{
public:
  Vertex();
  Vertex(const Point_3 &p, const std::vector<int> & parts);
  Vertex & operator=(const  Vertex &V); // op&eacute;rateur = surcharge pour l'affectation
  Point_3 pos; 
  int num;
  
  int size(){
    return particules.size();
  }
  std::vector<int> particules; 
};

class Face
{
public:
  Face();//:vertex(std::vector<Vertex>(1)){}
  Face(const std::vector<Vertex> & v, const int &part);
  Face(const std::vector<Vertex> & v, const int &part, const double &dist);
  Face & operator=(const  Face &F); // op&eacute;rateur = surcharge pour l'affectation
  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, const double& na, const double& nb, const double& nc, const int& a, const int& b, const int& c);
  void compProjectionIntegrals(double &P1, double &Pa, double &Pb, double &Paa, double &Pab, double &Pbb, double &Paaa, double &Paab, double &Pabb, double &Pbbb, const int &a, const int &b, const int &c);
  void Inertie();
  Point_3 centre; 
  Vector_3 normale; 
  double S; //Surface de la face
  double Is; 
  double It; 
  Vector_3 s; 
  Vector_3 t; 
  std::vector<Vertex> vertex; 
  int voisin; 
  double D0; 
};

  
class Particule
{

 public:
   
  Particule();//:faces(std::vector<Face>(1)){}
  
  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(const 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, 
            const std::vector<Face> & F);
  ~Particule();
    Particule & operator=(const Particule &P); // opérateur = surcharge pour l'affectation
    void Affiche();  //fonction auxilaire utile pour les tests
  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(const double &rho);
  void Volume_libre();
void solve_position(const double &dt, const bool &flag_2d);
void solve_vitesse(const double &dt, const bool &flag_2d);
  Vector_3 vitesse_parois(const Point_3& X_f);  
  Vector_3 vitesse_parois_prev(const Point_3& X_f);  
  //double min_x; //!< la plus petite coordonn&eacute;e  de la particule selon x
  //double min_y; //!< la plus petite coordonn&eacute;e  de la particule selon y
  //double min_z; //!< la plus petite coordonn&eacute;e  de la particule selon z
  //double max_x; //!< la plus grande coordonn&eacute;e  de la particule selon x
  //double max_y; //!< la plus petite coordonn&eacute;e  de la particule selon y
  //double max_z; //!< la plus petite coordonn&eacute;e  de la particule selon z
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 eref;
  Vector_3 eprev; 
  Aff_transformation_3 mvt_t; 
  Aff_transformation_3 mvt_tprev; 
}; 

class Solide
{
    
public:
  
  Solide();//:solide(std::vector<Particule>(1)){}
  Solide(const std::vector<Particule> & Part);
  ~Solide();
    Solide & operator=(const Solide &S); // opérateur = surcharge pour l'affectation
    void Affiche();  //fonction auxilaire utile pour les test
  int size(){
    return solide.size();
  }
  void Impression(const int &n, const bool &reconstruction);
  void Init(const char* s, const bool &rep, const int &numrep, const double &rho);
  void Solve_position(const double &dt, const bool &flag_2d);
  void Solve_vitesse(const double &dt, const bool &flag_2d);
  void Forces(const int &N_dim, const double &nu, const double &E);
  void Forces_internes(const int &N_dim, const double &nu, const double &E);
  void update_triangles();
  //void breaking_criterion();
  double Energie(const int &N_dim, const double &nu, const double &E);
  double Energie_potentielle(const int &N_dim, const double &nu, const double &E);
  double Energie_cinetique();
  double pas_temps(const double &t, const double &T, const double &cfls, const double &E, const double &nu, const double &rhos);
  // private :
  std::vector<Particule> solide; 
};


#endif