grid3D.h

Go to the documentation of this file.

#ifndef GRID3D_H
#define GRID3D_H

#ifdef   MPI_CHOLLA
#include"mpi_routines.h"
#endif /*MPI_CHOLLA*/

#include<stdio.h>
#include"global.h"

#ifdef HDF5
#include<hdf5.h>
#endif

#ifdef GRAVITY
#include"gravity/grav3D.h"
#endif

#ifdef PARTICLES
#include "particles/particles_3D.h"
#endif

#ifdef COSMOLOGY
#include"cosmology/cosmology.h"
#endif

#ifdef COOLING_GRACKLE
#include "cooling/cool_grackle.h"
#endif

#ifdef CPU_TIME
#include "timing_functions.h"
#endif

struct Rotation
{
  int nx;

  int nz;

  int nx_min;

  int nx_max;

  int nz_min;

  int nz_max;

  Real delta;

  Real theta;

  Real phi;

  Real Lx;

  Real Lz;

  int i_delta;

  Real n_delta;

  Real ddelta_dt;

  int flag_delta;
};

struct Header
{
  int n_cells;

  int n_ghost;

  int nx;

  int ny;

  int nz;

  int nx_real;

  int ny_real;

  int nz_real;

  /*  \brief Global domain x-direction minimum */
  Real xbound;

  /*  \brief Global domain y-direction minimum */
  Real ybound;

  /*  \brief Global domain z-direction minimum */
  Real zbound;

  /*  \brief Local domain length in x-direction */
  Real domlen_x;

  /*  \brief Local domain length in y-direction */
  Real domlen_y;
   
  /*  \brief Local domain length in z-direction */
  Real domlen_z;

  /*  \brief Local domain x-direction minimum */
  Real xblocal;

  /*  \brief Local domain y-direction minimum */
  Real yblocal;

  /*  \brief Local domain z-direction minimum */
  Real zblocal;

  /*  \brief Global domain length in x-direction */
  Real xdglobal;

  /*  \brief Global domain length in y-direction */
  Real ydglobal;

  /*  \brief Global domain length in z-direction */
  Real zdglobal;

  Real dx;

  Real dy;

  Real dz;
      
  Real t;

  Real dt;
  
  #ifdef AVERAGE_SLOW_CELLS
  Real min_dt_slow;
  #endif 

  Real t_wall;

  int n_step;

  int n_fields;
  
  // Values for lower limit for density and temperature
  Real density_floor;
  Real temperature_floor;
  
  Real Ekin_avrg;
  
  //Flag to indicate when to transfer the Conserved boundaries
  bool TRANSFER_HYDRO_BOUNDARIES;
  
  #ifdef GRAVITY

  int n_ghost_potential_offset;
  #endif
  
  #ifdef COSMOLOGY
  bool OUTPUT_SCALE_FACOR;
  #endif
  
  bool Output_Now;
  bool Output_Initial;
  
  bool Output_Complete_Data;
  

};

class Grid3D
{
  public:

    int flag_init;

    int gflag;

    struct Header H;

    struct Rotation R;

    Real *buffer0;

    Real *buffer1;
    
    #ifdef GRAVITY
    // Object that contains data for gravity
    Grav3D Grav;
    #endif
    
    #ifdef PARTICLES
    // Object that contains data for particles
    Particles_3D Particles;
    #endif
    
    #ifdef COSMOLOGY
    // Object that contains data for cosmology
    Cosmology Cosmo;
    #endif
    
    #ifdef COOLING_GRACKLE
    // Object that contains data for Grackle cooling
    Cool_GK Cool;
    #endif
    
    #ifdef CPU_TIME
    Time Timer;
    #endif

    struct Conserved
    {
      Real *density;

      Real *momentum_x;

      Real *momentum_y;

      Real *momentum_z;         

      Real *Energy;
      
      #ifdef DE

      Real *GasEnergy;
      #endif

      #ifdef SCALAR

      Real *scalar;
      #endif
      
      Real *Grav_potential;

      
    } C;


    Grid3D(void);

    void Initialize(struct parameters *P);
 
    void AllocateMemory(void);

    void Set_Initial_Conditions(parameters P);

    void Get_Position(long i, long j, long k, Real *xpos, Real *ypos, Real *zpos);

    void Set_Domain_Properties(struct parameters P);

    void set_dt(Real dti);
    
    #ifdef GRAVITY

    void set_dt_Gravity();
    #endif
    
    Real calc_dti_CPU_1D();
    
    Real calc_dti_CPU_2D();

    Real calc_dti_CPU_3D_function( int g_start, int g_end );
        
    Real calc_dti_CPU_3D();

    Real calc_dti_CPU();

    Real Update_Grid(void);
    
    Real Update_Hydro_Grid(void);
    
    void Update_Time();
    
    void Write_Header_Binary(FILE *fp);

    void Write_Grid_Binary(FILE *fp);

#ifdef HDF5

