InterfaceKernelBase.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 Total, S.A
 * 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_FINITEELEMENT_INTERFACEKERNELBASE_HPP_
#define GEOS_FINITEELEMENT_INTERFACEKERNELBASE_HPP_
 
#include "ImplicitKernelBase.hpp"
 
#ifndef SELECTED_FE_TYPES_2D
#define SELECTED_FE_TYPES_2D BASE_FE_TYPES_2D
#endif
 
namespace geos
{
 
namespace finiteElement
{
 
template< typename CONSTITUTIVE_TYPE,
          typename FE_TYPE,
          int NUM_DOF_PER_TEST_SP,
          int NUM_DOF_PER_TRIAL_SP >
class InterfaceKernelBase : public ImplicitKernelBase< FaceElementSubRegion,
                                                       CONSTITUTIVE_TYPE,
                                                       FE_TYPE,
                                                       NUM_DOF_PER_TEST_SP,
                                                       NUM_DOF_PER_TRIAL_SP >
{
public:
 
  using Base = ImplicitKernelBase< FaceElementSubRegion,
                                   CONSTITUTIVE_TYPE,
                                   FE_TYPE,
                                   NUM_DOF_PER_TEST_SP,
                                   NUM_DOF_PER_TRIAL_SP >;
 
  using Base::m_dofNumber;
  using Base::m_dofRankOffset;
  using Base::m_matrix;
 
  InterfaceKernelBase( NodeManager const & nodeManager,
                       EdgeManager const & edgeManager,
                       FaceManager const & faceManager,
                       localIndex const targetRegionIndex,
                       FaceElementSubRegion & elementSubRegion,
                       FE_TYPE const & finiteElementSpace,
                       CONSTITUTIVE_TYPE & inputConstitutiveType,
                       arrayView1d< globalIndex const > const inputDofNumber,
                       globalIndex const rankOffset,
                       CRSMatrixView< real64, globalIndex const > const inputMatrix,
                       arrayView1d< real64 > const inputRhs,
                       real64 const inputDt ):
    Base( nodeManager,
          edgeManager,
          faceManager,
          targetRegionIndex,
          elementSubRegion,
          finiteElementSpace,
          inputConstitutiveType,
          inputDofNumber,
          rankOffset,
          inputMatrix,
          inputRhs,
          inputDt )
  {}
 
  //***************************************************************************
  struct StackVariables
  {};
 
};
 
template< template< typename CONSTITUTIVE_TYPE,
                    typename FE_TYPE > class KERNEL_TYPE,
          typename ... ARGS >
class InterfaceKernelFactory
{
public:
 
  InterfaceKernelFactory( ARGS ... args ):
    m_args( args ... )
  {}
 
