ElasticWaveEquationSEM.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 SRC_CORECOMPONENTS_PHYSICSSOLVERS_WAVEPROPAGATION_ELASTICWAVEEQUATIONSEM_HPP_
#define SRC_CORECOMPONENTS_PHYSICSSOLVERS_WAVEPROPAGATION_ELASTICWAVEEQUATIONSEM_HPP_
 
#include "physicsSolvers/wavePropagation/shared/WaveSolverBase.hpp"
#include "mesh/MeshFields.hpp"
#include "physicsSolvers/PhysicsSolverBase.hpp"
#include "physicsSolvers/wavePropagation/sem/elastic/shared/ElasticFields.hpp"
 
namespace geos
{
 
class ElasticWaveEquationSEM : public WaveSolverBase
{
public:
 
  using EXEC_POLICY = parallelDevicePolicy<  >;
  using ATOMIC_POLICY = parallelDeviceAtomic;
 
  ElasticWaveEquationSEM( const std::string & name,
                          Group * const parent );
 
  virtual ~ElasticWaveEquationSEM() override;
 
  ElasticWaveEquationSEM() = delete;
  ElasticWaveEquationSEM( ElasticWaveEquationSEM const & ) = delete;
  ElasticWaveEquationSEM( ElasticWaveEquationSEM && ) = default;
 
  ElasticWaveEquationSEM & operator=( ElasticWaveEquationSEM const & ) = delete;
  ElasticWaveEquationSEM & operator=( ElasticWaveEquationSEM && ) = delete;
 
  static string coupledSolverAttributePrefix() { return "elastic"; }
 
  static string catalogName() { return "ElasticSEM"; }
  string getCatalogName() const override { return catalogName(); }
 
  virtual void initializePreSubGroups() override;
 
  virtual void registerDataOnMesh( Group & meshBodies ) override final;
 
 
  virtual real64 explicitStepForward( real64 const & time_n,
                                      real64 const & dt,
                                      integer const cycleNumber,
                                      DomainPartition & domain,
                                      bool const computeGradient ) override;
 
  virtual real64 explicitStepBackward( real64 const & time_n,
                                       real64 const & dt,
                                       integer const cycleNumber,
                                       DomainPartition & domain,
                                       bool const computeGradient ) override;
  void addSourceToRightHandSide( real64 const & time_n, arrayView1d< real32 > const rhsx, arrayView1d< real32 > const rhsy, arrayView1d< real32 > const rhsz );
 
  void computeDAS( arrayView2d< real32 > const xCompRcv,
                   arrayView2d< real32 > const yCompRcv,
                   arrayView2d< real32 > const zCompRcv );
 
  virtual real64 computeTimeStep( real64 & dtOut ) override;
 
 
  virtual void cleanup( real64 const time_n,
                        integer const cycleNumber,
                        integer const eventCounter,
                        real64 const eventProgress,
                        DomainPartition & domain ) override;
 
  struct viewKeyStruct : WaveSolverBase::viewKeyStruct
  {
    static constexpr char const * displacementXNp1AtReceiversString() { return "displacementXNp1AtReceivers"; }
    static constexpr char const * displacementYNp1AtReceiversString() { return "displacementYNp1AtReceivers"; }
    static constexpr char const * displacementZNp1AtReceiversString() { return "displacementZNp1AtReceivers"; }
 
    static constexpr char const * dasSignalNp1AtReceiversString() { return "dasSignalNp1AtReceivers"; }
 
    static constexpr char const * sourceForceString() { return "sourceForce"; }
    static constexpr char const * sourceMomentString() { return "sourceMoment"; }
 
    static constexpr char const * useVtiString() { return "useVTI"; }
 
  } waveEquationViewKeys;
 
 
  real64 explicitStepInternal( real64 const & time_n,
                               real64 const & dt,
                               DomainPartition & domain );
 
  void computeUnknowns( real64 const & time_n,
                        real64 const & dt,
                        DomainPartition & domain,
                        MeshLevel & mesh,
                        arrayView1d< string const > const & regionNames );
 
  void synchronizeUnknowns( real64 const & time_n,
                            real64 const & dt,
                            DomainPartition & domain,
                            MeshLevel & mesh,
                            arrayView1d< string const > const & regionNames );
 
  void prepareNextTimestep( MeshLevel & mesh );
 
  real32 computeGlobalMinQFactor();
 
protected:
 
  virtual void postInputInitialization() override final;
 
  virtual void initializePostInitialConditionsPreSubGroups() override final;
 
private:
 
  virtual void precomputeSourceAndReceiverTerm( MeshLevel & baseMesh, MeshLevel & mesh, arrayView1d< string const > const & regionNames ) override;
 
  virtual void applyFreeSurfaceBC( real64 const time, DomainPartition & domain ) override;
 
  virtual void initializePML() override;
 
  virtual void applyPML( real64 const time, DomainPartition & domain ) override;
 
  array2d< real64 > m_sourceConstantsx;
 
  array2d< real64 > m_sourceConstantsy;
 
  array2d< real64 > m_sourceConstantsz;
 
  array2d< real32 > m_displacementXNp1AtReceivers;
 
  array2d< real32 > m_displacementYNp1AtReceivers;
 
  array2d< real32 > m_displacementZNp1AtReceivers;
 
  array2d< real32 > m_dasSignalNp1AtReceivers;
 
  R1Tensor m_sourceForce;
 
  R2SymTensor m_sourceMoment;
 
  integer m_useVTI;
 
};
 
} /* namespace geos */
 
#endif /* SRC_CORECOMPONENTS_PHYSICSSOLVERS_WAVEPROPAGATION_ELASSTICWAVEEQUATIONSEM_HPP_ */