    void Write_Header_HDF5(hid_t file_id);

    void Write_Grid_HDF5(hid_t file_id);

    void Write_Projection_HDF5(hid_t file_id);    

    void Write_Header_Rotated_HDF5(hid_t file_id);

    void Write_Rotated_Projection_HDF5(hid_t file_id);   

    void Write_Slices_HDF5(hid_t file_id);    

#endif

    void Read_Grid(struct parameters P);

    void Read_Grid_Binary(FILE *fp);
    
#ifdef HDF5

    void Read_Grid_HDF5(hid_t file_id, struct parameters P);
#endif

    void Reset(void);

    void FreeMemory(void);

    void Constant(Real rho, Real vx, Real vy, Real vz, Real P);

    void Sound_Wave(Real rho, Real vx, Real vy, Real vz, Real P, Real A);

    void Square_Wave(Real rho, Real vx, Real vy, Real vz, Real P, Real A);

    void Riemann(Real rho_l, Real v_l, Real P_l, Real rho_r, Real v_r, Real P_r, Real diaph);

    void Shu_Osher();

    void Blast_1D();

    void KH();

    void KH_res_ind();

    void Rayleigh_Taylor();

    void Gresho();    

    void Implosion_2D();

    void Explosion_2D();

    void Noh_2D();

    void Noh_3D();

    void Disk_2D();    

    void Disk_3D(parameters P);    

    void Set_Boundary_Conditions(parameters P);
    
    void Set_Boundary_Conditions_Grid( parameters P);

    int Check_Custom_Boundary(int *flags, struct parameters P);

    void Set_Boundaries(int dir, int flags[]);

    void Set_Boundary_Extents(int dir, int *imin, int *imax);

    int  Set_Boundary_Mapping(int ig, int jg, int kg, int flags[], Real *a);

    int  Find_Index(int ig, int nx, int flag, int face, Real *a);

    void Custom_Boundary(char bcnd[MAXLEN]);

    void Noh_Boundary();
    
    void Spherical_Overpressure_3D();
    
    void Spherical_Overdensity_3D();
    
    void Uniform_Grid();
    
    void Zeldovich_Pancake( struct parameters P );


#ifdef   MPI_CHOLLA
    void Set_Boundaries_MPI(struct parameters P);
    void Set_Boundaries_MPI_SLAB(int *flags, struct parameters P);
    void Set_Boundaries_MPI_BLOCK(int *flags, struct parameters P);
    void Set_Edge_Boundaries(int dir, int *flags);
    void Set_Edge_Boundary_Extents(int dir, int edge, int *imin, int *imax);
    void Load_and_Send_MPI_Comm_Buffers(int dir, int *flags);
    void Load_and_Send_MPI_Comm_Buffers_SLAB(int *flags);
    void Load_and_Send_MPI_Comm_Buffers_BLOCK(int dir, int *flags);
    void Wait_and_Unload_MPI_Comm_Buffers_SLAB(int *flags);
    void Wait_and_Unload_MPI_Comm_Buffers_BLOCK(int dir, int *flags);
    void Unload_MPI_Comm_Buffers(int index);
    void Unload_MPI_Comm_Buffers_SLAB(int index);
    void Unload_MPI_Comm_Buffers_BLOCK(int index);
    int Load_Hydro_Buffer_X0();
    int Load_Hydro_Buffer_X1();
    int Load_Hydro_Buffer_Y0();
    int Load_Hydro_Buffer_Y1();
    int Load_Hydro_Buffer_Z0();
    int Load_Hydro_Buffer_Z1();
#endif /*MPI_CHOLLA*/

  #ifdef GRAVITY
  void Initialize_Gravity( struct parameters *P );
  void Compute_Gravitational_Potential( struct parameters *P );
  void Copy_Hydro_Density_to_Gravity_Function( int g_start, int g_end);
  void Copy_Hydro_Density_to_Gravity();
  void Extrapolate_Grav_Potential_Function( int g_start, int g_end );
  void Extrapolate_Grav_Potential();
  void Copy_Potential_Boundaries( int direction, int side );
  int Load_Gravity_Potential_To_Buffer( int direction, int side, Real *buffer, int buffer_start  );
  void Unload_Gravity_Potential_from_Buffer( int direction, int side, Real *buffer, int buffer_start  );
  #endif//GRAVITY 
  