  template< typename CONSTITUTIVE_TYPE, typename FE_TYPE >
  KERNEL_TYPE< CONSTITUTIVE_TYPE, FE_TYPE > createKernel(
    NodeManager & nodeManager,
    EdgeManager const & edgeManager,
    FaceManager const & faceManager,
    localIndex const targetRegionIndex,
    FaceElementSubRegion & elementSubRegion,
    FE_TYPE const & finiteElementSpace,
    CONSTITUTIVE_TYPE & inputConstitutiveType )
  {
    camp::tuple< NodeManager &,
                 EdgeManager const &,
                 FaceManager const &,
                 localIndex const,
                 FaceElementSubRegion &,
                 FE_TYPE const &,
                 CONSTITUTIVE_TYPE & > standardArgs { nodeManager,
                                                      edgeManager,
                                                      faceManager,
                                                      targetRegionIndex,
                                                      elementSubRegion,
                                                      finiteElementSpace,
                                                      inputConstitutiveType };
 
    auto allArgs = camp::tuple_cat_pair( standardArgs, m_args );
    return camp::make_from_tuple< KERNEL_TYPE< CONSTITUTIVE_TYPE, FE_TYPE > >( allArgs );
 
  }
 
private:
  camp::tuple< ARGS ... > m_args;
};
 
//*****************************************************************************
 
//START_interfaceBasedKernelApplication
template< typename POLICY,
          typename CONSTITUTIVE_BASE,
          typename KERNEL_FACTORY >
static
real64 interfaceBasedKernelApplication( MeshLevel & mesh,
                                        string const & targetRegionName,
                                        arrayView1d< localIndex const > const & faceElementList,
                                        FiniteElementBase const & subRegionFE,
                                        string const & constitutiveStringName,
                                        KERNEL_FACTORY & interfaceKernelFactory )
{
  GEOS_MARK_FUNCTION;
 
 
  // save the maximum residual contribution for scaling residuals for convergence criteria.
  real64 maxResidualContribution = 0;
 
  NodeManager & nodeManager = mesh.getNodeManager();
  EdgeManager & edgeManager = mesh.getEdgeManager();
  FaceManager & faceManager = mesh.getFaceManager();
  ElementRegionManager & elementManager = mesh.getElemManager();
 
  SurfaceElementRegion & region = elementManager.getRegion< SurfaceElementRegion >( targetRegionName );
  FaceElementSubRegion & subRegion = region.getUniqueSubRegion< FaceElementSubRegion >();
  localIndex const targetRegionIndex = 0;
 
  // Get the constitutive model...and allocate a null constitutive model if required.
  constitutive::ConstitutiveBase * constitutiveRelation = nullptr;
  constitutive::NullModel * nullConstitutiveModel = nullptr;
  if( subRegion.template hasWrapper< string >( constitutiveStringName ) )
  {
    string const & constitutiveName = subRegion.template getReference< string >( constitutiveStringName );
    constitutiveRelation = &subRegion.template getConstitutiveModel( constitutiveName );
  }
  else
  {
    nullConstitutiveModel = &subRegion.template registerGroup< constitutive::NullModel >( "nullModelGroup" );
    constitutiveRelation = nullConstitutiveModel;
  }
 
  localIndex const numElems = faceElementList.size();
 
  // Call the constitutive dispatch which converts the type of constitutive model into a compile time constant.
  constitutive::ConstitutivePassThru< CONSTITUTIVE_BASE >::execute( *constitutiveRelation,
                                                                    [&maxResidualContribution,
                                                                     &nodeManager,
                                                                     &edgeManager,
                                                                     &faceManager,
                                                                     targetRegionIndex,
                                                                     &interfaceKernelFactory,
                                                                     &subRegion,
                                                                     &subRegionFE,
                                                                     numElems]
                                                                      ( auto & castedConstitutiveRelation )
  {
 
    finiteElement::FiniteElementDispatchHandler< SELECTED_FE_TYPES_2D >::dispatch2D( subRegionFE,
                                                                                     [&maxResidualContribution,
                                                                                      &nodeManager,
                                                                                      &edgeManager,
                                                                                      &faceManager,
                                                                                      targetRegionIndex,
                                                                                      &interfaceKernelFactory,
                                                                                      &subRegion,
                                                                                      numElems,
                                                                                      &castedConstitutiveRelation] ( auto const finiteElement )
 
    {
      auto kernel = interfaceKernelFactory.createKernel( nodeManager,
                                                         edgeManager,
                                                         faceManager,
                                                         targetRegionIndex,
                                                         subRegion,
                                                         finiteElement,
                                                         castedConstitutiveRelation );
 
      using KERNEL_TYPE = decltype( kernel );
 
      // Call the kernelLaunch function, and store the maximum contribution to the residual.
      maxResidualContribution =
        std::max( maxResidualContribution,
                  KERNEL_TYPE::template kernelLaunch< POLICY, KERNEL_TYPE >( numElems, kernel ) );
 
    } );
  } );
 
  // Remove the null constitutive model (not required, but cleaner)
  if( nullConstitutiveModel )
  {
    subRegion.deregisterGroup( "nullModelGroup" );
  }
 
  return maxResidualContribution;
}
//END_interfaceBasedKernelApplication
 
} // namespace finiteElement
} // namespace geos
 
#endif /* GEOS_FINITEELEMENT_INTERFACEKERNELBASE_HPP_ */