StencilBase.hpp

/*
 * ------------------------------------------------------------------------------------------------------------
 * 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_FINITEVOLUME_STENCILBASE_HPP_
#define GEOS_FINITEVOLUME_STENCILBASE_HPP_
 
#include "common/DataTypes.hpp"
#include "codingUtilities/Utilities.hpp"
#include "mesh/ElementRegionManager.hpp"
 
namespace geos
{
 
template< template< typename ... > class CONTAINER,
          localIndex MAX_NUM_POINTS_IN_FLUX,
          localIndex MAX_STENCIL_SIZE,
          localIndex MAX_NUM_CONNECTIONS >
struct StencilTraits
{
  using IndexContainerType = CONTAINER< localIndex >;
 
  using IndexContainerViewConstType = LvArray::typeManipulation::NestedViewTypeConst< IndexContainerType >;
 
  using WeightContainerType = CONTAINER< real64 >;
 
  using WeightContainerViewConstType = LvArray::typeManipulation::NestedViewTypeConst< WeightContainerType >;
 
  using WeightContainerViewType = LvArray::typeManipulation::NestedViewType< WeightContainerType >;
 
  static constexpr localIndex maxNumPointsInFlux = MAX_NUM_POINTS_IN_FLUX;
 
  static constexpr localIndex maxStencilSize = MAX_STENCIL_SIZE;
 
  static constexpr localIndex maxNumConnections = MAX_NUM_CONNECTIONS;
};
 
using TwoPointStencilTraits = StencilTraits< array2d, 2, 2, 1 >;
 
template< typename TRAITS >
class StencilWrapperBase : public TRAITS
{
public:
 
  StencilWrapperBase( typename TRAITS::IndexContainerType const & elementRegionIndices,
                      typename TRAITS::IndexContainerType const & elementSubRegionIndices,
                      typename TRAITS::IndexContainerType const & elementIndices,
                      typename TRAITS::WeightContainerType const & weights ):
    m_elementRegionIndices( elementRegionIndices.toViewConst() ),
    m_elementSubRegionIndices( elementSubRegionIndices.toViewConst() ),
    m_elementIndices( elementIndices.toViewConst() ),
    m_weights( weights.toView() )
  {};
 
  typename TRAITS::IndexContainerViewConstType
  getElementRegionIndices() const { return m_elementRegionIndices; }
 
  typename TRAITS::IndexContainerViewConstType
  getElementSubRegionIndices() const { return m_elementSubRegionIndices; }
 
  typename TRAITS::IndexContainerViewConstType
  getElementIndices() const { return m_elementIndices; }
 
  typename TRAITS::WeightContainerViewConstType
  getWeights() const { return m_weights; }
 
protected:
 
  typename TRAITS::IndexContainerViewConstType m_elementRegionIndices;
 
  typename TRAITS::IndexContainerViewConstType m_elementSubRegionIndices;
 
  typename TRAITS::IndexContainerViewConstType m_elementIndices;
 
  typename TRAITS::WeightContainerViewType m_weights;
};
 
 
template< typename TRAITS, typename LEAFCLASS >
class StencilBase : public TRAITS
{
public:
 
  virtual ~StencilBase() = default;
 
  virtual void reserve( localIndex const size );
 
  virtual void move( LvArray::MemorySpace const space );
 
 
  virtual void add( localIndex const numPts,
                    localIndex const * const elementRegionIndices,
                    localIndex const * const elementSubRegionIndices,
                    localIndex const * const elementIndices,
                    real64 const * const weights,
                    localIndex const connectorIndex ) = 0;
 
  virtual bool zero( localIndex const connectorIndex );
 
  virtual localIndex size() const = 0;
 
  void setName( string const & name );
 
  typename TRAITS::IndexContainerViewConstType
  getElementRegionIndices() const { return m_elementRegionIndices.toViewConst(); }
 
  typename TRAITS::IndexContainerViewConstType
  getElementSubRegionIndices() const { return m_elementSubRegionIndices.toViewConst(); }
 
  typename TRAITS::IndexContainerViewConstType
  getElementIndices() const { return m_elementIndices.toViewConst(); }
 
  typename TRAITS::WeightContainerViewConstType
  getWeights() const { return m_weights.toViewConst(); }
 
protected:
 
  typename TRAITS::IndexContainerType m_elementRegionIndices;
 
  typename TRAITS::IndexContainerType m_elementSubRegionIndices;
 
  typename TRAITS::IndexContainerType m_elementIndices;
 
  typename TRAITS::WeightContainerType m_weights;
 
  unordered_map< localIndex, localIndex > m_connectorIndices;
};
 
 
 
template< typename LEAFCLASSTRAITS, typename LEAFCLASS >
void StencilBase< LEAFCLASSTRAITS, LEAFCLASS >::reserve( localIndex const size )
{
  m_elementRegionIndices.reserve( size * 2 );
  m_elementSubRegionIndices.reserve( size * 2 );
  m_elementIndices.reserve( size * 2 );
  m_weights.reserve( size * 2 );
}
 
 
template< typename LEAFCLASSTRAITS, typename LEAFCLASS >
bool StencilBase< LEAFCLASSTRAITS, LEAFCLASS >::zero( localIndex const connectorIndex )
{
  return
    executeOnMapValue( m_connectorIndices, connectorIndex, [&]( localIndex const connectionListIndex )
  {
    for( localIndex i = 0; i < static_cast< LEAFCLASS * >(this)->stencilSize( connectorIndex ); ++i )
    {
      m_weights[connectionListIndex][i] = 0;
    }
  } );
}
 
template< typename LEAFCLASSTRAITS, typename LEAFCLASS >
void StencilBase< LEAFCLASSTRAITS, LEAFCLASS >::setName( string const & name )
{
  m_elementRegionIndices.setName( name + "/elementRegionIndices" );
  m_elementSubRegionIndices.setName( name + "/elementSubRegionIndices" );
  m_elementIndices.setName( name + "/elementIndices" );
  m_weights.setName( name + "/weights" );
}
 
template< typename LEAFCLASSTRAITS, typename LEAFCLASS >
void StencilBase< LEAFCLASSTRAITS, LEAFCLASS >::move( LvArray::MemorySpace const space )
{
  m_elementRegionIndices.move( space, true );
  m_elementSubRegionIndices.move( space, true );
  m_elementIndices.move( space, true );
  m_weights.move( space, true );
}
 
} /* namespace geos */
 
#endif /* GEOS_FINITEVOLUME_STENCILBASE_HPP_ */