FluxApproximationBase.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_FINITEVOLUME_FLUXAPPROXIMATIONBASE_HPP_
#define GEOS_FINITEVOLUME_FLUXAPPROXIMATIONBASE_HPP_
 
#include "dataRepository/Group.hpp"
#include "CellElementStencilTPFA.hpp"
#include "SurfaceElementStencil.hpp"
#include "FaceElementToCellStencil.hpp"
#include "EmbeddedSurfaceToCellStencil.hpp"
#include "SurfaceElementStencil.hpp"
#include "mesh/DomainPartition.hpp"
 
namespace geos
{
 
enum class UpwindingScheme : integer
{
  PPU,    
  C1PPU,  
  IHU 
};
 
ENUM_STRINGS( UpwindingScheme,
              "PPU",
              "C1PPU",
              "IHU" );
 
struct UpwindingParameters
{
  UpwindingScheme upwindingScheme;
 
  //real64 epsC1PPU;
};
 
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 ) const = 0;
 
  virtual void addEmbeddedFracturesToStencils( MeshLevel & mesh,
                                               string const & embeddedSurfaceRegionName ) const = 0;
 
  struct viewKeyStruct
  {
    static constexpr char const * fieldNameString() { return "fieldName"; }
 
    static constexpr char const * coeffNameString() { return "coefficientName"; }
 
    static constexpr char const * targetRegionsString() { return "targetRegions"; }
 
    static constexpr char const * areaRelativeToleranceString() { return "areaRelTol"; }
 
    static constexpr char const * transMultiplierString() { return "TransMultiplier"; }
 
 
    // Keys below are for wrappers registered on MeshLevel, not the current object
 
    static constexpr char const * cellStencilString() { return "cellStencil"; }
 
    static constexpr char const * fractureStencilString() { return "fractureStencil"; }
 
    static constexpr char const * upwindingSchemeString() { return "upwindingScheme"; }
 
    //static constexpr char const * epsC1PPUString() { return "epsC1PPU"; }
 
  };
 
  struct groupKeyStruct
  {
    static constexpr auto stencilMeshGroupString() { return "finiteVolumeStencils"; }
  };
 
  array1d< string > & targetRegions( string const & meshBodyName ) { return m_targetRegions[meshBodyName]; }
 
  void addFieldName( string const & name );
 
  void setCoeffName( string const & name );
 
  UpwindingParameters const & upwindingParams() const { return m_upwindingParams; }
 
protected:
 
  virtual void initializePreSubGroups() override;
 
  virtual void initializePostInitialConditionsPreSubGroups() override;
 
  virtual void registerCellStencil( Group & stencilGroup ) const = 0;
 
  virtual void computeCellStencil( MeshLevel & mesh ) const = 0;
 
  virtual void computeFractureStencil( 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;
 
  virtual void registerAquiferStencil( Group & stencilGroup,
                                       string const & setName ) const = 0;
 
  virtual void computeAquiferStencil( DomainPartition & domain,
                                      MeshLevel & mesh ) const = 0;
 
 
  array1d< string > m_fieldNames;
 
  string m_coeffName;
 
  map< string, array1d< string > > m_targetRegions;
 
  real64 m_areaRelTol;
 
  real64 m_lengthScale;
 
  UpwindingParameters m_upwindingParams;
 
};
 
template< typename TYPE >
TYPE const & FluxApproximationBase::getStencil( MeshLevel const & mesh, string const & name ) const
{
  Group const & stencilGroup = mesh.getGroup( groupKeyStruct::stencilMeshGroupString() ).getGroup( getName() );
  return stencilGroup.getReference< TYPE >( name );
}
 
template< typename TYPE >
TYPE & FluxApproximationBase::getStencil( MeshLevel & mesh, string const & name ) const
{
  Group & stencilGroup = mesh.getGroup( groupKeyStruct::stencilMeshGroupString() ).getGroup( getName() );
  return stencilGroup.getReference< TYPE >( name );
}
 
template< typename LAMBDA >
void FluxApproximationBase::forAllStencils( MeshLevel const & mesh, LAMBDA && lambda ) const
{
  //TODO remove dependence on CellElementStencilTPFA and SurfaceElementStencil
  forStencils< CellElementStencilTPFA,
               SurfaceElementStencil,
               EmbeddedSurfaceToCellStencil,
               FaceElementToCellStencil >( 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.getGroup( groupKeyStruct::stencilMeshGroupString() ).getGroup( getName() );
  stencilGroup.forWrappers< TYPE, TYPES... >( [&] ( auto const & wrapper )
  {
    lambda( wrapper.reference() );
  } );
}
 
} // namespace geos
 
#endif //GEOS_FINITEVOLUME_FLUXAPPROXIMATIONBASE_HPP_