ImplicitKernelBase.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 "KernelBase.hpp"

#ifndef GEOSX_FINITEELEMENT_IMPLICITKERNELBASE_HPP_
#define GEOSX_FINITEELEMENT_IMPLICITKERNELBASE_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 ImplicitKernelBase : public KernelBase< SUBREGION_TYPE,
                                              CONSTITUTIVE_TYPE,
                                              FE_TYPE,
                                              NUM_DOF_PER_TEST_SP,
                                              NUM_DOF_PER_TRIAL_SP >
{
public:
  using Base = KernelBase< SUBREGION_TYPE,
                           CONSTITUTIVE_TYPE,
                           FE_TYPE,
                           NUM_DOF_PER_TEST_SP,
                           NUM_DOF_PER_TRIAL_SP >;

  using Base::numTestSupportPointsPerElem;
  using Base::numTrialSupportPointsPerElem;
  using Base::numDofPerTestSupportPoint;
  using Base::numDofPerTrialSupportPoint;
  using Base::m_elemsToNodes;


  ImplicitKernelBase( 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,
                      CRSMatrixView< real64, globalIndex const > const & inputMatrix,
                      arrayView1d< real64 > const & inputRhs ):
    Base( elementSubRegion,
          finiteElementSpace,
          inputConstitutiveType ),
    m_dofNumber( inputDofNumber ),
    m_dofRankOffset( rankOffset ),
    m_matrix( inputMatrix ),
    m_rhs( inputRhs )
  {
    GEOSX_UNUSED_VAR( nodeManager );
    GEOSX_UNUSED_VAR( edgeManager );
    GEOSX_UNUSED_VAR( faceManager );
  }


  //***************************************************************************
  struct StackVariables : public Base::StackVariables
  {
    static constexpr int numRows = numTestSupportPointsPerElem *numDofPerTestSupportPoint;

    static constexpr int numCols = numTrialSupportPointsPerElem *numDofPerTrialSupportPoint;

    GEOSX_HOST_DEVICE
    StackVariables():
      localRowDofIndex{ 0 },
      localColDofIndex{ 0 },
      localResidual{ 0.0 },
      localJacobian{ {0.0} }
    {}

    globalIndex localRowDofIndex[numRows];

    globalIndex localColDofIndex[numCols];

    real64 localResidual[numRows];

    real64 localJacobian[numRows][numCols];
  };
  //***************************************************************************

  GEOSX_HOST_DEVICE
  GEOSX_FORCE_INLINE
  void setup( localIndex const k,
              StackVariables & stack ) const
  {
    for( localIndex a=0; a<numTestSupportPointsPerElem; ++a )
    {
      localIndex const localNodeIndex = m_elemsToNodes[k][a];
      for( int i=0; i<numDofPerTestSupportPoint; ++i )
      {
        stack.localRowDofIndex[a*numDofPerTestSupportPoint+i] = m_dofNumber[localNodeIndex]+i;
      }
    }

    for( localIndex a=0; a<numTrialSupportPointsPerElem; ++a )
    {
      localIndex const localNodeIndex = m_elemsToNodes[k][a];
      for( int i=0; i<numDofPerTrialSupportPoint; ++i )
      {
        stack.localColDofIndex[a*numDofPerTrialSupportPoint+i] = m_dofNumber[localNodeIndex]+i;
      }
    }
  }


protected:
  arrayView1d< globalIndex const > const m_dofNumber;

  globalIndex const m_dofRankOffset;

  CRSMatrixView< real64, globalIndex const > const m_matrix;

  arrayView1d< real64 > const m_rhs;

};

}
}



#endif /* GEOSX_FINITEELEMENT_IMPLICITKERNELBASE_HPP_ */