InternalWellGenerator.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.
 * ------------------------------------------------------------------------------------------------------------
 */

/*
 * @file InternalWellGenerator.hpp
 *
 */

#ifndef GEOSX_MESHUTILITIES_INTERNALWELLGENERATOR_HPP_
#define GEOSX_MESHUTILITIES_INTERNALWELLGENERATOR_HPP_

#include "dataRepository/Group.hpp"
#include "meshUtilities/MeshGeneratorBase.hpp"

namespace geosx
{

namespace dataRepository
{
namespace keys
{
string const nodeCoords       = "polylineNodeCoords";
string const segmentConn      = "polylineSegmentConn";
string const nElems           = "numElementsPerSegment";
string const radius           = "radius";
string const wellRegionName   = "wellRegionName";
string const wellControlsName = "wellControlsName";
string const meshBodyName     = "meshName";
}
}

class InternalWellGenerator : public MeshGeneratorBase
{
public:

  struct NodeLocation
  {
    static constexpr integer TOP    = 0; 
    static constexpr integer BOTTOM = 1; 
  };


  InternalWellGenerator( const std::string & name,
                         Group * const parent );

  virtual ~InternalWellGenerator() override;



  static string CatalogName() { return "InternalWell"; }



  virtual void GenerateElementRegions( DomainPartition & ) override {}

  virtual Group * CreateChild( string const & childKey,
                               string const & childName ) override;

  virtual void ExpandObjectCatalogs() override;

  virtual void GenerateMesh( DomainPartition * const domain ) override;

  virtual void GetElemToNodesRelationInBox ( std::string const &,
                                             int const *,
                                             int const &,
                                             int *,
                                             int const ) override {}

  virtual void RemapMesh ( dataRepository::Group * const ) override {}



  // getters for element data

  globalIndex GetNumElements() const { return m_numElems; }

  arrayView2d< real64 const > GetElemCoords() const { return m_elemCenterCoords; }

  arrayView1d< globalIndex const > GetNextElemIndex() const { return m_nextElemId; }

  arrayView1d< arrayView1d< globalIndex const > const > GetPrevElemIndices() const { return m_prevElemId.toNestedViewConst(); }

  arrayView2d< globalIndex const > GetElemToNodesMap() const { return m_elemToNodesMap; }

  arrayView1d< real64 const > GetElemVolume() const { return m_elemVolume; }

  real64 GetElementRadius() const { return m_radius; }

  // getters for node data

  globalIndex GetNumNodes() const { return m_numNodes; }

  arrayView2d< real64 const > GetNodeCoords() const { return m_nodeCoords; }



  // getters for perforation data

  globalIndex GetNumPerforations() const { return m_numPerforations; }

  arrayView2d< real64 const > GetPerfCoords() const { return m_perfCoords; }

  arrayView1d< real64 const > GetPerfTransmissibility() const { return m_perfTransmissibility; }

  arrayView1d< globalIndex const > GetPerfElemIndex() const { return m_perfElemId; }


protected:

  void PostProcessInput() override final;

private:


  void ConstructPolylineNodeToSegmentMap();

  void FindPolylineHeadNodeIndex();

  void DiscretizePolyline();

  void ConnectPerforationsToWellElements();

  void MergePerforations();

  globalIndex GetNextSegmentIndex( globalIndex topSegId,
                                   globalIndex currentNodeId ) const;


  void DebugWellGeometry() const;

  // XML Input

  array2d< globalIndex > m_segmentToPolyNodeMap;

  int m_numElemsPerSegment;

  real64 m_radius;

  string m_wellRegionName;

  string m_wellControlsName;

  string m_meshBodyName;



  // Geometry of the well (later passed to the WellElementSubRegion)

  // well element data

  globalIndex m_numElems;

  array2d< real64 > m_elemCenterCoords;

  array1d< globalIndex > m_nextElemId;

  array1d< array1d< globalIndex > > m_prevElemId;

  array2d< globalIndex > m_elemToNodesMap;

  array1d< real64 > m_elemVolume;


  // well node data

  globalIndex const m_numNodesPerElem;

  globalIndex m_numNodes;

  array2d< real64 > m_nodeCoords;

  // perforation data

  globalIndex m_numPerforations;

  array2d< real64 > m_perfCoords;

  array1d< real64 > m_perfTransmissibility;

  array1d< globalIndex > m_perfElemId;



  // Auxiliary data

  // Number of physical dimensions
  const int m_nDims;

  array2d< real64 > m_polyNodeCoords;

  array1d< SortedArray< globalIndex > > m_polyNodeToSegmentMap;

  globalIndex m_polylineHeadNodeId;

  array1d< real64 > m_nodeDistFromHead;

  // Perforation data

  string_array m_perforationList;

  array1d< real64 > m_perfDistFromHead;

};
}

#endif /* GEOSX_MESHUTILITIES_INTERNALWELLGENERATOR_HPP_ */