DataTypes.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 TotalEnergies
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_COMMON_DATATYPES_HPP
#define GEOS_COMMON_DATATYPES_HPP
 
// Source includes
#include "common/GeosxConfig.hpp"
#include "GeosxMacros.hpp"
#include "BufferAllocator.hpp"
#include "DataLayouts.hpp"
#include "Tensor.hpp"
#include "Logger.hpp"
#include "LvArray/src/Macros.hpp"
#include "LvArray/src/Array.hpp"
#include "LvArray/src/ArrayOfArrays.hpp"
#include "LvArray/src/ArrayOfSets.hpp"
#include "LvArray/src/SparsityPattern.hpp"
#include "LvArray/src/CRSMatrix.hpp"
#include "LvArray/src/SortedArray.hpp"
#include "LvArray/src/StackBuffer.hpp"
#include "LvArray/src/ChaiBuffer.hpp"
 
#include "Path.hpp"
 
// TPL includes
#include <camp/camp.hpp>
 
// System includes
#ifdef GEOSX_USE_MPI
  #include <mpi.h>
#endif
 
#include <cassert>
//#include <cmath>
#include <cstdint>
#include <iostream>
#include <memory>
#include <typeindex>
#include <typeinfo>
#include <string>
#include <map>
#include <unordered_map>
#include <vector>
#include <set>
#include <string_view>
 
