fluide.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 <cstdlib>
#include <iostream>
#include <vector>
#include <fstream>
#include <stdio.h>
#include <sstream>
#include <cassert>
#include "parametres.hpp"
#include "solide.hpp"


#ifndef FLUIDE_HPP
#define FLUIDE_HPP

using namespace std;


class Cellule {

public :

 // Constructeur 
  Cellule();
  Cellule(double x, double y, double z);
  Cellule(double x, double y, double z, double dx, double dy, double dz);
  
  Cellule & operator=(const Cellule &cell);

  // Destructor
  ~Cellule();

  bool is_in_cell(double x,double y, double z);

  void Affiche ();  
    
  double x;       
  double y;
  double z; 

  int i;
  int j;
  int k;

  double dx;       
  double dy;
  double dz;

  double rho;       
  double rho1;      

  double u;        
  double v;        
  double w;        

  double p;         
  double p1;        
    

  double impx;      
  double impy;      
  double impz;      

  double impx0;      
  double impy0;      
  double impz0;      

  double rhoE;      
  double rhoE0;     
  double rho0;      



  double lambda[5];     
  double rp[5];         
  double rm[5];        
   
    double pdtx;     

    double pdty;     

    double pdtz;     
    
  double Mrho;      

  double Mimpx;     

  double Mimpy;     

  double Mimpz;     

  double MrhoE;     

  double cells;      

  double alpha;      

  double alpha0;    

  double kappai;    

  double kappaj; 

  double kappak; 

  double kappai0;    

  double kappaj0; 

  double kappak0; 

  int proche;         

  int proche1;       
  
  bool vide; 
  
  double flux_modif[5]; 

  double delta_w[5];    

  double phi_x;        

  double phi_y; 

  double phi_z; 

  double phi_v;  

  double cible_alpha;      

  double cible_rho;      

  double cible_impx;     

  double cible_impy;     

  double cible_impz;     

  double cible_rhoE;     
  
  double cible_i;      
  double cible_j;
  double cible_k;
  
  double xi;      
  double yj;
  double zk;
  
  double fluxi[5];     
  double fluxj[5];     
  double fluxk[5];     
  
  double S;                  
  double ve[5];             

  double fex;               
  double fey;               
  double fez;               
  
  
  double Qci[5];            
  double Qcj[5];            
  double Qck[5];            
  
  double dtfxi[5];          
  double dtfyj[5];          
  double dtfzk[5];          
  
  double delw[5];           
  double delwnu[5];         
  
  double cf2[5];            
  double cf3[5]; 
  double cf4[5]; 
  double cf5[5]; 
  double cf6[5]; 
  double cf7[5]; 
  double cf8[5]; 
  double cf9[5]; 
  double cf10[5]; 
  double cf11[5]; 


  double psic0[5];           
  double psic1[5]; 
  double psic2[5]; 
  double psic3[5]; 
  double psic4[5]; 

  double psid0[5];            
  double psid1[5]; 
  double psid2[5]; 
  double psid3[5]; 
  double psid4[5]; 

  double vpr[5][5];            


  double psic0r[5];           
  double psic1r[5]; 
  double psic2r[5]; 
  double psic3r[5]; 
  double psic4r[5]; 

  double psid0r[5];            
  double psid1r[5]; 
  double psid2r[5]; 
  double psid3r[5]; 
  double psid4r[5]; 

  double psid[5]; 
  double am[5];                 
  double am1[5];  
  
  int ordre;                    
  double co[11];               
  
  friend class Grille;         
  
};

class Grille
{

 public:

  Grille();
 Grille(int Nx0,int Ny0, int Nz0, double dx0, double x0, double dy0, double y0, double dz0, double z0);

  ~Grille();

  void affiche();  

  void affiche(string r);
  
  Cellule cellule(int i, int j, int k);
  Cellule in_cell(const Point_3& p);
  void in_cell(const Point_3& p, int &i, int& j, int& k, bool& interieur);
  void Init();

  double pas_temps(double t, double T);
  
  void BC();

  double Masse();
  double Impulsionx();
  double Impulsiony();
  double Impulsionz();
  double Energie();
 
  void Impression(int n);
  
  void solve_fluidx(const double dt);
  void solve_fluidy(const double dt);
  void solve_fluidz(const double dt);
  void melange(const double dt);
  void fnumx( const double sigma, double t);
  void fnumy(const double sigma, double t);
  void fnumz( const double sigma, double t);


  void corentx(double sigma);
  void corenty(double sigma);
  void corentz(double sigma);
  void Solve(const double dt, double t, int n, Solide& S); 

  void Forces_fluide(Solide& S, const double dt);
  void Modif_fnum(const double dt);  
  void Mixage(); 
  void Fill_cel(Solide& S);
  void swap_face(const Triangles& T3d_prev, const Triangles& T3d_n, const double dt,  Particule & P, double & volume_test);
  void swap_face_inexact(const Triangle_3& Tr_prev, const Triangle_3& Tr, const Triangles& T3d_prev, const Triangles& T3d_n, const double dt,  Particule & P, double & volume_test);
  void cells_intersection_face(int& in,int& jn,int& kn,int& in1,int& jn1,int& kn1, std::vector<Bbox>& box_cells, std::vector<Cellule>& Cells);
  void Swap_2d(const double dt, Solide& S);
  void Swap_3d(const double dt, Solide& S); 
  Cellule voisin_fluide(const Cellule &c,  bool &target); 
  Cellule voisin_mixt(const Cellule &c,  bool &target); 
  Cellule voisin(const Cellule &c); 
  Cellule cible(const Cellule &c, std::vector< std::vector<int> > & tab_cible );
  void Mixage_cible();
  bool Mixage_cible2(); 
  void Parois_particles(Solide& S,double dt);
  std::vector<Point_3> intersection(Triangle_3 t1, Triangle_3 t2);
//private :

  double x;          
  double y;
  double z;
  double dx;          
  double dy;
  double dz;
  vector< vector< vector<Cellule > > > grille; 
 

};

#endif