AcousticWaveEquationDG.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 TotalEnergies
 * Copyright (c) 2019-     GEOS Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
 
#ifndef GEOS_PHYSICSSOLVERS_WAVEPROPAGATION_ACOUSTICWAVEEQUATIONDG_HPP_
#define GEOS_PHYSICSSOLVERS_WAVEPROPAGATION_ACOUSTICWAVEEQUATIONDG_HPP_
 
#include "mesh/MeshFields.hpp"
#include "physicsSolvers/PhysicsSolverBase.hpp"
#include "physicsSolvers/wavePropagation/shared/WaveSolverBase.hpp"
#include "physicsSolvers/wavePropagation/dg/acoustic/shared/AcousticFieldsDG.hpp"
#include "physicsSolvers/wavePropagation/shared/WaveSolverTypeDefDG.hpp"
 
namespace geos
{
 
class AcousticWaveEquationDG : public WaveSolverBase
{
public:
 
  using EXEC_POLICY = parallelDevicePolicy< 32 >;
  using ATOMIC_POLICY = AtomicPolicy< EXEC_POLICY >;
 
  AcousticWaveEquationDG( const std::string & name,
                          Group * const parent );
 
  virtual ~AcousticWaveEquationDG() override;
 
  AcousticWaveEquationDG() = delete;
  AcousticWaveEquationDG( AcousticWaveEquationDG const & ) = delete;
  AcousticWaveEquationDG( AcousticWaveEquationDG && ) = default;
 
  AcousticWaveEquationDG & operator=( AcousticWaveEquationDG const & ) = delete;
  AcousticWaveEquationDG & operator=( AcousticWaveEquationDG && ) = delete;
 
 
  static string catalogName() { return "AcousticDG"; }
 
  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,
                                      integer const computeGradient ) override;
 
  virtual real64 explicitStepBackward( real64 const & time_n,
                                       real64 const & dt,
                                       integer const cycleNumber,
                                       DomainPartition & domain,
                                       integer const computeGradient ) override;
 
 
 
  virtual real32 getGlobalMinWavespeed( MeshLevel & mesh, string_array const & regionNames ) override;
 
 
  virtual void initializePML() override;
 
  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 * pressureNp1AtReceiversString() { return "pressureNp1AtReceivers"; }
 
    static constexpr char const * sourceElemString() { return "sourceElem"; }
    static constexpr char const * sourceRegionString() { return "sourceRegion"; }
    static constexpr char const * receiverElemString() { return "receiverElem"; }
 
  } waveEquationViewKeys;
 
 
  real64 explicitStepInternal( real64 const & time_n,
                               real64 const & dt,
                               integer const cycleNumber,
                               DomainPartition & domain );
 
  void computeUnknowns( real64 const & time_n,
                        real64 const & dt,
                        DomainPartition & domain,
                        MeshLevel & mesh,
                        string_array const & regionNames );
 
  void synchronizeUnknowns( real64 const & time_n,
                            real64 const & dt,
                            DomainPartition & domain,
                            MeshLevel & mesh,
                            string_array const & regionNames );
 
  void prepareNextTimestep( MeshLevel & mesh );
 
  void updatePressure( localIndex const size, localIndex const numNodesPerElem, arrayView2d< real32 > const p_nm1, arrayView2d< real32 > const p_n, arrayView2d< real32 >  p_np1 );
 
protected:
 
  virtual void postInputInitialization() override final;
 
  //Nothing to do inside ? (no global mass or damping)
  virtual void initializePostInitialConditionsPreSubGroups() override final;
 
private:
 
  virtual void precomputeSourceAndReceiverTerm( MeshLevel & baseMesh, MeshLevel & mesh, string_array const & regionNames ) override;
 
  virtual void applyFreeSurfaceBC( real64 const time, DomainPartition & domain ) override;
 
  virtual void applyPML( real64 const time, DomainPartition & domain ) override;
 
  array2d< real32 > m_pressureNp1AtReceivers;
 
  array1d< localIndex > m_sourceElem;
 
  array1d< localIndex > m_sourceRegion;
 
  ArrayOfArrays< array2d< real64 > > m_referenceInvMassMatrix;
 
  ArrayOfArrays< array3d< real64 > > m_boundaryInvMassPlusDamping;
 
};
 
} /* namespace geos */
 
#endif /* GEOS_PHYSICSSOLVERS_WAVEPROPAGATION_ACOUSTICWAVEEQUATIONDG_HPP_ */