CepsEnums.hpp

Go to the documentation of this file.

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   This file is part of CEPS.
 
   CEPS 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.
 
   CEPS 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 CEPS (see file LICENSE at root of project).
   If not, see <https://www.gnu.org/licenses/>.
 
 
   Copyright 2019-2024 Inria, Universite de Bordeaux
 
   Authors, in alphabetical order:
 
     Pierre-Elliott BECUE, Florian CARO, Yves COUDIERE(*), Andjela DAVIDOVIC, 
     Charlie DOUANLA-LONTSI, Marc FUENTES, Mehdi JUHOOR, Michael LEGUEBE(*), 
     Pauline MIGERDITICHAN, Valentin PANNETIER(*), Nejib ZEMZEMI.
     * : currently active authors
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#pragma once
 
#include "common/core/CepsTypes.hpp"
 
namespace ceps
{
  template <typename _Enum>
  constexpr auto
  toIntegral(_Enum e) -> typename std::underlying_type<_Enum>::type
  {
    return static_cast<typename std::underlying_type<_Enum>::type>(e);
  }
}  // namespace ceps
 
#define CEPS_DECL_ENUM_OPERATORS(ENUM)                                           \
                                              \
  constexpr CepsEnum operator| (const ENUM &a, const ENUM &b)                    \
  {                                                                              \
    return ceps::toIntegral(a) | ceps::toIntegral(b);                            \
  }                                                                              \
                                              \
  constexpr CepsEnum operator| (const ENUM &a, const CepsEnum &b)                \
  {                                                                              \
    return ceps::toIntegral(a) | b;                                              \
  }                                                                              \
                                              \
  constexpr CepsEnum operator| (const CepsEnum &a, const ENUM &b)                \
  {                                                                              \
    return a | ceps::toIntegral(b);                                              \
  }                                                                              \
                                             \
  constexpr CepsEnum operator& (const ENUM &a, const ENUM &b)                    \
  {                                                                              \
    return ceps::toIntegral(a) & ceps::toIntegral(b);                            \
  }                                                                              \
                                             \
  constexpr CepsEnum operator& (const ENUM &a, const CepsEnum &b)                \
  {                                                                              \
    return ceps::toIntegral(a) & b;                                              \
  }                                                                              \
                                             \
  constexpr CepsEnum operator& (const CepsEnum &a, const ENUM &b)                \
  {                                                                              \
    return a & ceps::toIntegral(b);                                              \
  }                                                                              \
                                         \
  constexpr CepsBool isEnabledOption (const ENUM& value, const ENUM& option)     \
  {                                                                              \
    return (value & option) == ceps::toIntegral(option);                         \
  }                                                                              \
                                         \
  constexpr CepsBool isEnabledOption (const CepsEnum& value, const ENUM& option) \
  {                                                                              \
    return (value & option) == ceps::toIntegral(option);                         \
  }
 
enum class CepsCompactSupportFlag : CepsEnum
{
  Const,      
  C4,         
  C5,         
  CInf,       
  SRectangle  
  // GAUSSIAN  = 'g',  ///< Gaussian bell
  // HEAVISIDE = 'h',  ///< Heaviside
  // RECTANGLE = 'r'   ///< Rectangle
};
constexpr CepsUInt CepsCompactSupportFlagSize = 4;
 
enum class CepsLocationFlag : CepsEnum
{
  ZeroD = 0,  
  Point = 1,  
  Cell  = 2,  
};
constexpr CepsUInt CepsLocationFlagSize = 3;
 
enum class CepsGhostFlag : CepsEnum
{
  Owned = 0,  
  Halo  = 1   
};
constexpr CepsUInt CepsGhostFlagSize = 2;
 
enum class CepsCellType : CepsEnum
{
  Simplex = 1,   
  Quad    = 100  
};
constexpr CepsUInt CepsCellTypeSize = 200;
 
enum class CepsFunctionFlag : CepsEnum
{
  None         = 1 << 1, 
  Time         = 1 << 2, 
  Space        = 1 << 3, 
  Solution     = 1 << 4, 
  Attribute    = 1 << 5, 
  DofIndex     = 1 << 6, 
  CellIndex    = 1 << 7, 
  NodeIndex    = 1 << 8, 
  UnknownIndex = 1 << 9  
};
 
constexpr CepsUInt CepsFunctionFlagSize = 1 << 9;
CEPS_DECL_ENUM_OPERATORS(CepsFunctionFlag)
 
enum class CepsBoundaryConditionFlag : CepsEnum
{
  Dirichlet, 
  Neumann,   
  Robin      
};
 
enum class CepsSourceTermFlag : CepsEnum 
{
  Default     = 1 << 1, 
  Stimulation = 1 << 2, 
  Laplace     = 1 << 3  
};
CEPS_DECL_ENUM_OPERATORS(CepsSourceTermFlag)
 
enum class CepsAssemblingFlag : CepsEnum 
{
  TimeDerivative,    
  SpatialOperator    
};
 
enum class CepsOutputFormat : CepsEnum
{
  VTKLegacy      = (1 << 1),             
  VTU            = (1 << 2),             
  Music          = (1 << 3) | VTKLegacy, 
  ParaviewSeries = (1 << 4) | VTU,       
  VTKCeps        = (1 << 5),             
  Medit          = (1 << 6)              
};
CEPS_DECL_ENUM_OPERATORS(CepsOutputFormat)