HistoryDataSpec.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2019 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2019 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2019 Total, S.A
 * Copyright (c) 2019-     GEOSX Contributors
 * All right reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */

#ifndef GEOSX_HISTORY_DATA_SPEC_HPP_
#define GEOSX_HISTORY_DATA_SPEC_HPP_

#include "codingUtilities/traits.hpp"
#include "common/DataTypes.hpp"
#include "LvArray/src/Array.hpp"

namespace geosx
{
template< typename T >
constexpr bool can_history_io = std::is_same< std::remove_reference_t< std::remove_const_t< T > >, char >::value ||
                                std::is_same< std::remove_reference_t< std::remove_const_t< T > >, signed char >::value ||
                                std::is_same< std::remove_reference_t< std::remove_const_t< T > >, float >::value ||
                                std::is_same< std::remove_reference_t< std::remove_const_t< T > >, double >::value ||
                                std::is_same< std::remove_reference_t< std::remove_const_t< T > >, int >::value ||
                                std::is_same< std::remove_reference_t< std::remove_const_t< T > >, long >::value ||
                                std::is_same< std::remove_reference_t< std::remove_const_t< T > >, long long >::value;

class HistoryMetadata
{
public:
  HistoryMetadata():
    m_name( "null" ),
    m_rank( 0 ),
    m_dims( ),
    m_type( std::type_index( typeid( nullptr ) ) )
  {}

  HistoryMetadata( const string & name, localIndex rank, localIndex * dims, std::type_index type ):
    m_name( name ),
    m_rank( rank ),
    m_dims( dims, dims+rank ),
    m_type( type )
  {}
  HistoryMetadata( const string & name, localIndex count, std::type_index type ):
    m_name( name ),
    m_rank( 1 ),
    m_dims( &count, &count+1 ),
    m_type( type )
  {}
  void setName( const string & name )
  {
    m_name = name;
  }
  const string & getName( ) const
  {
    return m_name;
  }
  void setType( std::type_index type )
  {
    m_type = type;
  }
  std::type_index getType( ) const
  {
    return m_type;
  }
  localIndex size( ) const
  {
    localIndex localSize = 1;
    for( localIndex dim : m_dims )
    {
      localSize *= dim;
    }
    return localSize;
  }
  localIndex getRank( ) const
  {
    return m_rank;
  }
  std::vector< localIndex > const & getDims( ) const
  {
    return m_dims;
  }
  localIndex size( localIndex dim ) const
  {
    return m_dims[dim];
  }
private:
  std::string m_name;
  localIndex m_rank;
  std::vector< localIndex > m_dims;
  std::type_index m_type;
};

template< typename T >
constexpr bool can_history_io_container = ( traits::is_array_type< T > || traits::is_sorted_array_type< T > );

template< typename T >
inline
typename std::enable_if< can_history_io< T >, HistoryMetadata >::type
getHistoryMetadata( string const & name, ArrayView< T const, 1, 0 > const & arr, localIndex sizeOverride = -1 )
{
  localIndex size = sizeOverride < 0 ? arr.size( ) : sizeOverride;
  return HistoryMetadata( name, size, std::type_index( typeid( T )));
}

template< typename T >
inline
typename std::enable_if< can_history_io< T >, HistoryMetadata >::type
getHistoryMetadata( string const & name, SortedArrayView< T const > const & arr, localIndex sizeOverride = -1 )
{
  localIndex size = sizeOverride < 0 ? arr.size( ) : sizeOverride;
  return HistoryMetadata( name, size, std::type_index( typeid(T)));
}

template< typename ARRAY_T >
inline
typename std::enable_if< ( traits::is_array_type< ARRAY_T >) && (ARRAY_T::NDIM > 1) && can_history_io< typename ARRAY_T::value_type >, HistoryMetadata >::type
getHistoryMetadata( string const & name, ARRAY_T const & arr, localIndex sizeOverride = -1 )
{
  localIndex perIndexSize = arr[ 0 ].size( );
  localIndex numIndices = ( sizeOverride >= 0 ? sizeOverride :  arr.size( ) / perIndexSize );
  localIndex sizes[2] = { numIndices, perIndexSize };
  return HistoryMetadata( name, 2, &sizes[0], std::type_index( typeid(typename ARRAY_T::value_type)));
}

template< typename T >
inline typename std::enable_if< can_history_io< T >, HistoryMetadata >::type
getHistoryMetadata( string const & name, const T & type, localIndex sizeOverride = -1 )
{
  GEOSX_UNUSED_VAR( type );
  localIndex size = sizeOverride < 0 ? 0 : sizeOverride;
  return HistoryMetadata( name, size, std::type_index( typeid(T)));
}

template< typename T >
inline typename std::enable_if< can_history_io_container< T > && !can_history_io< typename T::value_type >, HistoryMetadata >::type
getHistoryMetadata( string const & name, const T & type, localIndex sizeOverride )
{
  GEOSX_ERROR( "Trying to use time history output on an unsupported type." );
  GEOSX_UNUSED_VAR( name );
  GEOSX_UNUSED_VAR( type );
  GEOSX_UNUSED_VAR( sizeOverride );
  return HistoryMetadata( );
}

template< typename T >
inline typename std::enable_if< !can_history_io_container< T > && !can_history_io< T >, HistoryMetadata >::type
getHistoryMetadata( string const & name, const T & type, localIndex sizeOverride )
{
  GEOSX_ERROR( "Trying to use time history output on an unsupported type." );
  GEOSX_UNUSED_VAR( name );
  GEOSX_UNUSED_VAR( type );
  GEOSX_UNUSED_VAR( sizeOverride );
  return HistoryMetadata( );
}

}

#endif