ImplicitSmallStrainQuasiStatic.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_PHYSICSSOLVERS_SOLIDMECHANICS_KERNELS_IMPLCITSMALLSTRAINQUASISTATIC_HPP_
#define GEOS_PHYSICSSOLVERS_SOLIDMECHANICS_KERNELS_IMPLCITSMALLSTRAINQUASISTATIC_HPP_
 
#include "finiteElement/kernelInterface/ImplicitKernelBase.hpp"
#include "physicsSolvers/solidMechanics/SolidMechanicsFields.hpp"
 
namespace geos
{
 
namespace solidMechanicsLagrangianFEMKernels
{
 
template< typename SUBREGION_TYPE,
          typename CONSTITUTIVE_TYPE,
          typename FE_TYPE >
class ImplicitSmallStrainQuasiStatic :
  public finiteElement::ImplicitKernelBase< SUBREGION_TYPE,
                                            CONSTITUTIVE_TYPE,
                                            FE_TYPE,
                                            3,
                                            3 >
{
public:
  using Base = finiteElement::ImplicitKernelBase< SUBREGION_TYPE,
                                                  CONSTITUTIVE_TYPE,
                                                  FE_TYPE,
                                                  3,
                                                  3 >;
 
  static constexpr int numNodesPerElem = Base::maxNumTestSupportPointsPerElem;
  using Base::numDofPerTestSupportPoint;
  using Base::numDofPerTrialSupportPoint;
  using Base::m_dofNumber;
  using Base::m_dofRankOffset;
  using Base::m_matrix;
  using Base::m_rhs;
  using Base::m_elemsToNodes;
  using Base::m_constitutiveUpdate;
  using Base::m_finiteElementSpace;
  using Base::m_meshData;
  using Base::m_dt;
 
  ImplicitSmallStrainQuasiStatic( 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,
                                  CRSMatrixView< real64, globalIndex const > const inputMatrix,
                                  arrayView1d< real64 > const inputRhs,
                                  real64 const inputDt,
                                  real64 const (&inputGravityVector)[3] );
 
  //*****************************************************************************
  struct StackVariables : public Base::StackVariables
  {
public:
 
    GEOS_HOST_DEVICE
    StackVariables():
      Base::StackVariables(),
                                       xLocal(),
                                       u_local(),
                                       uhat_local(),
                                       constitutiveStiffness()
    {}
 
#if !defined(CALC_FEM_SHAPE_IN_KERNEL)
    int xLocal;
#else
    real64 xLocal[ numNodesPerElem ][ 3 ];
#endif
 
    real64 u_local[numNodesPerElem][numDofPerTrialSupportPoint];
 
    real64 uhat_local[numNodesPerElem][numDofPerTrialSupportPoint];
 
    real64 constitutiveStiffness[ 6 ][ 6 ];
  };
  //*****************************************************************************
 
  GEOS_HOST_DEVICE
  void setup( localIndex const k,
              StackVariables & stack ) const;
 
 
  struct NoOpFunctors
  {
    GEOS_HOST_DEVICE inline constexpr
    void operator() ( localIndex const a, localIndex const b )
    {
      GEOS_UNUSED_VAR( a );
      GEOS_UNUSED_VAR( b );
    }
 
    GEOS_HOST_DEVICE inline constexpr
    void operator() ( real64 (& stress)[6] )
    {
      GEOS_UNUSED_VAR( stress );
    }
  };
 
  template< typename STRESS_MODIFIER = NoOpFunctors >
  GEOS_HOST_DEVICE
  void quadraturePointKernel( localIndex const k,
                              localIndex const q,
                              StackVariables & stack,
                              STRESS_MODIFIER && stressModifier = NoOpFunctors{} ) const;
 
  GEOS_HOST_DEVICE
  inline
  real64 complete( localIndex const k,
                   StackVariables & stack ) const;
 
  template< typename POLICY,
            typename KERNEL_TYPE >
  static real64
  kernelLaunch( localIndex const numElems,
                KERNEL_TYPE const & kernelComponent );
 
protected:
  arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const m_X;
 
  arrayView2d< real64 const, nodes::TOTAL_DISPLACEMENT_USD > const m_disp;
 
  arrayView2d< real64 const, nodes::INCR_DISPLACEMENT_USD > const m_uhat;
 
  real64 const m_gravityVector[3];
 
  arrayView2d< real64 const > const m_density;
 
  GEOS_HOST_DEVICE
  inline
  real64 computeStabilizationScaling( localIndex const k ) const
  {
    // TODO: generalize this to other constitutive models (currently we assume linear elasticity).
    return 2.0 * m_constitutiveUpdate.getShearModulus( k );
  }
};
 
using QuasiStaticFactory = finiteElement::KernelFactory< ImplicitSmallStrainQuasiStatic,
                                                         arrayView1d< globalIndex const > const,
                                                         globalIndex,
                                                         CRSMatrixView< real64, globalIndex const > const,
                                                         arrayView1d< real64 > const,
                                                         real64 const,
                                                         real64 const (&)[3] >;
 
} // namespace solidMechanicsLagrangianFEMKernels
 
} // namespace geos
 
#include "finiteElement/kernelInterface/SparsityKernelBase.hpp"
 
#endif // GEOS_PHYSICSSOLVERS_SOLIDMECHANICS_KERNELS_IMPLCITSMALLSTRAINQUASISTATIC_HPP_