hlld_cuda.h

 
#pragma once
 
// External Includes
 
// Local Includes
#include "../global/global.h"
#include "../reconstruction/reconstruction.h"
#include "../utils/hydro_utilities.h"
 
#ifdef MHD
namespace mhd
{
template <int reconstruction, uint direction>
__global__ void Calculate_HLLD_Fluxes_CUDA(Real const *dev_conserved, Real const *dev_bounds_L,
                                           Real const *dev_bounds_R, Real const *dev_magnetic_face, Real *dev_flux,
                                           int const nx, int const ny, int const nz, int const n_cells,
                                           Real const gamma, int const n_fields);
 
namespace internal
{
Real static const _hlldSmallNumber = 1.0e-8;
 
struct StarState {
  // velocityStarX = Speeds.M
  // Total pressure is computed on its own since it's shared
  Real density, velocityY, velocityZ, energy, magneticY, magneticZ;
};
 
struct DoubleStarState {
  // velocityDoubleStarX = Speeds.M
  // densityDoubleStar = densityStar
  // pressureDoubleStar = pressureStar
  // Shared values
  Real velocityY, velocityZ, magneticY, magneticZ;
  // Different values. Initializing these since one or the other can be uninitializing leading to bad tests
  Real energyL = 0.0, energyR = 0.0;
};
 
struct Flux {
  Real density, momentumX, momentumY, momentumZ, energy, magneticY, magneticZ;
};
 
struct Speeds {
  Real L, LStar, M, RStar, R;
};
 
__device__ __host__ reconstruction::InterfaceState loadState(Real const *interfaceArr, Real const &magneticX,
                                                             Real const &gamma, int const &threadId, int const &n_cells,
                                                             int const &o1, int const &o2, int const &o3);
 
__device__ __host__ mhd::internal::Speeds approximateLRWaveSpeeds(reconstruction::InterfaceState const &stateL,
                                                                  reconstruction::InterfaceState const &stateR,
                                                                  Real const &magneticX, Real const &gamma);
 
__device__ __host__ Real approximateMiddleWaveSpeed(reconstruction::InterfaceState const &stateL,
                                                    reconstruction::InterfaceState const &stateR,
                                                    mhd::internal::Speeds const &speed);
 
__device__ __host__ Real approximateStarWaveSpeed(mhd::internal::StarState const &starState,
                                                  mhd::internal::Speeds const &speed, Real const &magneticX,
                                                  Real const &side);
 
__device__ __host__ mhd::internal::Flux nonStarFluxes(reconstruction::InterfaceState const &state,
                                                      Real const &magneticX);
 
__device__ __host__ void returnFluxes(int const &threadId, int const &o1, int const &o2, int const &o3,
                                      int const &n_cells, Real *dev_flux, mhd::internal::Flux const &flux,
                                      reconstruction::InterfaceState const &state);
 
__device__ __host__ Real starTotalPressure(reconstruction::InterfaceState const &stateL,
                                           reconstruction::InterfaceState const &stateR,
                                           mhd::internal::Speeds const &speed);
 
__device__ __host__ mhd::internal::StarState computeStarState(reconstruction::InterfaceState const &state,
                                                              mhd::internal::Speeds const &speed, Real const &speedSide,
                                                              Real const &magneticX, Real const &totalPressureStar);
 
__device__ __host__ mhd::internal::Flux starFluxes(mhd::internal::StarState const &starState,
                                                   reconstruction::InterfaceState const &state,
                                                   mhd::internal::Flux const &flux, mhd::internal::Speeds const &speed,
                                                   Real const &speedSide);
 
__device__ __host__ mhd::internal::DoubleStarState computeDoubleStarState(mhd::internal::StarState const &starStateL,
                                                                          mhd::internal::StarState const &starStateR,
                                                                          Real const &magneticX,
                                                                          Real const &totalPressureStar,
                                                                          mhd::internal::Speeds const &speed);
 
__device__ __host__ mhd::internal::Flux computeDoubleStarFluxes(mhd::internal::DoubleStarState const &doubleStarState,
                                                                Real const &doubleStarStateEnergy,
                                                                mhd::internal::StarState const &starState,
                                                                reconstruction::InterfaceState const &state,
                                                                mhd::internal::Flux const &flux,
                                                                mhd::internal::Speeds const &speed,
                                                                Real const &speedSide, Real const &speedSideStar);
 
inline __host__ __device__ Real Calc_Pressure_Primitive(reconstruction::InterfaceState const &state,
                                                        Real const &magneticX, Real const &gamma)
{
  return hydro_utilities::Calc_Pressure_Primitive(state.energy, state.density, state.velocity.x(), state.velocity.y(),
                                                  state.velocity.z(), gamma, magneticX, state.magnetic.y(),
                                                  state.magnetic.z());
}
}  // namespace internal
}  // end namespace mhd
#endif  // MHD