namespace geos
{
 
template< typename NEW_TYPE, typename EXISTING_TYPE >
NEW_TYPE dynamicCast( EXISTING_TYPE * const val )
{
  static_assert( std::is_pointer< NEW_TYPE >::value, "NEW_TYPE must be a pointer." );
  return dynamic_cast< NEW_TYPE >( val );
}
 
template< typename NEW_TYPE, typename EXISTING_TYPE >
NEW_TYPE dynamicCast( EXISTING_TYPE & val )
{
  static_assert( std::is_reference< NEW_TYPE >::value, "NEW_TYPE must be a reference." );
 
  using POINTER_TO_NEW_TYPE = std::remove_reference_t< NEW_TYPE > *;
  POINTER_TO_NEW_TYPE ptr = dynamicCast< POINTER_TO_NEW_TYPE >( &val );
  GEOS_ERROR_IF( ptr == nullptr, "Cast from " << LvArray::system::demangleType( val ) << " to " <<
                 LvArray::system::demangleType< NEW_TYPE >() << " failed." );
 
  return *ptr;
}
 
#ifdef GEOSX_USE_MPI
extern MPI_Comm MPI_COMM_GEOSX;
#else
extern int MPI_COMM_GEOSX;
#endif
 
 
using size_t      = std::size_t;
 
using integer     = std::int32_t;
 
using localIndex  = GEOSX_LOCALINDEX_TYPE;
 
using globalIndex = GEOSX_GLOBALINDEX_TYPE;
 
using string      = std::string;
 
using string_view = std::string_view;
 
using real32 = float;
using real64 = double;
 
 
 
using buffer_unit_type = signed char;
 
#ifdef GEOSX_USE_CHAI
using buffer_type = std::vector< buffer_unit_type, BufferAllocator< buffer_unit_type > >;
#else
using buffer_type = std::vector< buffer_unit_type >;
#endif
 
 
 
using Timestamp = unsigned long long int;
 
 
//START_SPHINX_INCLUDE_00
 
 
template< typename T,
          int NDIM,
          typename PERMUTATION=camp::make_idx_seq_t< NDIM > >
using Array = LvArray::Array< T, NDIM, PERMUTATION, localIndex, LvArray::ChaiBuffer >;
 
template< typename T,
          int NDIM,
          int USD = NDIM - 1 >
using ArrayView = LvArray::ArrayView< T, NDIM, USD, localIndex, LvArray::ChaiBuffer >;
 
template< typename T, int NDIM, int USD = NDIM - 1 >
using ArraySlice = LvArray::ArraySlice< T, NDIM, USD, localIndex >;
 
template< typename T, int NDIM, int MAXSIZE, typename PERMUTATION=camp::make_idx_seq_t< NDIM > >
using StackArray = LvArray::StackArray< T, NDIM, PERMUTATION, localIndex, MAXSIZE >;
 
 
 
using R1Tensor = Tensor< real64, 3 >;
using R1Tensor32 = Tensor< real32, 3 >;
 
using R2SymTensor = Tensor< real64, 6 >;
 
 
template< typename T >
using array1d = Array< T, 1 >;
 
template< typename T >
using arrayView1d = ArrayView< T, 1 >;
 
template< typename T, int USD = 0 >
using arraySlice1d = ArraySlice< T, 1, USD >;
 
template< typename T, int MAXSIZE >
using stackArray1d = StackArray< T, 1, MAXSIZE >;
 
template< typename T, typename PERMUTATION=camp::make_idx_seq_t< 2 > >
using array2d = Array< T, 2, PERMUTATION >;
 
template< typename T, int USD = 1 >
using arrayView2d = ArrayView< T, 2, USD >;
 
template< typename T, int USD = 1 >
using arraySlice2d = ArraySlice< T, 2, USD >;
 
template< typename T, int MAXSIZE >
using stackArray2d = StackArray< T, 2, MAXSIZE >;
 
template< typename T, typename PERMUTATION=camp::make_idx_seq_t< 3 > >
using array3d = Array< T, 3, PERMUTATION >;
 
template< typename T, int USD=2 >
using arrayView3d = ArrayView< T, 3, USD >;
 
template< typename T, int USD=2 >
using arraySlice3d = ArraySlice< T, 3, USD >;
 
template< typename T, int MAXSIZE >
using stackArray3d = StackArray< T, 3, MAXSIZE >;
 
template< typename T, typename PERMUTATION=camp::make_idx_seq_t< 4 > >
using array4d = Array< T, 4, PERMUTATION >;
 
template< typename T, int USD=3 >
using arrayView4d = ArrayView< T, 4, USD >;
 
template< typename T, int USD=3 >
using arraySlice4d = ArraySlice< T, 4, USD >;
 
template< typename T, int MAXSIZE >
using stackArray4d = StackArray< T, 4, MAXSIZE >;
 
template< typename T, typename PERMUTATION=camp::make_idx_seq_t< 5 > >
using array5d = Array< T, 5, PERMUTATION >;
 
template< typename T, int USD=4 >
using arrayView5d = ArrayView< T, 5, USD >;
 
template< typename T, int USD=4 >
using arraySlice5d = ArraySlice< T, 5, 4 >;
 
template< typename T, int MAXSIZE >
using stackArray5d = StackArray< T, 5, MAXSIZE >;
 
 
 
template< typename T >
using set = std::set< T >;
 
template< typename T >
using SortedArray = LvArray::SortedArray< T, localIndex, LvArray::ChaiBuffer >;
 
template< typename T >
using SortedArrayView = LvArray::SortedArrayView< T, localIndex, LvArray::ChaiBuffer >;
 
 
 
template< typename T, typename INDEX_TYPE=localIndex >
using ArrayOfArrays = LvArray::ArrayOfArrays< T, INDEX_TYPE, LvArray::ChaiBuffer >;
 
template< typename T, typename INDEX_TYPE=localIndex, bool CONST_SIZES=std::is_const< T >::value >
using ArrayOfArraysView = LvArray::ArrayOfArraysView< T, INDEX_TYPE const, CONST_SIZES, LvArray::ChaiBuffer >;
 
template< typename T, typename INDEX_TYPE=localIndex >
using ArrayOfSets = LvArray::ArrayOfSets< T, INDEX_TYPE, LvArray::ChaiBuffer >;
 
template< typename T, typename INDEX_TYPE=localIndex >
using ArrayOfSetsView = LvArray::ArrayOfSetsView< T, INDEX_TYPE const, LvArray::ChaiBuffer >;
 
template< typename COL_INDEX, typename INDEX_TYPE=localIndex >
using SparsityPattern = LvArray::SparsityPattern< COL_INDEX, INDEX_TYPE, LvArray::ChaiBuffer >;
 
template< typename COL_INDEX, typename INDEX_TYPE=localIndex >
using SparsityPatternView = LvArray::SparsityPatternView< COL_INDEX, INDEX_TYPE const, LvArray::ChaiBuffer >;
 
template< typename T, typename COL_INDEX=globalIndex >
using CRSMatrix = LvArray::CRSMatrix< T, COL_INDEX, localIndex, LvArray::ChaiBuffer >;
 
template< typename T, typename COL_INDEX=globalIndex >
using CRSMatrixView = LvArray::CRSMatrixView< T, COL_INDEX, localIndex const, LvArray::ChaiBuffer >;
 
 
//END_SPHINX_INCLUDE_00
 
 
template< typename TKEY, typename TVAL, typename SORTED >
class mapBase
{};
 
template< typename TKEY, typename TVAL >
class mapBase< TKEY, TVAL, std::integral_constant< bool, true > > : public std::map< TKEY, TVAL >
{
  using std::map< TKEY, TVAL >::map; // enable list initialization
};
 
template< typename TKEY, typename TVAL >
class mapBase< TKEY, TVAL, std::integral_constant< bool, false > > : public std::unordered_map< TKEY, TVAL >
{
  using std::unordered_map< TKEY, TVAL >::unordered_map; // enable list initialization
};
 
template< typename K, typename V, typename SORTED >
inline
std::ostream & operator<< ( std::ostream & stream, mapBase< K, V, SORTED > const & map )
{
  stream << "{\n";
  for( auto const & pair : map )
  {
    stream << pair.first << " : " << pair.second << "\n";
  }
  stream << "}";
  return stream;
}
 
template< typename TKEY, typename TVAL >
using map = mapBase< TKEY, TVAL, std::integral_constant< bool, true > >;
 
template< typename TKEY, typename TVAL >
using unordered_map = mapBase< TKEY, TVAL, std::integral_constant< bool, false > >;
 
 
 
using integer_array = array1d< integer >;
 
using real32_array = array1d< real32 >;
 
using real64_array = array1d< real64 >;
 
using string_array = array1d< string >;
 
using path_array = array1d< Path >;
 
using localIndex_array = array1d< localIndex >;
 
using globalIndex_array = array1d< globalIndex >;
 
 
using integer_array2d = array2d< integer >;
 
using real32_array2d = array2d< real32 >;
 
using real64_array2d = array2d< real64 >;
 
using localIndex_array2d = array2d< localIndex >;
 
using globalIndex_array2d = array2d< globalIndex >;
 
 
using integer_array3d = array3d< integer >;
 
using real32_array3d = array3d< real32 >;
 
using real64_array3d = array3d< real64 >;
 
using localIndex_array3d = array3d< localIndex >;
 
using globalIndex_array3d = array3d< globalIndex >;
 
 
using integer_array4d = array4d< integer >;
 
using real32_array4d = array4d< real32 >;
 
using real64_array4d = array4d< real64 >;
 
using localIndex_array4d = array4d< localIndex >;
 
using globalIndex_array4d = array4d< globalIndex >;
 
 
constexpr static auto GLOBALINDEX_MAX = std::numeric_limits< globalIndex >::max();
 
constexpr static auto LOCALINDEX_MAX = std::numeric_limits< localIndex >::max();
 
constexpr static localIndex unmappedLocalIndexValue = -1;
 
 
void printTypeSummary();
 
struct Regex
{
  string m_regexStr;
  string m_formatDescription;
  Regex() {}
  Regex( string_view regexStr, string_view formatDescription );
};
 
template< typename T, typename ENABLE = void >
struct TypeRegex
{
  static Regex get() { return {}; }
};
 
class rtTypes
{
public:
 
