CepsTypes.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
 
// Standard and library includes
#include <array>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <mpi.h>
#include <ostream>
#include <set>
#include <span>
#include <sstream>
#include <tuple>
#include <typeinfo>
#include <unordered_map>
#include <vector>
#include <concepts>
#include <memory>
// Bug in order of includes...
#include <vtkPointLocator.h>
#ifdef CEPS_USE_PETSC
  #include <petsc.h>
#endif  // CEPS_USE_PETSC
#include <Eigen/Dense>
 
// =========================================================================
// Select int and floating point types
 
// If Ceps is using Petsc, types are deduced from Petsc configuration
#ifdef CEPS_USE_PETSC
 
  #if not (PETSC_VERSION_MAJOR >= 3 && PETSC_VERSION_MINOR >= 2)
    #error "Ceps need a Petsc version higher or equal than 3.2."
  #endif
 
// Only check if petsc use real as scalar, we don't want extra memory allocation !
static_assert (
  sizeof (PetscReal) == sizeof (PetscScalar),
  "You need to compile Petsc with option '--with-scalar-type=real'"
);
 
using CepsReal  = PetscReal;                     
using CepsInt   = PetscInt;                      
using CepsUInt  = std::make_unsigned_t<CepsInt>; 
using CepsShort = PetscShort;                    
using CepsIndex = PetscInt;                      
 
  // If Petsc is using double precision and Ceps is not using double precision, make the change
  #if defined(PETSC_USE_REAL_DOUBLE) && not defined(CEPS_WITH_DOUBLE_PRECISION)
    #define CEPS_WITH_DOUBLE_PRECISION
  #elif defined(PETSC_USE_REAL_SINGLE) && defined(CEPS_WITH_DOUBLE_PRECISION)
    #undef CEPS_WITH_DOUBLE_PRECISION
  #endif
 
// If Ceps is not using Petsc, types are deduced from Ceps configuration
#else
  #include <inttypes.h>
  #include <type_traits>
 
  #ifdef CEPS_WITH_DOUBLE_PRECISION
using CepsReal = double;   
  #else
using CepsReal = float;    
  #endif
 
  #ifdef CEPS_WITH_64_BIT_INTEGERS
using CepsInt  = int64_t;  
  #else
using CepsInt  = int32_t;  
  #endif
 
using CepsUInt  = std::make_unsigned_t<CepsInt>;  
using CepsShort = short;                          
using CepsIndex = CepsInt;                        
#endif
 
#ifdef CEPS_WITH_DOUBLE_PRECISION
  #define FLOATING_POINT_EPSILON 1E-15  
#else
  #define FLOATING_POINT_EPSILON 1E-6  
#endif
 
// =========================================================================
// Define types with same prefix
 
using CepsProcId  = CepsUInt;                    
using CepsBool    = bool;                        
using CepsChar    = char;                        
using CepsSize    = size_t;                      
using CepsCString = const CepsChar *;            
using CepsString  = std::basic_string<CepsChar>; 
 
// --------------------------------------------------------------
// Definition of math types
using CepsScalar        = CepsReal; 
using CepsMathScalar    = CepsScalar; 
using CepsMathScalars   = Eigen::Matrix<CepsScalar, 1, Eigen::Dynamic>; 
using CepsMathVertex    = Eigen::Matrix<CepsScalar, 3, 1>;              
using CepsMathVertices  = Eigen::Matrix<CepsScalar, 3, Eigen::Dynamic>; 
using CepsMathTensor    = Eigen::Matrix<CepsScalar, 3, 3>;              
using CepsMathTensors   = Eigen::Matrix<CepsScalar, 3, Eigen::Dynamic>; 
using CepsMathDynamic1D = Eigen::Matrix<CepsScalar, Eigen::Dynamic, 1>; 
using CepsMathDynamic2D = Eigen::Matrix<CepsScalar, Eigen::Dynamic, Eigen::Dynamic>; 
 
namespace ceps {
  template<typename _Result>
  _Result
  convertReal(CepsReal* data);
}
 
 
// --------------------------------------------------------------
// Definition of containers,
// check the corresponding header files in common/containers
template <class _Type, class _Alloc = std::allocator<_Type>>
using CepsVector = std::vector<_Type, _Alloc>;
 
template <class _Type, CepsSize _N>
using CepsArray = std::array<_Type, _N>;
template <class _Type>
using CepsArray2 = CepsArray<_Type, 2U>;
template <class _Type>
using CepsArray3 = CepsArray<_Type, 3U>;
template <class _Type>
using CepsArray4 = CepsArray<_Type, 4U>;
template <class _Type>
using CepsArray9                = CepsArray<_Type, 9U>;
 
using CepsReal1D                = CepsArray<CepsReal, 1u>;
using CepsReal2D                = CepsArray2<CepsReal>;
using CepsReal3D                = CepsArray3<CepsReal>;
constexpr CepsReal1D CepsZero1D = {0.0};
constexpr CepsReal2D CepsZero2D = {0.0, 0.0};
constexpr CepsReal3D CepsZero3D = {0.0, 0.0, 0.0};
 
template <class... _Args>
using CepsTuple = std::tuple<_Args...>;
 
template <
  typename _Key,
  typename _Tp,
  typename _Compare = std::less<_Key>,
  typename _Alloc   = std::allocator<std::pair<const _Key, _Tp>>>
