WellElementSubRegion.hpp

/*
 * ------------------------------------------------------------------------------------------------------------
 * 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_MESH_WELLELEMENTSUBREGION_HPP_
#define GEOS_MESH_WELLELEMENTSUBREGION_HPP_
 
#include "mesh/ElementSubRegionBase.hpp"
#include "mesh/InterObjectRelation.hpp"
#include "mesh/PerforationData.hpp"
#include "mesh/generators/LineBlockABC.hpp"
 
namespace geos
{
 
class WellElementSubRegion : public ElementSubRegionBase
{
public:
 
  using NodeMapType = InterObjectRelation< array2d< localIndex, cells::NODE_MAP_PERMUTATION > >;
  using EdgeMapType = FixedOneToManyRelation; // unused but needed in MeshLevel::generateAdjacencyLists
  using FaceMapType = FixedOneToManyRelation; // unused but needed in MeshLevel::generateAdjacencyLists
 
  enum WellElemParallelStatus : unsigned
  {
    UNOWNED = 0,             // there are no perforations on this mesh partition
    REMOTE = 1,              // all perforations are remote
    LOCAL  = 2,              // all perforations are local
    SHARED = REMOTE | LOCAL  // both remote and local perforations
  };
 
  enum WellElemStatus : unsigned
  {
    CLOSED = 0,            //  no flow in element
    OPEN = 1
  };
 
 
  WellElementSubRegion( string const & name,
                        Group * const parent );
 
 
 
  static string catalogName() { return "wellElementSubRegion"; }
 
  virtual string getCatalogName() const override { return catalogName(); }
 
 
 
  virtual void calculateElementGeometricQuantities( NodeManager const &,
                                                    FaceManager const & ) override
  {}
 
  virtual void setupRelatedObjectsInRelations( MeshLevel const & mesh ) override;
 
 
 
  NodeMapType & nodeList()
  {
    return m_toNodesRelation;
  }
 
  NodeMapType const & nodeList() const
  {
    return m_toNodesRelation;
  }
 
  localIndex getTopWellElementIndex() const
  {
    return m_topWellElementIndex;
  }
 
  arrayView1d< globalIndex const >  getGlobalWellElementIndex() const
  {
    return m_globalWellElementIndex;
  }
  void setWellControlsName( string const & name )
  {
    m_wellControlsName = name;
  }
 
  string const & getWellControlsName() const
  {
    return m_wellControlsName;
  }
 
  PerforationData * getPerforationData()
  {
    return &m_perforationData;
  }
 
  PerforationData const * getPerforationData() const
  {
    return &m_perforationData;
  }
 
  array1d< integer > & getWellLocalElementStatus()
  {
    return m_wellLocalElementStatus;
  }
 
  array1d< integer > const & getLocalWellElementStatus() const
  {
    return m_wellLocalElementStatus;
  }
 
 
  array1d< integer > & getWellElementStatus()
  {
    return m_wellElementStatus;
  }
 
  array1d< integer > const & getWellElementStatus() const
  {
    return m_wellElementStatus;
  }
 
  void setTopRank( int rank )
  {
    m_topRank = rank;
  }
 
  bool isLocallyOwned() const;
 
 
 
  void generate( MeshLevel & mesh,
                 LineBlockABC const & lineBlock,
                 arrayView1d< integer > & elemStatus,
                 globalIndex nodeOffsetGlobal,
                 globalIndex elemOffsetGlobal,
                 real64 geomTol );
 
  void connectPerforationsToMeshElements( MeshLevel & mesh,
                                          LineBlockABC const & lineBlock,
                                          real64 geomTol );
 
  void reconstructLocalConnectivity();
 
 
 
  virtual localIndex packUpDownMapsSize( arrayView1d< localIndex const > const & packList ) const override;
 
  virtual localIndex packUpDownMaps( buffer_unit_type * & buffer,
                                     arrayView1d< localIndex const > const & packList ) const override;
 
  virtual localIndex unpackUpDownMaps( buffer_unit_type const * & buffer,
                                       localIndex_array & packList,
                                       bool const overwriteUpMaps,
                                       bool const overwriteDownMaps ) override;
 
  virtual void fixUpDownMaps( bool const clearIfUnmapped ) final override;
 
 
  struct viewKeyStruct : public ElementSubRegionBase::viewKeyStruct
  {
    static constexpr char const * wellControlsString() { return "wellControlsName"; }
    static constexpr char const * wellNodeListString() { return "nodeList"; }
    static constexpr char const * nextWellElementIndexString() { return "nextWellElementIndex"; }
    static constexpr char const * nextWellElementIndexGlobalString() { return "nextWellElementIndexGlobal"; }
    static constexpr char const * topWellElementIndexString() { return "topWellElementIndex"; }
    static constexpr char const * topRankString() { return "topRank"; }
    static constexpr char const * radiusString() { return "radius"; }
    static constexpr char const * wellLocalElementGlobalIndexString() { return "wellLocalElementGlobalIndex"; }
    static constexpr char const * wellLocalElementStatusString() { return "wellLocalElementStatus"; }
 
    dataRepository::ViewKey wellControlsName     = { wellControlsString() };
    dataRepository::ViewKey wellNodeList         = { wellNodeListString() };
    dataRepository::ViewKey nextWellElementIndex = { nextWellElementIndexString() };
    dataRepository::ViewKey nextWellElementIndexGlobal = { nextWellElementIndexGlobalString() };
    dataRepository::ViewKey topWellElementIndex = { topWellElementIndexString() };
    dataRepository::ViewKey topRank            = { topRankString() };
    dataRepository::ViewKey radius             = { radiusString() };
    dataRepository::ViewKey wellLocalElementGlobalIndex = { wellLocalElementGlobalIndexString() };
    dataRepository::ViewKey wellLocalElementStatus   = { wellLocalElementStatusString() };
  }
  viewKeysWellElementSubRegion;
 
  struct groupKeyStruct : public ElementSubRegionBase::groupKeyStruct
  {
    static constexpr char const * perforationDataString() { return "wellElementSubRegion"; }
 
    dataRepository::GroupKey perforationData = { perforationDataString() };
 
  }
  groupKeysWellElementSubRegion;
 
  integer const & getNumLocalElements() const { return m_numLocalElements;}
 
  void setupCommArrays();
 
  void setElementStatus( arrayView1d< integer >  const & localElemPerfStatus );
 
  array1d< globalIndex > const & getGlobalElementIndex() const { return m_globalElementIndex; }
private:
 
  void assignUnownedElementsInReservoir( MeshLevel & mesh,
                                         LineBlockABC const & lineBlock,
                                         SortedArray< globalIndex >           const & unownedElems,
                                         SortedArray< globalIndex > & localElems,
                                         arrayView1d< integer > & elemStatusGlobal,
                                         real64 geomTol ) const;
 
  void checkPartitioningValidity( LineBlockABC const & lineBlock,
                                  SortedArray< globalIndex > & localElems,
                                  arrayView1d< integer > & elemStatusGlobal ) const;
 
  void updateNodeManagerSize( MeshLevel & mesh,
                              LineBlockABC const & lineBlock,
                              SortedArray< globalIndex > const & localNodes,
                              SortedArray< globalIndex > const & boundaryNodes,
                              globalIndex nodeOffsetGlobal );
 
  void constructSubRegionLocalElementMaps( MeshLevel & mesh,
                                           LineBlockABC const & lineBlock,
                                           SortedArray< globalIndex > const & localElems,
                                           globalIndex nodeOffsetGlobal,
                                           globalIndex elemOffsetGlobal );
 
  void updateNodeManagerNodeToElementMap( MeshLevel & mesh );
 
  template< bool DO_PACKING >
  localIndex packUpDownMapsImpl( buffer_unit_type * & buffer,
                                 arrayView1d< localIndex const > const & packList ) const;
 
  map< localIndex, array1d< globalIndex > > m_unmappedGlobalIndicesInNodelist;
 
  string m_wellControlsName;
 
  NodeMapType m_toNodesRelation;
 
  array1d< globalIndex > m_globalWellElementIndex;
 
  array1d< globalIndex > m_globalElementIndex;
 
  array1d< localIndex > m_nextWellElementIndex;
 
  array1d< localIndex > m_nextWellElementIndexGlobal;
 
  localIndex m_topWellElementIndex;
 
  PerforationData m_perforationData;
 
  integer m_topRank;
 
  array1d< real64 > m_radius;
 
  localIndex m_searchDepth;
 
  integer m_numLocalElements;
 
  array1d< integer > m_wellElementStatus; // (sized total number of segments)
 
  array1d< integer > m_wellLocalElementStatus; // (sized number of local segments)
 
  array1d< integer > m_mpiElementOffset;
 
  array1d< localIndex > m_elementPerRank;
};
 
} /* namespace geos */
 
#endif /* GEOS_MESH_WELLELEMENTSUBREGION_HPP_ */