FluxApproximationBase.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 Total, S.A
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */

#ifndef GEOSX_FINITEVOLUME_FLUXAPPROXIMATIONBASE_HPP_
#define GEOSX_FINITEVOLUME_FLUXAPPROXIMATIONBASE_HPP_

#include "dataRepository/Group.hpp"
#include "finiteVolume/FluxStencil.hpp"
#include "CellElementStencilTPFA.hpp"
#include "FaceElementStencil.hpp"
#include "managers/DomainPartition.hpp"

namespace geosx
{

struct CellDescriptor
{
  localIndex region;
  localIndex subRegion;
  localIndex index;

  bool operator==( CellDescriptor const & other )
  {
    return( region==other.region && subRegion==other.subRegion && index==other.index );
  }
};

struct PointDescriptor
{
  enum class Tag { CELL, FACE, NODE };

  Tag tag;

  union
  {
    localIndex nodeIndex;
    localIndex faceIndex;
    CellDescriptor cellIndex;
  };
};

class FluxApproximationBase : public dataRepository::Group
{
public:

  using CatalogInterface = dataRepository::CatalogInterface< FluxApproximationBase, string const &, Group * const >;
  static typename CatalogInterface::CatalogType & GetCatalog();

  FluxApproximationBase() = delete;

  FluxApproximationBase( string const & name, dataRepository::Group * const parent );

  template< typename TYPE >
  TYPE const & getStencil( MeshLevel const & mesh, string const & name ) const;

  template< typename TYPE >
  TYPE & getStencil( MeshLevel & mesh, string const & name ) const;

  template< typename LAMBDA >
  void forAllStencils( MeshLevel const & mesh, LAMBDA && lambda ) const;

  template< typename TYPE, typename ... TYPES, typename LAMBDA >
  void forStencils( MeshLevel const & mesh, LAMBDA && lambda ) const;

  virtual void addToFractureStencil( MeshLevel & mesh,
                                     string const & faceElementRegionName,
                                     bool const initFlag ) const = 0;

  virtual void addEDFracToFractureStencil( MeshLevel & mesh,
                                           string const & embeddedSurfaceRegionName ) const = 0;

  struct viewKeyStruct
  {
    static constexpr auto fieldNameString             = "fieldName";
    static constexpr auto coeffNameString             = "coefficientName";
    static constexpr auto targetRegionsString         = "targetRegions";
    static constexpr auto areaRelativeToleranceString = "areaRelTol";
    static constexpr auto transMultiplierString       = "TransMultiplier";

    // Keys below are for wrappers registered on MeshLevel, not the current object

    static constexpr auto cellStencilString           = "cellStencil";
    static constexpr auto fractureStencilString       = "fractureStencil";
  };

  struct groupKeyStruct
  {
    static constexpr auto stencilMeshGroupString = "finiteVolumeStencils";
  };

  string_array const & targetRegions() const { return m_targetRegions; }
  string_array & targetRegions()       { return m_targetRegions; }

protected:

  virtual void RegisterDataOnMesh( Group * const meshBodies ) override;

  virtual void InitializePostInitialConditions_PreSubGroups( Group * const rootGroup ) override;

  virtual void registerCellStencil( Group & stencilGroup ) const = 0;

  virtual void computeCellStencil( MeshLevel & mesh ) const = 0;

  virtual void registerFractureStencil( Group & stencilGroup ) const = 0;

  virtual void registerBoundaryStencil( Group & stencilGroup,
                                        string const & setName ) const = 0;

  virtual void computeBoundaryStencil( MeshLevel & mesh,
                                       string const & setName,
                                       SortedArrayView< localIndex const > const & faceSet ) const = 0;

  string m_fieldName;

  string m_coeffName;

  string_array m_targetRegions;

  real64 m_areaRelTol;

  real64 m_lengthScale;

};

template< typename TYPE >
TYPE const & FluxApproximationBase::getStencil( MeshLevel const & mesh, string const & name ) const
{
  Group const & stencilGroup = mesh.getGroupReference( groupKeyStruct::stencilMeshGroupString ).getGroupReference( getName() );
  return stencilGroup.getReference< TYPE >( name );
}

template< typename TYPE >
TYPE & FluxApproximationBase::getStencil( MeshLevel & mesh, string const & name ) const
{
  Group & stencilGroup = mesh.getGroupReference( groupKeyStruct::stencilMeshGroupString ).getGroupReference( getName() );
  return stencilGroup.getReference< TYPE >( name );
}

template< typename LAMBDA >
void FluxApproximationBase::forAllStencils( MeshLevel const & mesh, LAMBDA && lambda ) const
{
  //TODO remove dependence on CellElementStencilTPFA and FaceElementStencil
  forStencils< CellElementStencilTPFA, FaceElementStencil >( mesh, std::forward< LAMBDA >( lambda ) );
}

template< typename TYPE, typename ... TYPES, typename LAMBDA >
void FluxApproximationBase::forStencils( MeshLevel const & mesh, LAMBDA && lambda ) const
{
  Group const & stencilGroup = mesh.getGroupReference( groupKeyStruct::stencilMeshGroupString ).getGroupReference( getName() );
  stencilGroup.forWrappers< TYPE, TYPES... >( [&] ( auto const & wrapper )
  {
    lambda( wrapper.reference() );
  } );
}

} // namespace geosx

#endif //GEOSX_FINITEVOLUME_FLUXAPPROXIMATIONBASE_HPP_