FiniteElementBase.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_FINITEELEMENT_ELEMENTFORMULATIONS_FINITEELEMENTBASE_HPP_
#define GEOS_FINITEELEMENT_ELEMENTFORMULATIONS_FINITEELEMENTBASE_HPP_
 
#include "common/DataTypes.hpp"
#include "common/GeosxMacros.hpp"
#include "finiteElement/PDEUtilities.hpp"
#include "LvArray/src/tensorOps.hpp"
#include "mesh/NodeManager.hpp"
#include "mesh/EdgeManager.hpp"
#include "mesh/FaceManager.hpp"
 
namespace geos
{
namespace finiteElement
{
 
template< int NUM_SUPPORT_POINTS,
          int NUM_FACES,
          int NUM_QUADRATURE_POINTS >
class FiniteElementBase_impl
{
public:
 
  constexpr static localIndex numNodes = NUM_SUPPORT_POINTS;
 
  constexpr static localIndex numSupportPoints = NUM_SUPPORT_POINTS;
 
  constexpr static localIndex maxSupportPoints = numSupportPoints;
 
  constexpr static localIndex numFaces = NUM_FACES;
 
  constexpr static localIndex numQuadraturePoints = NUM_QUADRATURE_POINTS;
 
  constexpr static int numSamplingPointsPerDirection = 10;
 
  constexpr static int numSamplingPoints = numSamplingPointsPerDirection * numSamplingPointsPerDirection * numSamplingPointsPerDirection;
 
#ifdef __CUDACC__
  #pragma diag_push
  #pragma nv_diag_suppress 20012
#endif
  GEOS_HOST_DEVICE FiniteElementBase_impl() = default;
  GEOS_HOST_DEVICE ~FiniteElementBase_impl() = default;
  GEOS_HOST_DEVICE FiniteElementBase_impl( FiniteElementBase_impl const & ) = default;
  GEOS_HOST_DEVICE FiniteElementBase_impl & operator=( FiniteElementBase_impl const & ) = default;
  GEOS_HOST_DEVICE FiniteElementBase_impl( FiniteElementBase_impl && ) = default;
  GEOS_HOST_DEVICE FiniteElementBase_impl & operator=( FiniteElementBase_impl && ) = default;
#ifdef __CUDACC__
  #pragma diag_pop
#endif
 
  struct StackVariables
  {};
 
  template< typename SUBREGION_TYPE >
  struct MeshData
  {};
 
  GEOS_HOST_DEVICE
  static localIndex getNumQuadraturePoints()
  {
    return numQuadraturePoints;
  }
 
  template< typename STACK_VARIABLES_TYPE >
  GEOS_HOST_DEVICE
  static localIndex getNumQuadraturePoints( STACK_VARIABLES_TYPE const & stack )
  {
    GEOS_UNUSED_VAR( stack );
    return numQuadraturePoints;
  }
 
  GEOS_HOST_DEVICE
  static localIndex getNumSupportPoints()
  {
    return numNodes;
  }
 
  template< typename STACK_VARIABLES_TYPE >
  GEOS_HOST_DEVICE
  static localIndex getNumSupportPoints( STACK_VARIABLES_TYPE const & stack )
  {
    GEOS_UNUSED_VAR( stack );
    return numNodes;
  }
 
  GEOS_HOST_DEVICE
  static localIndex getMaxSupportPoints()
  {
    return maxSupportPoints;
  }
 
  GEOS_HOST_DEVICE
  GEOS_FORCE_INLINE
  static void getSamplingPointCoordInParentSpace( int const & linearIndex,
                                                  real64 (& samplingPointCoord)[3] )
  {
    GEOS_UNUSED_VAR( linearIndex, samplingPointCoord );
    GEOS_ERROR( " Element type not supported." );
  }
 
 
 
  template< typename SUBREGION_TYPE,
            typename MESH_DATA_TYPE >
  static void fillMeshData( NodeManager const & nodeManager,
                            EdgeManager const & edgeManager,
                            FaceManager const & faceManager,
                            SUBREGION_TYPE const & cellSubRegion,
                            MESH_DATA_TYPE & meshData )
  {
    GEOS_UNUSED_VAR( nodeManager,
                     edgeManager,
                     faceManager,
                     cellSubRegion,
                     meshData );
  }
 
  template< typename LEAF,
            typename SUBREGION_TYPE,
            typename MESH_DATA_TYPE >
  static void initialize( NodeManager const & nodeManager,
                          EdgeManager const & edgeManager,
                          FaceManager const & faceManager,
                          SUBREGION_TYPE const & cellSubRegion,
                          MESH_DATA_TYPE & meshData
                          )
  {
    LEAF::template fillMeshData< SUBREGION_TYPE >( nodeManager,
                                                   edgeManager,
                                                   faceManager,
                                                   cellSubRegion,
                                                   meshData );
  }
 
 
  template< typename MESH_DATA_TYPE,
            typename STACK_VARIABLES_TYPE >
  GEOS_HOST_DEVICE
  GEOS_FORCE_INLINE
  static void setupStack( localIndex const & cellIndex,
                          MESH_DATA_TYPE const & meshData,
                          STACK_VARIABLES_TYPE & stack )
  {
    GEOS_UNUSED_VAR( cellIndex,
                     meshData,
                     stack );
 
  }
 
 
  template< typename LEAF,
            typename MESH_DATA_TYPE >
  GEOS_HOST_DEVICE
  void setup( localIndex const & cellIndex,
              MESH_DATA_TYPE const & meshData,
              typename LEAF::StackVariables & stack ) const
  {
    LEAF::setupStack( cellIndex, meshData, stack );
  }
 
 
  template< int N >
  GEOS_HOST_DEVICE
  constexpr static PDEUtilities::FunctionSpace getFunctionSpace()
  {
    if constexpr ( N == 1 )
    {
      return PDEUtilities::FunctionSpace::H1;
    }
    else if constexpr ( N == 3 )
    {
      return PDEUtilities::FunctionSpace::H1vector;
    }
    else
    {
      static_assert( N == 1 || N == 3, "Unsupported number of components per support point" );
    }
  }
 
 
 