  #ifdef PARTICLES
  void Initialize_Particles( struct parameters *P );
  void Initialize_Uniform_Particles();
  void Copy_Particles_Density_function( int g_start, int g_end );
  void Copy_Particles_Density();
  void Copy_Particles_Density_to_Gravity(struct parameters P);
  void Copy_Particles_Density_Boundaries( int direction, int side );
  void Transfer_Particles_Boundaries( struct parameters P );
  Real Update_Grid_and_Particles_KDK( struct parameters P );
  void Set_Particles_Boundary( int dir, int side);
  #ifdef MPI_CHOLLA
  int Load_Particles_Density_Boundary_to_Buffer( int direction, int side, Real *buffer );
  void Unload_Particles_Density_Boundary_From_Buffer( int direction, int side, Real *buffer );
  void Load_and_Send_Particles_X0( int ireq_n_particles, int ireq_particles_transfer );
  void Load_and_Send_Particles_X1( int ireq_n_particles, int ireq_particles_transfer );
  void Load_and_Send_Particles_Y0( int ireq_n_particles, int ireq_particles_transfer );
  void Load_and_Send_Particles_Y1( int ireq_n_particles, int ireq_particles_transfer );
  void Load_and_Send_Particles_Z0( int ireq_n_particles, int ireq_particles_transfer );
  void Load_and_Send_Particles_Z1( int ireq_n_particles, int ireq_particles_transfer );
  void Unload_Particles_from_Buffer_X0( int *flags );
  void Unload_Particles_from_Buffer_X1( int *flags );
  void Unload_Particles_from_Buffer_Y0( int *flags );
  void Unload_Particles_from_Buffer_Y1( int *flags );
  void Unload_Particles_from_Buffer_Z0( int *flags );
  void Unload_Particles_from_Buffer_Z1( int *flags );
  void Wait_NTransfer_and_Request_Recv_Particles_Transfer_BLOCK(int dir, int *flags);
  void Load_NTtransfer_and_Request_Receive_Particles_Transfer(int index, int *ireq_particles_transfer);
  void Wait_and_Unload_MPI_Comm_Particles_Buffers_BLOCK(int dir, int *flags);
  void Unload_Particles_From_Buffers_BLOCK(int index, int *flags );
  void Finish_Particles_Transfer();
  #endif//MPI_CHOLLA
  void Transfer_Particles_Density_Boundaries( struct parameters P );
  // void Transfer_Particles_Boundaries( struct parameters P );
  void WriteData_Particles(  struct parameters P, int nfile);
  void OutputData_Particles(  struct parameters P, int nfile);
  void Load_Particles_Data(  struct parameters P);
  #ifdef HDF5
  void Write_Particles_Header_HDF5( hid_t file_id);
  void Write_Particles_Data_HDF5( hid_t file_id);
  void Load_Particles_Data_HDF5(hid_t file_id, int nfile);
  #endif//HDF5
  void Get_Gravity_Field_Particles_function( int g_start, int g_end );
  void Get_Gravity_Field_Particles();
  void Get_Gravity_CIC_function( part_int_t p_start, part_int_t p_end );
  void Get_Gravity_CIC();
  void Advance_Particles_KDK_Step1( );
  void Advance_Particles_KDK_Step2( );
  void Advance_Particles_KDK_Step1_function( part_int_t p_start, part_int_t p_end );
  void Advance_Particles_KDK_Step2_function( part_int_t p_start, part_int_t p_end );
  void Get_Particles_Acceleration();
  void Advance_Particles( int N_KDK_step );
  Real Calc_Particles_dt_function( part_int_t p_start, part_int_t p_end );
  Real Calc_Particles_dt();
  #ifdef PARTICLES_GPU
  Real Calc_Particles_dt_GPU();
  void Advance_Particles_KDK_Step1_GPU();
  void Advance_Particles_KDK_Step2_GPU();
  void Set_Particles_Boundary_GPU( int dir, int side);  
  #endif//PARTICLES_GPU
  #endif//PARTICLES
  
  #ifdef COSMOLOGY
  void Initialize_Cosmology( struct parameters *P );
  void Change_DM_Frame_System( bool forward );
  void Change_GAS_Frame_System( bool forward );
  void Change_Cosmological_Frame_Sytem( bool forward );
  void Advance_Particles_KDK_Cosmo_Step1_function( part_int_t p_start, part_int_t p_end );
  void Advance_Particles_KDK_Cosmo_Step2_function( part_int_t p_start, part_int_t p_end );
  Real Calc_Particles_dt_Cosmo_function( part_int_t p_start, part_int_t p_end );
  Real Calc_Particles_dt_Cosmo();
  #ifdef PARTICLES_GPU
  void Advance_Particles_KDK_Cosmo_Step1_GPU();
  void Advance_Particles_KDK_Cosmo_Step2_GPU();
  #endif//PARTICLES_GPU
  #endif//COSMOLOGY
  
  #ifdef COOLING_GRACKLE
  void Initialize_Grackle( struct parameters *P );
  void Allocate_Memory_Grackle();
  void Initialize_Fields_Grackle();
  void Copy_Fields_To_Grackle_function( int g_start, int g_end );
  void Copy_Fields_To_Grackle();
  void Update_Internal_Energy_function( int g_start, int g_end );
  void Update_Internal_Energy();
  void Do_Cooling_Step_Grackle();
  #endif
  

};



#endif //GRID3D_H