WellElementSubRegion.hpp

/*
 * ------------------------------------------------------------------------------------------------------------
 * 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 Total, S.A
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */

#ifndef GEOSX_MESH_WELLELEMENTSUBREGION_HPP_
#define GEOSX_MESH_WELLELEMENTSUBREGION_HPP_

#include "mesh/ElementSubRegionBase.hpp"
#include "mesh/InterObjectRelation.hpp"
#include "meshUtilities/PerforationData.hpp"

namespace geosx
{

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 WellElemStatus : unsigned
  {
    UNOWNED = 0,             // there are no perforations on this element
    REMOTE = 1,              // all perforations are remote
    LOCAL  = 2,              // all perforations are local
    SHARED = REMOTE | LOCAL  // both remote and local perforations
  };


  WellElementSubRegion( string const & name,
                        Group * const parent );

  virtual ~WellElementSubRegion() override;



  static const string CatalogName() { return "wellElementSubRegion"; }

  virtual const string getCatalogName() const override { return WellElementSubRegion::CatalogName(); }



  virtual void CalculateElementGeometricQuantities( NodeManager const &,
                                                    FaceManager const & ) override
  {}

  virtual void setupRelatedObjectsInRelations( MeshLevel const * const mesh ) override;



  FixedOneToManyRelation & edgeList()
  {
    return m_toEdgesRelation;
  }

  FixedOneToManyRelation const & edgeList() const
  {
    return m_toEdgesRelation;
  }

  FixedOneToManyRelation & faceList()
  {
    return m_toFacesRelation;
  }

  FixedOneToManyRelation const & faceList() const
  {
    return m_toFacesRelation;
  }

  NodeMapType & nodeList()
  {
    return m_toNodesRelation;
  }

  NodeMapType const & nodeList() const
  {
    return m_toNodesRelation;
  }

  localIndex GetTopWellElementIndex() const
  {
    return m_topWellElementIndex;
  }

  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;
  }

  void SetTopRank( int rank )
  {
    m_topRank = rank;
  }

  int GetTopRank() const
  {
    return m_topRank;
  }

  bool IsLocallyOwned() const;



  void Generate( MeshLevel & mesh,
                 InternalWellGenerator const & wellGeometry,
                 arrayView1d< integer > & elemStatus,
                 globalIndex nodeOffsetGlobal,
                 globalIndex elemOffsetGlobal );

  void ConnectPerforationsToMeshElements( MeshLevel & mesh,
                                          InternalWellGenerator const & wellGeometry );

  void ReconstructLocalConnectivity();



  virtual void ViewPackingExclusionList( SortedArray< localIndex > & exclusionList ) const override;

  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;


  void DebugWellElementSubRegionsAfterSetupCommunications() const;

  struct viewKeyStruct : public ElementSubRegionBase::viewKeyStruct
  {
    static constexpr auto wellControlsString               = "wellControlsName";
    static constexpr auto wellNodeListString               = "nodeList";
    static constexpr auto nextWellElementIndexString       = "nextWellElementIndex";
    static constexpr auto nextWellElementIndexGlobalString = "nextWellElementIndexGlobal";
    static constexpr auto topWellElementIndexString        = "topWellElementIndex";
    static constexpr auto topRankString                    = "topRank";
    static constexpr auto radiusString                     = "radius";

    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 };

  }
  viewKeysWellElementSubRegion;

  struct groupKeyStruct : public ElementSubRegionBase::groupKeyStruct
  {
    static constexpr auto perforationDataString = "wellElementSubRegion";

    dataRepository::GroupKey perforationData = { perforationDataString };

  }
  groupKeysWellElementSubRegion;


private:

  void AssignUnownedElementsInReservoir( MeshLevel & mesh,
                                         InternalWellGenerator const & wellGeometry,
                                         SortedArray< globalIndex >           const & unownedElems,
                                         SortedArray< globalIndex > & localElems,
                                         arrayView1d< integer > & elemStatusGlobal ) const;

  void CheckPartitioningValidity( InternalWellGenerator const & wellGeometry,
                                  SortedArray< globalIndex > & localElems,
                                  arrayView1d< integer > & elemStatusGlobal ) const;

  void UpdateNodeManagerSize( MeshLevel & mesh,
                              InternalWellGenerator const & wellGeometry,
                              SortedArray< globalIndex > const & localNodes,
                              SortedArray< globalIndex > const & boundaryNodes,
                              globalIndex nodeOffsetGlobal );

  void ConstructSubRegionLocalElementMaps( MeshLevel & mesh,
                                           InternalWellGenerator const & wellGeometry,
                                           SortedArray< globalIndex > const & localElems,
                                           globalIndex nodeOffsetGlobal,
                                           globalIndex elemOffsetGlobal );

  void UpdateNodeManagerNodeToElementMap( MeshLevel & mesh );

  void DebugNodeManager( MeshLevel const & mesh ) const;

  void DebugWellElementSubRegions( arrayView1d< integer const > const & wellElemStatus, globalIndex elemOffsetGlobal ) const;

  template< bool DOPACK >
  localIndex PackUpDownMapsPrivate( buffer_unit_type * & buffer,
                                    arrayView1d< localIndex const > const & packList ) const;

  map< localIndex, array1d< globalIndex > > m_unmappedGlobalIndicesInNodelist;

  string m_wellControlsName;

  NodeMapType m_toNodesRelation;

  EdgeMapType m_toEdgesRelation;  // unused but needed in MeshLevel::GenerateAdjacencyLists

  FaceMapType m_toFacesRelation;  // unused but needed in MeshLevel::GenerateAdjacencyLists

  array1d< localIndex > m_nextWellElementIndex;

  array1d< localIndex > m_nextWellElementIndexGlobal;

  localIndex m_topWellElementIndex;

  PerforationData m_perforationData;

  integer m_topRank;

  array1d< real64 > m_radius;

  localIndex m_searchDepth;

};

} /* namespace geosx */

#endif /* GEOSX_MESH_WELLELEMENTSUBREGION_HPP_ */