  template< localIndex NUMDOFSPERTRIALSUPPORTPOINT,
            localIndex MAXSUPPORTPOINTS,
            bool UPPER,
            typename STACK_VARIABLES_TYPE >
  GEOS_HOST_DEVICE
  GEOS_FORCE_INLINE
  static void addGradGradStabilization( STACK_VARIABLES_TYPE const & stack,
                                        real64 ( & matrix )[MAXSUPPORTPOINTS * NUMDOFSPERTRIALSUPPORTPOINT][MAXSUPPORTPOINTS * NUMDOFSPERTRIALSUPPORTPOINT],
                                        real64 const & scaleFactor )
  {
    GEOS_UNUSED_VAR( stack,
                     matrix,
                     scaleFactor );
  }
 
 
 
  template< typename LEAF, localIndex NUMDOFSPERTRIALSUPPORTPOINT, bool UPPER = false >
  GEOS_HOST_DEVICE
  void addGradGradStabilizationMatrix( typename LEAF::StackVariables const & stack,
                                       real64 ( & matrix )[LEAF::maxSupportPoints * NUMDOFSPERTRIALSUPPORTPOINT][LEAF::maxSupportPoints * NUMDOFSPERTRIALSUPPORTPOINT],
                                       real64 const scaleFactor = 1.0 ) const
  {
    LEAF::template addGradGradStabilization< NUMDOFSPERTRIALSUPPORTPOINT,
                                             LEAF::maxSupportPoints,
                                             UPPER >( stack,
                                                      matrix,
                                                      scaleFactor );
  }
 
  template< localIndex NUMDOFSPERTRIALSUPPORTPOINT,
            localIndex MAXSUPPORTPOINTS,
            typename STACK_VARIABLES_TYPE >
  GEOS_HOST_DEVICE
  GEOS_FORCE_INLINE
  static void addEvaluatedGradGradStabilization( STACK_VARIABLES_TYPE const & stack,
                                                 real64 const ( &dofs )[MAXSUPPORTPOINTS][NUMDOFSPERTRIALSUPPORTPOINT],
                                                 real64 ( & targetVector )[MAXSUPPORTPOINTS][NUMDOFSPERTRIALSUPPORTPOINT],
                                                 real64 const scaleFactor )
  {
    GEOS_UNUSED_VAR( stack );
    GEOS_UNUSED_VAR( dofs );
    GEOS_UNUSED_VAR( targetVector );
    GEOS_UNUSED_VAR( scaleFactor );
  }
 
  template< typename LEAF, localIndex NUMDOFSPERTRIALSUPPORTPOINT >
  GEOS_HOST_DEVICE
  GEOS_FORCE_INLINE
  void
  addEvaluatedGradGradStabilizationVector( typename LEAF::StackVariables const & stack,
                                           real64 const ( &dofs )[LEAF::maxSupportPoints]
                                           [NUMDOFSPERTRIALSUPPORTPOINT],
                                           real64 ( & targetVector )[LEAF::maxSupportPoints]
                                           [NUMDOFSPERTRIALSUPPORTPOINT],
                                           real64 const scaleFactor = 1.0 ) const
  {
    LEAF::template
    addEvaluatedGradGradStabilization< NUMDOFSPERTRIALSUPPORTPOINT, LEAF::maxSupportPoints >( stack,
                                                                                              dofs,
                                                                                              targetVector,
                                                                                              scaleFactor );
  }
 
 
};
 
 
class FiniteElementBase
{
public:
 
  FiniteElementBase( localIndex const numSupportPoints,
                     localIndex const maxSupportPoints,
                     localIndex const numQuadraturePoints ):
    m_numSupportPoints( numSupportPoints ),
    m_maxSupportPoints( maxSupportPoints ),
    m_numQuadraturePoints( numQuadraturePoints )
  { }
 
  virtual ~FiniteElementBase() = default;
 
  localIndex getNumQuadraturePoints() const
  {
    return m_numQuadraturePoints;
  }
 
  localIndex getNumSupportPoints() const { return m_numSupportPoints; };
 
  localIndex getMaxSupportPoints() const { return m_maxSupportPoints; };
 
private:
  localIndex const m_numSupportPoints;
  localIndex const m_maxSupportPoints;
  localIndex const m_numQuadraturePoints;
};
 
} // namespace geos::finiteElement
} // namespace geos
 
#endif //GEOS_FINITEELEMENT_ELEMENTFORMULATIONS_FINITEELEMENTBASE_HPP_