  using RegexMapType = std::map< string, Regex >;
 
  struct CustomTypes
  {
    static constexpr string_view mapPair             = "mapPair";
    static constexpr string_view plotLevel           = "geos_dataRepository_PlotLevel";
    static constexpr string_view groupName           = "groupName";
    static constexpr string_view groupNameRef        = "groupNameRef";
    static constexpr string_view groupNameRefArray   = "groupNameRef_array";
  };
 
  static string getTypeName( std::type_index const key );
 
  template< typename T >
  static Regex const & getTypeRegex()
  { return getTypeRegex< T >( getTypeName( typeid( T ) ) ); }
 
  template< typename T >
  static Regex const & getTypeRegex( string_view typeName )
  {
    RegexMapType & map = getTypeRegexMap();
    auto const it = map.find( string( typeName ) );
    if( it != map.end() )
    {
      return it->second;
    }
    else
    {
      return map.emplace( typeName, TypeRegex< T >::get() ).first->second;
    }
  }
 
  static RegexMapType createBasicTypesRegexMap();
 
private:
 
  static RegexMapType & getTypeRegexMap()
  {
    static RegexMapType m = createBasicTypesRegexMap();
    return m;
  }
 
  rtTypes() {}
 
};
 
template< typename T >
struct TypeName
{
  static string full()
  {
    return ::LvArray::system::demangle( typeid( T ).name() );
  }
 
  static string brief()
  {
    string const full_name = full();
    string::size_type const pos = full_name.find_last_of( "::" );
    return ( pos == string::npos ) ? full_name : full_name.substr( pos );
  }
};
 
}
 
 
 
#endif /* GEOS_COMMON_DATATYPES_HPP */