ProjectionEDFMHelper.hpp

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 Total, S.A
 * 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_FINITEVOLUME_PROJECTIONEDFMHELPER_HPP_
#define GEOS_FINITEVOLUME_PROJECTIONEDFMHELPER_HPP_
 
#include "common/DataTypes.hpp"
#include "mesh/ElementRegionManager.hpp"
 
namespace geos
{
 
class MeshLevel;
class CellElementStencilTPFA;
class EmbeddedSurfaceToCellStencil;
 
struct CellDescriptor
{
  localIndex region;
  localIndex subRegion;
  localIndex index;
 
  CellDescriptor( localIndex r, localIndex sr, localIndex i )
    : region( r ), subRegion( sr ), index( i )
  {}
 
  bool operator==( CellDescriptor const & other ) const
  {
    return( region==other.region && subRegion==other.subRegion && index==other.index );
  }
};
 
class ProjectionEDFMHelper
{
public:
 
  ProjectionEDFMHelper( MeshLevel const & mesh,
                        CellElementStencilTPFA & stencil,
                        EmbeddedSurfaceToCellStencil & edfmStencil,
                        string const & embeddedSurfaceRegionName );
 
  void addNonNeighboringConnections() const;
 
private:
 
  std::vector< localIndex > selectFaces( FixedOneToManyRelation const & subRegionFaces,
                                         CellDescriptor const & hostCellID,
                                         localIndex const fracElement,
                                         EmbeddedSurfaceSubRegion const & fractureSubRegion ) const;
 
  bool intersection( real64 const ( &fracCenter )[3],
                     arraySlice1d< real64 const > const & fracNormal,
                     localIndex const edgeIdx ) const;
 
  bool isBoundaryFace( localIndex const faceIdx ) const;
 
  bool onLargerSide( localIndex const faceIdx,
                     real64 const signedDistanceCellCenterToFrac,
                     real64 const ( &fracCenter )[3],
                     arraySlice1d< real64 const > const & fracNormal ) const;
 
  /*
   * @brief compute the signed distance between the fracture and as cell center
   * @param[in] hostCellID id of the host cell
   * @param[in] fracNormal the normal vector of the fracture element
   * @param[in] fracCenter the coordinates of the center of the fracture cell
   * @param[out] cellCenterToFracCenter distance vector between the cell and the fracture.
   * return The signed distance between the fracture and the cell (based on the frac normal direction)
   */
  real64 getSignedDistanceCellCenterToFracPlane( CellDescriptor const & hostCellID,
                                                 arraySlice1d< real64 const > const & fracNormal,
                                                 real64 const (&fracCenter)[3],
                                                 real64 ( &cellCenterToFracCenter )[3] ) const;
 
  /*
   * @brief returns true if the signed distance from the neighbor center to the frac is of the same sign as signedDistanceCellCenterToFrac
   *(computed in the host cell)
   * @@param[in] faceIdx the face index
   * @param[in] signedDistanceCellCenterToFrac signed distance between the fracture and the cell (based on the frac normal direction)
   * @param[in] hostCellID id of the host cell (region, subregion and element index)
   * @param[in] fractureSubRegion the embeddedSurfaceSubRegion
   * return whether the neighboring cell has the fracture on the same side of the face or not.
   */
  bool neighborOnSameSide( localIndex const faceIdx,
                           real64 const signedDistanceCellCenterToFrac,
                           CellDescriptor const & hostCellID,
                           EmbeddedSurfaceSubRegion const & fractureSubRegion ) const;
 
  CellDescriptor otherCell( localIndex const faceIdx, CellDescriptor const & hostCellID ) const;
 
  void computeFractureMatrixWeights( CellDescriptor const & neighborCell,
                                     localIndex const fracElement,
                                     EmbeddedSurfaceSubRegion const & fractureSubRegion,
                                     localIndex const faceIdx,
                                     real64 ( &weights )[2] ) const;
 
  void addNonNeighboringConnection( localIndex const fracElement,
                                    CellDescriptor const & cell,
                                    real64 const (&weights)[2],
                                    EmbeddedSurfaceSubRegion const & fractureSubRegion ) const;
 
  // Private variables
 
  ElementRegionManager const & m_elementManager;
  arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const m_nodesCoord;
  arrayView2d< localIndex const > const m_edgeToNodes;
  arrayView2d< localIndex const > const m_faceToRegions;
  arrayView2d< localIndex const > const m_faceToSubRegions;
  arrayView2d< localIndex const > const m_faceToCells;
  ArrayOfArraysView< localIndex const > m_faceToEdges;
  ArrayOfArraysView< localIndex const > const m_faceToNodes;
  ElementRegionManager::ElementViewAccessor< arrayView2d< real64 const > > const m_cellCenters;
  CellElementStencilTPFA & m_cellStencil;
  EmbeddedSurfaceToCellStencil & m_edfmStencil;
  string const m_embeddedSurfaceRegionName;
 
};
 
}  // end namespace geos
 
 
#endif // __PROJECTIONEDFMHELPER_H_