Branch data     Line data    Source code

       1                 :            : // *****************************************************************************
       2                 :            : /*!
       3                 :            :   \file      src/PDE/Riemann/Rusanov.hpp
       4                 :            :   \copyright 2012-2015 J. Bakosi,
       5                 :            :              2016-2018 Los Alamos National Security, LLC.,
       6                 :            :              2019-2021 Triad National Security, LLC.
       7                 :            :              All rights reserved. See the LICENSE file for details.
       8                 :            :   \brief     Rusanov Riemann flux function
       9                 :            :   \details   This file implements the Rusanov Riemann solver, specific to ALECG.
      10                 :            : */
      11                 :            : // *****************************************************************************
      12                 :            : #ifndef Rusanov_h
      13                 :            : #define Rusanov_h
      14                 :            : 
      15                 :            : #include <vector>
      16                 :            : 
      17                 :            : #include "Types.hpp"
      18                 :            : #include "Fields.hpp"
      19                 :            : #include "Tags.hpp"
      20                 :            : #include "FunctionPrototypes.hpp"
      21                 :            : #include "Inciter/Options/Flux.hpp"
      22                 :            : #include "EoS/EoS.hpp"
      23                 :            : 
      24                 :            : namespace inciter {
      25                 :            : 
      26                 :            : //! Rusanov approximate Riemann solver
      27                 :            : //! \details This class can be used polymorphically with inciter::RiemannSolver
      28                 :            : struct Rusanov {
      29                 :            : 
      30                 :            :   using real = tk::real;
      31                 :            : 
      32                 :            :   //! Rusanov approximate Riemann solver flux function
      33                 :            :   //! \param[in] system Equation system index
      34                 :            :   //! \param[in] nx X component of the surface normal
      35                 :            :   //! \param[in] ny Y component of the surface normal
      36                 :            :   //! \param[in] nz Z component of the surface normal
      37                 :            :   //! \param[in] mx X component of the weighted surface normal on chare
      38                 :            :   //!   boundary, weighted by the number of contributions to the edge
      39                 :            :   //! \param[in] my Y component of the weighted surface normal on chare
      40                 :            :   //!   boundary, weighted by the number of contributions to the edge
      41                 :            :   //! \param[in] mz Z component of the weighted surface normal on chare
      42                 :            :   //!   boundary, weighted by the number of contributions to the edge
      43                 :            :   //! \param[in] rL Left density
      44                 :            :   //! \param[in] ruL Left X momentum
      45                 :            :   //! \param[in] rvL Left Y momentum
      46                 :            :   //! \param[in] rwL Left Z momentum
      47                 :            :   //! \param[in] reL Left total specific energy
      48                 :            :   //! \param[in] rR Right density
      49                 :            :   //! \param[in] ruR Right X momentum
      50                 :            :   //! \param[in] rvR Right Y momentum
      51                 :            :   //! \param[in] rwR Right Z momentum
      52                 :            :   //! \param[in] reR Right total specific energy
      53                 :            :   //! \param[in] w1L Left X mesh velocity
      54                 :            :   //! \param[in] w2L Left Y mesh velocity
      55                 :            :   //! \param[in] w3L Left Z mesh velocity
      56                 :            :   //! \param[in] w1R Right X mesh velocity
      57                 :            :   //! \param[in] w2R Right Y mesh velocity
      58                 :            :   //! \param[in] w3R Right Z mesh velocity
      59                 :            :   //! \param[in] pL Left pressure
      60                 :            :   //! \param[in] pR Right pressure
      61                 :            :   //! \param[in,out] fr Riemann solution for density according to Rusanov
      62                 :            :   //! \param[in,out] fru Riemann solution for X momenutm according to Rusanov
      63                 :            :   //! \param[in,out] frv Riemann solution for Y momenutm according to Rusanov
      64                 :            :   //! \param[in,out] frw Riemann solution for Z momenutm according to Rusanov
      65                 :            :   //! \param[in,out] fre Riemann solution for specific total energy according
      66                 :            :   //!   to Rusanov
      67                 :            :   #pragma omp declare simd
      68                 :            :   static void
      69                 :   19371723 :   flux( std::size_t system,
      70                 :            :         real nx, real ny, real nz,
      71                 :            :         real mx, real my, real mz,
      72                 :            :         real rL, real ruL, real rvL, real rwL, real reL,
      73                 :            :         real rR, real ruR, real rvR, real rwR, real reR,
      74                 :            :         real w1L, real w2L, real w3L, real w1R, real w2R, real w3R,
      75                 :            :         real pL, real pR,
      76                 :            :         real& fr, real& fru, real& frv, real& frw, real& fre )
      77                 :            :   {
      78                 :   19371723 :     auto ul = ruL/rL - w1L;
      79                 :   19371723 :     auto vl = rvL/rL - w2L;
      80                 :   19371723 :     auto wl = rwL/rL - w3L;
      81                 :            : 
      82                 :   19371723 :     auto ur = ruR/rR - w1R;
      83                 :   19371723 :     auto vr = rvR/rR - w2R;
      84                 :   19371723 :     auto wr = rwR/rR - w3R;
      85                 :            : 
      86                 :   19371723 :     auto al = eos_soundspeed< tag::compflow >( system, rL, pL );
      87                 :   19371723 :     auto ar = eos_soundspeed< tag::compflow >( system, rR, pR );
      88                 :            : 
      89                 :            :     // dissipation
      90                 :            :     real len = tk::length( {mx,my,mz} );
      91                 :   19371723 :     real vml = ul*mx + vl*my + wl*mz;
      92         [ +  + ]:   19371723 :     real vmr = ur*mx + vr*my + wr*mz;
      93                 :   19371723 :     auto sl = std::abs(vml) + al*len;
      94         [ +  + ]:   19371723 :     auto sr = std::abs(vmr) + ar*len;
      95                 :   19371723 :     auto smax = std::max( sl, sr );
      96                 :            : 
      97                 :            :     // face-normal velocities
      98                 :   19371723 :     real vnl = ul*nx + vl*ny + wl*nz;
      99                 :   19371723 :     real vnr = ur*nx + vr*ny + wr*nz;
     100                 :            : 
     101                 :            :     // numerical fluxes
     102                 :   19371723 :     fr  = 0.5*(rL*vnl + rR*vnr - smax*(rR - rL));
     103                 :   19371723 :     fru = 0.5*(ruL*vnl + pL*nx + ruR*vnr + pR*nx - smax*(ruR - ruL));
     104                 :   19371723 :     frv = 0.5*(rvL*vnl + pL*ny + rvR*vnr + pR*ny - smax*(rvR - rvL));
     105                 :   19371723 :     frw = 0.5*(rwL*vnl + pL*nz + rwR*vnr + pR*nz - smax*(rwR - rwL));
     106                 :   19371723 :     fre = 0.5*(reL*vnl + reR*vnr
     107                 :   19371723 :                + pL*(ruL*nx + rvL*ny + rwL*nz)/rL
     108                 :   19371723 :                + pR*(ruR*nx + rvR*ny + rwR*nz)/rR
     109                 :   19371723 :                - smax*(reR - reL));
     110                 :   19371723 :   }
     111                 :            : 
     112                 :            :   //! Flux type accessor
     113                 :            :   //! \return Flux type
     114                 :            :   static ctr::FluxType type() noexcept { return ctr::FluxType::Rusanov; }
     115                 :            : };
     116                 :            : 
     117                 :            : } // inciter::
     118                 :            : 
     119                 :            : #endif // Rusanov_h