vfp-flags.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// Copyright (C) 2023 by the Sapphire++ authors
//
// This file is part of Sapphire++.
//
// Sapphire++ is free software: you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option) any
// later version.
//
// Sapphire++ 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 Lesser General Public License for more
// details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Sapphire++. If not, see <https://www.gnu.org/licenses/>.
//
// -----------------------------------------------------------------------------

 
#ifndef VFP_VFPFLAGS_H
#define VFP_VFPFLAGS_H
 
#include <cstdint>
 
namespace sapphirepp
{

  namespace VFP
  {

    enum class VFPFlags : std::uint16_t
    {
      none = 0,
      time_evolution = 1 << 0,

      spatial_advection = 1 << 1,

      collision = 1 << 2,

      rotation = 1 << 3,

      time_independent_fields = 1 << 4,

      momentum = 1 << 5,

      linear_p = 1 << 6,

      source = 1 << 7,

      time_independent_source = 1 << 8,

      scaled_distribution_function = 1 << 9,

      local_lax_friedrichs_flux = 1 << 10,

      radiation_reaction = 1 << 11
    };
 
 

    constexpr VFPFlags
    operator|(VFPFlags f1, VFPFlags f2)
    {
      return static_cast<VFPFlags>(static_cast<int>(f1) | static_cast<int>(f2));
    }
 
 

    constexpr VFPFlags
    operator&(VFPFlags f1, VFPFlags f2)
    {
      return static_cast<VFPFlags>(static_cast<int>(f1) & static_cast<int>(f2));
    }
 
 

    template <typename StreamType>
    inline StreamType &
    operator<<(StreamType &os, VFPFlags f)
    {
      os << "VFP flags: \n";
      if ((f & VFPFlags::time_evolution) != VFPFlags::none)
        os << "  - Time evolution term\n";
      if ((f & VFPFlags::spatial_advection) != VFPFlags::none)
        os << "  - Spatial Advection\n";
      if ((f & VFPFlags::collision) != VFPFlags::none)
        os << "  - Collision\n";
      if ((f & VFPFlags::rotation) != VFPFlags::none)
        os << "  - Rotation\n";
      if ((f & VFPFlags::time_independent_fields) != VFPFlags::none)
        os << "  - Time Independent Fields\n";
      else
        os << "  - Time Dependent Fields\n";
      if ((f & VFPFlags::momentum) != VFPFlags::none)
        {
          os << "    - Momentum";
          if ((f & VFPFlags::linear_p) != VFPFlags::none)
            os << " (linear)\n";
          else
            os << " (logarithmic)\n";
        }
      if ((f & VFPFlags::source) != VFPFlags::none)
        {
          os << "    - Source";
          if ((f & VFPFlags::time_independent_source) != VFPFlags::none)
            os << " (time independent)\n";
          else
            os << " (time dependent)\n";
        }
      if ((f & VFPFlags::scaled_distribution_function) != VFPFlags::none)
        os << "  - Scaled distribution function\n";
      if ((f & VFPFlags::local_lax_friedrichs_flux) != VFPFlags::none)
        os << "  - Local Lax-Friedrichs Flux\n";
      else
        os << "  - Upwind Flux\n";
      if ((f & VFPFlags::radiation_reaction) != VFPFlags::none)
        os << "  - Radiation reaction term\n";
 
      return os;
    }
 
 

    enum class BoundaryConditions : std::uint8_t
    {
      continuous,

      zero_inflow,

      reflective,

      inflow,

      periodic
    };
 
 

    enum class TimeSteppingMethod : std::uint8_t
    {
      crank_nicolson,

      forward_euler,

      backward_euler,

      erk4,

      lserk4
    };
 
 

    enum class GridType : std::uint8_t
    {
      hypercube,

      shock,

      file
    };
  } // namespace VFP
} // namespace sapphirepp
#endif