WellGeneratorBase.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 TotalEnergies
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
/*
 * @file WellGeneratorBase.hpp
 *
 */
 
#ifndef GEOS_MESH_GENERATORS_WELLGENERATORBASE_HPP_
#define GEOS_MESH_GENERATORS_WELLGENERATORBASE_HPP_
 
#include "mesh/generators/WellGeneratorABC.hpp"
#include "dataRepository/Group.hpp"
#include "codingUtilities/Utilities.hpp"
#include "common/DataTypes.hpp"
 
 
namespace geos
{
 
class WellGeneratorBase : public WellGeneratorABC
{
public:
 
  WellGeneratorBase( const string & name,
                     Group * const parent );
 
  virtual void expandObjectCatalogs() override;
 
  using CatalogInterface = dataRepository::CatalogInterface< WellGeneratorBase, string const &, Group * const >;
 
 
  virtual Group * createChild( string const & childKey, string const & childName ) override;
 
  static CatalogInterface::CatalogType & getCatalog();
 
  void generateWellGeometry( ) override;
 
 
 
  // getters for element data
 
  globalIndex numElements() const override { return m_numElems; }
 
  const array2d< globalIndex > & getSegmentToPolyNodeMap() const override { return m_segmentToPolyNodeMap; };
 
  globalIndex numNodesPerElement() const override { return m_numNodesPerElem; }
 
  const array2d< real64 > & getPolyNodeCoord() const override { return m_polyNodeCoords; }
 
  real64 getMinSegmentLength() const override { return m_minSegmentLength; }
 
  real64 getMinElemLength() const override { return m_minElemLength; }
 
  const string_array & getPerforationList() const override { return m_perforationList; }
 
  arrayView2d< real64 const > getElemCoords() const override { return m_elemCenterCoords; }
 
  arrayView1d< globalIndex const > getNextElemIndex() const override { return m_nextElemId; }
 
  arrayView1d< arrayView1d< globalIndex const > const > getPrevElemIndices() const override { return m_prevElemId.toNestedViewConst(); }
 
  arrayView2d< globalIndex const > getElemToNodesMap() const override { return m_elemToNodesMap; }
 
  arrayView1d< real64 const > getElemVolume() const override { return m_elemVolume; }
 
  real64 getElementRadius() const override { return m_radius; }
 
  // getters for node data
 
  globalIndex numNodes() const override { return m_numNodes; }
 
  arrayView2d< real64 const > getNodeCoords() const override { return m_nodeCoords; }
 
  // getters for perforation data
  globalIndex numPerforations() const override { return m_numPerforations; }
 
  arrayView2d< real64 const > getPerfCoords() const override { return m_perfCoords; }
 
  arrayView1d< real64 const > getPerfTransmissibility() const override { return m_perfTransmissibility; }
 
  arrayView1d< real64 const > getPerfSkinFactor() const override { return m_perfSkinFactor; };
 
  arrayView1d< globalIndex const > getPerfElemIndex() const override { return m_perfElemId; }
 
  int getPhysicalDimensionsNumber() const override { return m_nDims; }
 
  const string getWellRegionName() const override { return m_wellRegionName; }
 
  const string getWellControlsName() const override { return m_wellControlsName; }
 
  struct viewKeyStruct
  {
    constexpr static char const * polylineNodeCoordsString() { return "polylineNodeCoords"; }
    constexpr static char const * polylineSegmentConnString() { return "polylineSegmentConn"; }
    constexpr static char const * numElementsPerSegmentString() { return "numElementsPerSegment"; }
    constexpr static char const * minSegmentLengthString() { return "minSegmentLength"; }
    constexpr static char const * minElementLengthString() { return "minElementLength"; }
    constexpr static char const * radiusString() { return "radius"; }
    constexpr static char const * wellRegionNameString() { return "wellRegionName"; }
    constexpr static char const * wellControlsNameString() { return "wellControlsName"; }
    constexpr static char const * perforationString() { return "Perforation"; }
  };
 
protected:
 
  void postProcessInput() override;
 
 
  virtual void fillPolylineDataStructure() { };
 
  void constructPolylineNodeToSegmentMap();
 
  void findPolylineHeadNodeIndex();
 
  void discretizePolyline();
 
  void connectPerforationsToWellElements();
 
  void checkPerforationLocationsValidity();
 
  void mergePerforations( array1d< array1d< localIndex > > const & elemToPerfMap );
 
  globalIndex getNextSegmentIndex( globalIndex topSegId,
                                   globalIndex currentNodeId ) const;
 
 
  void debugWellGeometry() const;
 
  globalIndex m_numPerforations;
 
  string_array m_perforationList;
 
  // XML Input
 
  array2d< globalIndex > m_segmentToPolyNodeMap;
 
  int m_numElemsPerSegment;
 
  real64 m_minSegmentLength;
 
  real64 m_minElemLength;
 
  real64 m_radius;
 
  string m_wellRegionName;
 
  string m_wellControlsName;
 
 
 
  // 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
 
  array2d< real64 > m_perfCoords;
 
  array1d< real64 > m_perfTransmissibility;
 
  array1d< globalIndex > m_perfElemId;
 
 
 
  // Auxiliary data
 
  const int m_nDims;
 
  array2d< real64 > m_polyNodeCoords;
 
  array1d< SortedArray< globalIndex > > m_polyNodeToSegmentMap;
 
  globalIndex m_polylineHeadNodeId;
 
  array1d< real64 > m_nodeDistFromHead;
 
  // Perforation data
 
  array1d< real64 > m_perfSkinFactor;
 
  array1d< real64 > m_perfDistFromHead;
 
};
}
#endif /* GEOS_MESH_GENERATORS_WELLGENERATORBASE_HPP_ */