SparsityKernelBase.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.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#include "ImplicitKernelBase.hpp"
 
#ifndef GEOS_FINITEELEMENT_SPARSITYKERNELBASE_HPP_
#define GEOS_FINITEELEMENT_SPARSITYKERNELBASE_HPP_
 
 
 
namespace geos
{
 
namespace finiteElement
{
 
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
template< typename SUBREGION_TYPE,
          typename CONSTITUTIVE_TYPE,
          typename FE_TYPE,
          int NUM_DOF_PER_TEST_SP,
          int NUM_DOF_PER_TRIAL_SP >
class SparsityKernelBase : public ImplicitKernelBase< SUBREGION_TYPE,
                                                      CONSTITUTIVE_TYPE,
                                                      FE_TYPE,
                                                      NUM_DOF_PER_TEST_SP,
                                                      NUM_DOF_PER_TRIAL_SP >
{
public:
  using Base = ImplicitKernelBase< SUBREGION_TYPE,
                                   CONSTITUTIVE_TYPE,
                                   FE_TYPE,
                                   NUM_DOF_PER_TEST_SP,
                                   NUM_DOF_PER_TRIAL_SP >;
 
 
  using typename Base::StackVariables;
  using Base::m_dofRankOffset;
  using Base::m_dt;
 
  using Base::setup;
 
  SparsityKernelBase( NodeManager const & nodeManager,
                      EdgeManager const & edgeManager,
                      FaceManager const & faceManager,
                      localIndex const targetRegionIndex,
                      SUBREGION_TYPE const & elementSubRegion,
                      FE_TYPE const & finiteElementSpace,
                      CONSTITUTIVE_TYPE & inputConstitutiveType,
                      arrayView1d< globalIndex const > const & inputDofNumber,
                      globalIndex const rankOffset,
                      real64 const inputDt,
                      SparsityPattern< globalIndex > & inputSparsity ):
    Base( nodeManager,
          edgeManager,
          faceManager,
          targetRegionIndex,
          elementSubRegion,
          finiteElementSpace,
          inputConstitutiveType,
          inputDofNumber,
          rankOffset,
          CRSMatrixView< real64, globalIndex const >(),
          arrayView1d< real64 >(),
          inputDt ),
    m_sparsity( inputSparsity )
  {}
 
 
  inline
  real64 complete( localIndex const k,
                   StackVariables & stack ) const
  {
    GEOS_UNUSED_VAR( k );
 
    for( localIndex r=0; r<stack.numRows; ++r )
    {
      localIndex const row = stack.localRowDofIndex[r] - m_dofRankOffset;
      if( row < 0 || row >= m_sparsity.numRows() ) continue;
      for( localIndex c=0; c<stack.numCols; ++c )
      {
        m_sparsity.insertNonZero( row,
                                  stack.localColDofIndex[c] );
      }
    }
    return 0;
  }
 
 
 
  template< typename POLICY,
            typename KERNEL_TYPE >
  static
  real64
  kernelLaunch( localIndex const numElems,
                KERNEL_TYPE const & kernelComponent )
  {
    GEOS_MARK_FUNCTION;
 
    // launch the kernel
    forAll< POLICY >( numElems,
                      [=] ( localIndex const k )
    {
      // allocate the stack variables
      typename KERNEL_TYPE::StackVariables stack;
 
      kernelComponent.setup( k, stack );
 
      kernelComponent.complete( k, stack );
 
    } );
    return 0;
  }
private:
  SparsityPattern< globalIndex > & m_sparsity;
};
 
 
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
template< template< typename,
                    typename,
                    typename > class KERNEL_TEMPLATE >
class SparsityKernelFactory
{
public:
 
  SparsityKernelFactory( arrayView1d< globalIndex const > const & inputDofNumber,
                         globalIndex const rankOffset,
                         SparsityPattern< globalIndex > & inputSparsityPattern ):
    m_inputDofNumber( inputDofNumber ),
    m_rankOffset( rankOffset ),
    m_inputSparsityPattern( inputSparsityPattern )
  {}
 
  template< typename SUBREGION_TYPE, typename CONSTITUTIVE_TYPE, typename FE_TYPE >
  auto createKernel( NodeManager const & nodeManager,
                     EdgeManager const & edgeManager,
                     FaceManager const & faceManager,
                     localIndex const targetRegionIndex,
                     SUBREGION_TYPE const & elementSubRegion,
                     FE_TYPE const & finiteElementSpace,
                     CONSTITUTIVE_TYPE & inputConstitutiveType )
  {
    using Kernel = KERNEL_TEMPLATE< SUBREGION_TYPE, CONSTITUTIVE_TYPE, FE_TYPE >;
 
    return SparsityKernelBase< SUBREGION_TYPE,
                               CONSTITUTIVE_TYPE,
                               FE_TYPE,
                               Kernel::numDofPerTestSupportPoint,
                               Kernel::numDofPerTrialSupportPoint >( nodeManager,
                                                                     edgeManager,
                                                                     faceManager,
                                                                     targetRegionIndex,
                                                                     elementSubRegion,
                                                                     finiteElementSpace,
                                                                     inputConstitutiveType,
                                                                     m_inputDofNumber,
                                                                     m_rankOffset,
                                                                     0.0, //dt but not needed
                                                                     m_inputSparsityPattern );
  }
 
private:
  arrayView1d< globalIndex const > const & m_inputDofNumber;
  globalIndex const m_rankOffset;
  SparsityPattern< globalIndex > & m_inputSparsityPattern;
};
 
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
template< typename REGION_TYPE,
          template< typename SUBREGION_TYPE,
                    typename CONSTITUTIVE_TYPE,
                    typename FE_TYPE > class KERNEL_TEMPLATE >
static
real64 fillSparsity( MeshLevel & mesh,
                     arrayView1d< string const > const & targetRegions,
                     string const & discretizationName,
                     arrayView1d< globalIndex const > const & inputDofNumber,
                     globalIndex const rankOffset,
                     SparsityPattern< globalIndex > & inputSparsityPattern )
{
  GEOS_MARK_FUNCTION;
 
  SparsityKernelFactory< KERNEL_TEMPLATE > KernelFactory( inputDofNumber, rankOffset, inputSparsityPattern );
 
  regionBasedKernelApplication< serialPolicy,
                                constitutive::NullModel,
                                REGION_TYPE >( mesh,
                                               targetRegions,
                                               discretizationName,
                                               string(),
                                               KernelFactory );
 
  return 0;
}
 
}
}
 
 
 
#endif /* GEOS_FINITEELEMENT_SPARSITYKERNELBASE_HPP_ */