ImplicitSmallStrainNewmark.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_PHYSICSSOLVERS_SOLIDMECHANICS_KERNELS_IMPLCITSMALLSTRAINNEWMARK_HPP_
#define GEOS_PHYSICSSOLVERS_SOLIDMECHANICS_KERNELS_IMPLCITSMALLSTRAINNEWMARK_HPP_
 
#include "ImplicitSmallStrainQuasiStatic.hpp"
 
 
namespace geos
{
 
namespace solidMechanicsLagrangianFEMKernels
{
 
template< typename SUBREGION_TYPE,
          typename CONSTITUTIVE_TYPE,
          typename FE_TYPE >
class ImplicitSmallStrainNewmark : public ImplicitSmallStrainQuasiStatic< SUBREGION_TYPE,
                                                                          CONSTITUTIVE_TYPE,
                                                                          FE_TYPE >
{
public:
  using Base = ImplicitSmallStrainQuasiStatic< SUBREGION_TYPE,
                                               CONSTITUTIVE_TYPE,
                                               FE_TYPE >;
 
  using Base::numNodesPerElem;
  using Base::maxNumTestSupportPointsPerElem;
  using Base::maxNumTrialSupportPointsPerElem;
  using Base::numDofPerTestSupportPoint;
  using Base::numDofPerTrialSupportPoint;
 
  using Base::m_dofNumber;
  using Base::m_matrix;
  using Base::m_rhs;
  using Base::m_elemsToNodes;
  using Base::m_disp;
  using Base::m_uhat;
  using Base::m_density;
  using Base::m_finiteElementSpace;
  using Base::m_dt;
 
#if !defined(CALCFEMSHAPE)
  using Base::m_X;
#endif
  using Base::m_gravityVector;
 
  ImplicitSmallStrainNewmark( 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],
                              real64 const inputNewmarkGamma,
                              real64 const inputNewmarkBeta,
                              real64 const inputMassDamping,
                              real64 const inputStiffnessDamping );
 
  //***************************************************************************
  struct StackVariables : public Base::StackVariables
  {
public:
    using Base::StackVariables::maxNumRows;
    using Base::StackVariables::maxNumCols;
 
    GEOS_HOST_DEVICE
    StackVariables():
      Base::StackVariables(),
            dRdU_InertiaMassDamping{ {0.0} },
      vtilde_local(),
      uhattilde_local()
    {}
 
    real64 dRdU_InertiaMassDamping[ maxNumRows ][ maxNumCols ];
 
    real64 vtilde_local[numNodesPerElem][numDofPerTrialSupportPoint];
 
    real64 uhattilde_local[numNodesPerElem][numDofPerTrialSupportPoint];
  };
  //***************************************************************************
 
  GEOS_HOST_DEVICE
  void setup( localIndex const k,
              StackVariables & stack ) const;
 
  GEOS_HOST_DEVICE
  void quadraturePointKernel( localIndex const k,
                              localIndex const q,
                              StackVariables & stack ) const;
 
  GEOS_HOST_DEVICE
  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::TOTAL_DISPLACEMENT_USD > const m_vtilde;
 
  arrayView2d< real64 const, nodes::INCR_DISPLACEMENT_USD > const m_uhattilde;
 
  real64 const m_newmarkGamma;
 
  real64 const m_newmarkBeta;
 
  real64 const m_massDamping;
 
  real64 const m_stiffnessDamping;
 
 
};
 
using ImplicitNewmarkFactory = finiteElement::KernelFactory< ImplicitSmallStrainNewmark,
                                                             arrayView1d< globalIndex const > const &,
                                                             globalIndex,
                                                             CRSMatrixView< real64, globalIndex const > const,
                                                             arrayView1d< real64 > const,
                                                             real64 const,
                                                             real64 const (&)[3],
                                                             real64,
                                                             real64,
                                                             real64,
                                                             real64 >;
 
} // namespace solidMechanicsLagrangianFEMKernels
 
} // namespace geos
 
#include "finiteElement/kernelInterface/SparsityKernelBase.hpp"
 
#endif //GEOS_PHYSICSSOLVERS_SOLIDMECHANICS_KERNELS_IMPLCITSMALLSTRAINNEWMARK_HPP_