MeshLevel.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_MESH_MESHLEVEL_HPP_
#define GEOS_MESH_MESHLEVEL_HPP_
 
#include "NodeManager.hpp"
#include "ParticleManager.hpp"
#include "EmbeddedSurfaceNodeManager.hpp"
#include "EdgeManager.hpp"
#include "ElementRegionManager.hpp"
#include "FaceManager.hpp"
 
namespace geos
{
class ElementRegionManager;
 
class MeshLevel : public dataRepository::Group
{
public:
 
  MeshLevel( string const & name,
             Group * const parent );
 
 
  MeshLevel( string const & name,
             Group * const parent,
             MeshLevel & source );
 
 
  MeshLevel( string const & name,
             Group * const parent,
             MeshLevel const & source,
             int const order );
 
  virtual ~MeshLevel() override;
 
  void generateSets();
 
 
  void generateAdjacencyLists( arrayView1d< localIndex const > const & seedNodeList,
                               localIndex_array & nodeAdjacencyList,
                               localIndex_array & edgeAdjacencyList,
                               localIndex_array & faceAdjacencyList,
                               ElementRegionManager::ElementViewAccessor< ReferenceWrapper< localIndex_array > > & elementAdjacencyList,
                               integer const depth );
 
 
  virtual void initializePostInitialConditionsPostSubGroups() override;
 
 
 
  struct viewStructKeys
  {
    dataRepository::ViewKey meshLevel                = { "meshLevel" };
//    static constexpr char const *  baseDiscretizationString() { return "baseDiscretization"; }
 
  } viewKeys;
 
  struct groupStructKeys
  {
    dataRepository::GroupKey vertexManager  = { "vertexManager" };
    dataRepository::GroupKey cellManager    = { "cellManager" };
 
    static constexpr char const * nodeManagerString() { return "nodeManager"; }
    static constexpr char const * edgeManagerString() { return "edgeManager"; }
    static constexpr char const * faceManagerString() { return "faceManager"; }
 
    // This key is defined in problem manager:
    static constexpr char const * elemManagerString() { return "ElementRegions"; }
    static constexpr char const * particleManagerString() { return "ParticleRegions"; }
 
    static constexpr auto embSurfNodeManagerString = "embeddedSurfacesNodeManager";
    static constexpr auto embSurfEdgeManagerString = "embeddedSurfacesEdgeManager";
 
    dataRepository::GroupKey nodeManager = {nodeManagerString()};
    dataRepository::GroupKey particleManager = {particleManagerString()};
    dataRepository::GroupKey edgeManager = {edgeManagerString()};
    dataRepository::GroupKey faceManager = {faceManagerString()};
    dataRepository::GroupKey elemManager = {elemManagerString()};
    dataRepository::GroupKey embSurfNodeManager = {embSurfNodeManagerString};
    dataRepository::GroupKey embSurfEdgeManager = {embSurfEdgeManagerString};
  } groupKeys;
 
 
 
  NodeManager const & getNodeManager() const
  { return *m_nodeManager; }
 
  NodeManager & getNodeManager()
  { return *m_nodeManager; }
 
  ParticleManager const & getParticleManager() const
  { return *m_particleManager; }
 
  ParticleManager & getParticleManager()
  { return *m_particleManager; }
 
  EdgeManager const & getEdgeManager() const
  { return *m_edgeManager; }
 
  EdgeManager & getEdgeManager()
  { return *m_edgeManager; }
 
  FaceManager const & getFaceManager() const
  { return *m_faceManager; }
 
  FaceManager & getFaceManager()
  { return *m_faceManager; }
 
  ElementRegionManager const & getElemManager() const
  { return *m_elementManager; }
 
  ElementRegionManager & getElemManager()
  { return *m_elementManager; }
 
  EmbeddedSurfaceNodeManager const & getEmbSurfNodeManager() const
  { return *m_embSurfNodeManager; }
 
  EmbeddedSurfaceNodeManager & getEmbSurfNodeManager()
  { return *m_embSurfNodeManager; }
 
  EdgeManager const & getEmbSurfEdgeManager() const
  { return *m_embSurfEdgeManager; }
 
  EdgeManager & getEmbSurfEdgeManager()
  { return *m_embSurfEdgeManager; }
 
  Timestamp getModificationTimestamp() const
  { return m_modificationTimestamp; }
 
  void modified()
  { m_modificationTimestamp++; }
 
  bool isShallowCopy() const
  { return m_isShallowCopy; }
 
  bool isShallowCopyOf( MeshLevel const & comparisonLevel ) const;
 
 
  MeshLevel const & getShallowParent() const;
 
  MeshLevel & getShallowParent();
 
 
private:
 
  NodeManager * const m_nodeManager;
  ParticleManager * const m_particleManager;
  EdgeManager * const m_edgeManager;
  FaceManager * const m_faceManager;
  ElementRegionManager * const m_elementManager;
 
  EmbeddedSurfaceNodeManager * const m_embSurfNodeManager;
  EdgeManager * const m_embSurfEdgeManager;
 
  Timestamp m_modificationTimestamp;
 
  bool const m_isShallowCopy = false;
 
  MeshLevel * const m_shallowParent;
 
};
 
} /* namespace geos */
 
#endif /* GEOS_MESH_MESHLEVEL_HPP_ */