PerforationData.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 PerforationData.hpp
 */

#ifndef GEOSX_MESHUTILITIES_PERFORATIONDATA_HPP
#define GEOSX_MESHUTILITIES_PERFORATIONDATA_HPP

#include "dataRepository/Group.hpp"
#include "managers/ObjectManagerBase.hpp"
#include "mesh/ToElementRelation.hpp"
#include "meshUtilities/InternalWellGenerator.hpp"

namespace geosx
{

class DomainPartition;
class MeshLevel;
class WellElementSubRegion;
class CellBlock;

class PerforationData : public ObjectManagerBase
{
public:


  explicit PerforationData( string const & name, dataRepository::Group * const parent );

  ~PerforationData() override;

  PerforationData() = delete;

  PerforationData( PerforationData const & ) = delete;

  PerforationData( PerforationData && ) = delete;

  PerforationData & operator=( PerforationData const & ) = delete;

  PerforationData & operator=( PerforationData && ) = delete;



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

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



  void SetNumPerforationsGlobal( globalIndex nPerfs ) { m_numPerforationsGlobal = nPerfs; }


  globalIndex GetNumPerforationsGlobal() const { return m_numPerforationsGlobal; }


  ToElementRelation< array1d< localIndex > > & GetMeshElements() { return m_toMeshElements; }


  ToElementRelation< array1d< localIndex > > const & GetMeshElements() const { return m_toMeshElements; }


  arrayView1d< localIndex > GetWellElements() { return m_wellElementIndex; }


  arrayView1d< localIndex const > GetWellElements() const { return m_wellElementIndex; }


  arrayView2d< real64 > GetLocation() { return m_location; }


  arrayView2d< real64 const > GetLocation() const { return m_location; }


  arrayView1d< real64 const > GetWellTransmissibility() const { return m_wellTransmissibility; }


  arrayView1d< real64 > GetWellTransmissibility() { return m_wellTransmissibility; }



  void ComputeWellTransmissibility( MeshLevel const & mesh,
                                    WellElementSubRegion const * const wellElemSubRegion,
                                    string const & permeabilityKey );



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


  void ConnectToWellElements( InternalWellGenerator const & wellGeometry,
                              unordered_map< globalIndex, localIndex > const & globalToLocalWellElementMap,
                              globalIndex elemOffsetGlobal );


  struct viewKeyStruct : public ObjectManagerBase::viewKeyStruct
  {
    static constexpr auto numPerforationsGlobalString     = "numPerforationsGlobal";
    static constexpr auto reservoirElementRegionString    = "reservoirElementRegion";
    static constexpr auto reservoirElementSubregionString = "reservoirElementSubregion";
    static constexpr auto reservoirElementIndexString     = "reservoirElementIndex";
    static constexpr auto wellElementIndexString          = "wellElementIndex";
    static constexpr auto locationString                  = "location";
    static constexpr auto wellTransmissibilityString      = "wellTransmissibility";

    dataRepository::ViewKey numPerforationsGlobal     = { numPerforationsGlobalString };
    dataRepository::ViewKey reservoirElementRegion    = { reservoirElementRegionString };
    dataRepository::ViewKey reservoirElementSubregion = { reservoirElementSubregionString };
    dataRepository::ViewKey reservoirElementIndex     = { reservoirElementIndexString };
    dataRepository::ViewKey wellElementIndex          = { wellElementIndexString };
    dataRepository::ViewKey location                  = { locationString };
    dataRepository::ViewKey wellTransmissibility      = { wellTransmissibilityString };

  }
  viewKeysPerforationData;

  struct groupKeyStruct : public ObjectManagerBase::groupKeyStruct
  {}
  groupKeysPerforationData;

private:


  void GetReservoirElementDimensions( MeshLevel const & mesh,
                                      localIndex const er, localIndex const esr, localIndex const ei,
                                      real64 & dx, real64 & dy, real64 & dz ) const;


  void DebugLocalPerforations() const;

  globalIndex m_numPerforationsGlobal;

  ToElementRelation< array1d< localIndex > > m_toMeshElements;

  array1d< localIndex > m_wellElementIndex;

  array2d< real64 > m_location;

  array1d< real64 > m_wellTransmissibility;

};

} //namespace geosx

#endif //GEOSX_MESHUTILITIES_PERFORATIONDATA_HPP