using CepsMap = std::map<_Key, _Tp, _Compare, _Alloc>;
 
template <
  typename _Key,
  typename _Tp,
  typename _Hash     = std::hash<_Key>,
  typename _KeyEqual = std::equal_to<_Key>,
  typename _Alloc    = std::allocator<std::pair<const _Key, _Tp>>>
using CepsMultiMap = std::unordered_multimap<_Key, _Tp, _Hash, _KeyEqual, _Alloc>;
 
template <class _Type, class _Compare = std::less<_Type>, class _Alloc = std::allocator<_Type>>
using CepsSet = std::set<_Type, _Compare, _Alloc>;
 
// -----------------
// Types for indices
// These typedefs are mostly to discriminate what is indexed when writing code
 
using CepsAttribute       = CepsInt;         
using CepsEnum            = int;             
using CepsUnknownIndex    = CepsIndex;       
using CepsGlobalIndex     = CepsIndex;       
using CepsLocalIndex      = CepsIndex;       
using CepsHash            = CepsSize;        
using CepsSHash           = int64_t;         
using CepsCellGlobalIndex = CepsGlobalIndex; 
using CepsCellLocalIndex  = CepsLocalIndex;  
using CepsNodeGlobalIndex = CepsGlobalIndex; 
using CepsNodeLocalIndex  = CepsLocalIndex;  
using CepsDofGlobalIndex  = CepsGlobalIndex; 
using CepsDofLocalIndex   = CepsLocalIndex;  
 
constexpr const CepsChar CepsNoName[] = "no-name"; 
constexpr const CepsChar CepsNoUnit[] = "no-unit"; 
 
constexpr CepsAttribute CepsUniversal = -1; 
 
struct CepsStandardArgs
{
  CepsReal               t         = 0.0;             
  CepsReal3D             x         = CepsZero3D;      
  CepsReal               u         = 0.0;             
  CepsSet<CepsAttribute> attr      = {CepsUniversal}; 
  CepsDofGlobalIndex     dofId     = CepsUniversal;   
  CepsCellGlobalIndex    cellId    = CepsUniversal;   
  CepsNodeGlobalIndex    nodeId    = CepsUniversal;   
  CepsUnknownIndex       unknownId = CepsUniversal;   
};
 
// =========================================================================
// Utilities to retrieve the name of the MPI type to be used as argument
// in communications methods
 
template <typename _Type>
struct MpiType;
 
#define CEPS_DECL_PARALLEL_TYPE(_type, _mpi_type)                          \
  template <>                                                              \
  struct MpiType<_type>                                                    \
  {                                                                        \
  \
    static MPI_Datatype                                                    \
    getType()                                                              \
    {                                                                      \
      return static_cast<MPI_Datatype>(static_cast<void *>(&_mpi_type));   \
    }                                                                      \
  }
 
CEPS_DECL_PARALLEL_TYPE(void, ompi_mpi_datatype_null);
 
CEPS_DECL_PARALLEL_TYPE(float, ompi_mpi_float);
 
CEPS_DECL_PARALLEL_TYPE(double, ompi_mpi_double);
 
CEPS_DECL_PARALLEL_TYPE(int8_t, ompi_mpi_int8_t);
 
CEPS_DECL_PARALLEL_TYPE(uint8_t, ompi_mpi_uint8_t);
 
CEPS_DECL_PARALLEL_TYPE(int16_t, ompi_mpi_int16_t);
 
CEPS_DECL_PARALLEL_TYPE(uint16_t, ompi_mpi_uint16_t);
 
CEPS_DECL_PARALLEL_TYPE(int32_t, ompi_mpi_int32_t);
 
CEPS_DECL_PARALLEL_TYPE(uint32_t, ompi_mpi_uint32_t);
 
CEPS_DECL_PARALLEL_TYPE(int64_t, ompi_mpi_int64_t);
 
CEPS_DECL_PARALLEL_TYPE (uint64_t, ompi_mpi_uint64_t);
 
// Define MPI_TYPE used in Ceps
 
#define CEPS_MPI_REAL MpiType<CepsReal>::getType()
 
#define CEPS_MPI_INT MpiType<CepsInt>::getType ()
 
#define CEPS_MPI_UINT MpiType<CepsUInt>::getType ()
 
#define CEPS_MPI_SHORT MpiType<CepsShort>::getType ()
 
#define CEPS_MPI_INDEX MpiType<CepsIndex>::getType ()
 
#define CEPS_MPI_GEOM_INDEX MpiType<CepsIndex>::getType ()
 
#define CEPS_MPI_GLOBAL_INDEX MpiType<CepsGlobalIndex>::getType ()
 
#define CEPS_MPI_LOCAL_INDEX MpiType<CepsLocalIndex>::getType ()
 
#define CEPS_MPI_ELEMENT_INDEX MpiType<CepsIndex>::getType ()
 
#define CEPS_MPI_HASH MpiType<CepsHash>::getType ()
 
#define CEPS_MPI_SHASH MpiType<CepsSHash>::getType()
 
// undefine  CEPS_DECL_PARALLEL_TYPE
#undef CEPS_DECL_PARALLEL_TYPE
 
#define CEPS_MAKE_ALIGNED_OP_NEW EIGEN_MAKE_ALIGNED_OPERATOR_NEW