DataTypes.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/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 "BufferAllocator.hpp"
#include "DataLayouts.hpp"
#include "GeosxMacros.hpp"
#include "Path.hpp"
#include "StdContainerWrappers.hpp"
#include "Tensor.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"
 
 
// TPL includes
#include <camp/camp.hpp>
 
// System includes
#ifdef GEOS_USE_MPI
  #include <mpi.h>
#endif
 
#include <cassert>
//#include <cmath>
#include <cstdint>
#include <iostream>
#include <optional>
#include <set>
#include <string>
#include <string_view>
#include <typeindex>
#include <typeinfo>
 
/*
 * top level geos namespace contains all code that is specific to GEOSX
 */
namespace geos
{
 
 
using size_t      = std::size_t;
 
using integer     = std::int32_t;
 
using localIndex  = GEOS_LOCALINDEX_TYPE;
 
using globalIndex = GEOS_GLOBALINDEX_TYPE;
 
using string      = std::string;
 
using string_view = std::string_view;
 
using real32 = float;
using real64 = double;
 
 
 
#if defined( GEOS_USE_BOUNDS_CHECK )
 
#else
 
#endif
 
 
 
 
using buffer_unit_type = signed char;
 
#ifdef GEOS_USE_CHAI
using buffer_type = stdVector< buffer_unit_type, BufferAllocator< buffer_unit_type > >;
#else
using buffer_type = stdVector< 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 = string_array;
using string_array = stdVector< 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;
 
} /* namespace geos */
 
#endif /* GEOS_COMMON_DATATYPES_HPP */