SparsityKernelBase.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.
 * ------------------------------------------------------------------------------------------------------------
 */

#include "ImplicitKernelBase.hpp"

#ifndef GEOSX_FINITEELEMENT_SPARSITYKERNELBASE_HPP_
#define GEOSX_FINITEELEMENT_SPARSITYKERNELBASE_HPP_



namespace geosx
{

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::setup;

  SparsityKernelBase( NodeManager const & nodeManager,
                      EdgeManager const & edgeManager,
                      FaceManager const & faceManager,
                      SUBREGION_TYPE const & elementSubRegion,
                      FE_TYPE const & finiteElementSpace,
                      CONSTITUTIVE_TYPE * const inputConstitutiveType,
                      arrayView1d< globalIndex const > const & inputDofNumber,
                      globalIndex const rankOffset,
                      SparsityPattern< globalIndex > & inputSparsity ):
    Base( nodeManager,
          edgeManager,
          faceManager,
          elementSubRegion,
          finiteElementSpace,
          inputConstitutiveType,
          inputDofNumber,
          rankOffset,
          CRSMatrixView< real64, globalIndex const >(),
          arrayView1d< real64 >() ),
    m_sparsity( inputSparsity )
  {}


  GEOSX_FORCE_INLINE
  real64 complete( localIndex const k,
                   StackVariables & stack ) const
  {
    GEOSX_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 )
  {
    GEOSX_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 >
struct SparsityHelper
{

  template< typename SUBREGION_TYPE,
            typename CONSTITUTIVE_TYPE,
            typename FE_TYPE >
  using Kernel = SparsityKernelBase< SUBREGION_TYPE,
                                     CONSTITUTIVE_TYPE,
                                     FE_TYPE,
                                     KERNEL_TEMPLATE< SUBREGION_TYPE,
                                                      CONSTITUTIVE_TYPE,
                                                      FE_TYPE >::numDofPerTestSupportPoint,
                                     KERNEL_TEMPLATE< SUBREGION_TYPE,
                                                      CONSTITUTIVE_TYPE,
                                                      FE_TYPE >::numDofPerTrialSupportPoint
                                     >;
};


//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
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 )
{
  GEOSX_MARK_FUNCTION;
  regionBasedKernelApplication< serialPolicy,
                                constitutive::NullModel,
                                REGION_TYPE,
                                SparsityHelper< KERNEL_TEMPLATE >::template Kernel
                                >( mesh,
                                   targetRegions,
                                   discretizationName,
                                   arrayView1d< string const >(),
                                   inputDofNumber,
                                   rankOffset,
                                   inputSparsityPattern );

  return 0;
}

}
}



#endif /* GEOSX_FINITEELEMENT_SPARSITYKERNELBASE_HPP_ */