FaceElementSubRegion.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * 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.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_MESH_FACEELEMENTSUBREGION_HPP_
#define GEOS_MESH_FACEELEMENTSUBREGION_HPP_
 
#include "SurfaceElementSubRegion.hpp"
#include "mesh/generators/FaceBlockABC.hpp"
 
namespace geos
{
 
class FaceElementSubRegion : public SurfaceElementSubRegion
{
public:
 
  using FaceMapType = InterObjectRelation< ArrayOfArrays< localIndex > >;
 
 
  static string catalogName()
  { return "FaceElementSubRegion"; }
 
  virtual string getCatalogName() const override
  {
    return catalogName();
  }
 
 
 
  FaceElementSubRegion( string const & name,
                        dataRepository::Group * const parent );
 
 
  void copyFromCellBlock( FaceBlockABC const & faceBlock );
 
 
  virtual void calculateElementGeometricQuantities( NodeManager const & nodeManager,
                                                    FaceManager const & faceManager ) override;
  void calculateSingleElementGeometricQuantities( localIndex const k,
                                                  arrayView1d< real64 const > const & faceArea );
 
  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,
                                       array1d< localIndex > & packList,
                                       bool const overwriteUpMaps,
                                       bool const overwriteDownMaps ) override;
 
  virtual void fixUpDownMaps( bool const clearIfUnmapped ) override;
 
  void fixSecondaryMappings( NodeManager const & nodeManager,
                             EdgeManager const & edgeManager,
                             FaceManager const & faceManager,
                             ElementRegionManager const & elemManager );
 
 
  void inheritGhostRankFromParentFace( FaceManager const & faceManager,
                                       std::set< localIndex > const & indices );
 
  void fixNeighboringFacesNormals( FaceManager & faceManager,
                                   ElementRegionManager const & elemManager );
 
  void flipFaceMap( FaceManager & faceManager,
                    ElementRegionManager const & elemManager );
 
  struct viewKeyStruct : SurfaceElementSubRegion::viewKeyStruct
  {
    static constexpr char const * dNdXString() { return "dNdX"; }
    static constexpr char const * detJString() { return "detJ"; }
    static constexpr char const * edgesTofractureConnectorsEdgesString() { return "edgesToFractureConnectors"; }
    static constexpr char const * fractureConnectorEdgesToEdgesString() { return "fractureConnectorsToEdges"; }
    static constexpr char const * fractureConnectorsEdgesToFaceElementsIndexString() { return "fractureConnectorsToElementIndex"; }
    static constexpr char const * elem2dToCollocatedNodesBucketsString() { return "elem2dToCollocatedNodesBuckets"; }
 
#if GEOSX_USE_SEPARATION_COEFFICIENT
    constexpr static char const * separationCoeffString() { return "separationCoeff"; }
    constexpr static char const * dSeparationCoeffdAperString() { return "dSeparationCoeffdAper"; }
#endif
  };
 
  virtual void setupRelatedObjectsInRelations( MeshLevel const & mesh ) override;
 
 
 
  FaceMapType const & faceList() const
  {
    return m_toFacesRelation;
  }
 
  FaceMapType & faceList()
  {
    return m_toFacesRelation;
  }
 
 
 
  //virtual localIndex numNodesPerElement( localIndex const k ) const override { return m_toNodesRelation[k].size(); }
 
#ifdef GEOSX_USE_SEPARATION_COEFFICIENT
  arrayView1d< real64 > getSeparationCoefficient() { return m_separationCoefficient; }
  arrayView1d< real64 const > getSeparationCoefficient() const { return m_separationCoefficient; }
#endif
 
 
  map< localIndex, array1d< globalIndex > > m_unmappedGlobalIndicesInToEdges;
 
  map< localIndex, array1d< globalIndex > > m_unmappedGlobalIndicesInToFaces;
 
  SortedArray< localIndex > m_newFaceElements;
 
  SortedArray< localIndex > m_recalculateConnectionsFor2dFaces;
 
  map< localIndex, localIndex > m_edgesTo2dFaces;
 
  array1d< localIndex > m_2dFaceToEdge;
 
  ArrayOfArrays< localIndex > m_2dFaceTo2dElems;
 
  std::set< std::set< globalIndex > > getCollocatedNodes() const;
 
  array4d< real64 > & dNdX()
  { return m_dNdX; }
 
  arrayView4d< real64 const > dNdX() const
  { return m_dNdX.toViewConst(); }
 
  array2d< real64 > & detJ()
  { return m_detJ; }
 
  arrayView2d< real64 const > detJ() const
  { return m_detJ; }
 
  using ElementSubRegionBase::getElementType;
 
  ElementType getElementType( localIndex ei ) const;
 
  ArrayOfArraysView< array1d< globalIndex > const > get2dElemToCollocatedNodesBuckets() const
  {
    return m_2dElemToCollocatedNodesBuckets.toViewConst();
  }
 
private:
 
  template< bool DO_PACKING >
  localIndex packUpDownMapsImpl( buffer_unit_type * & buffer,
                                 arrayView1d< localIndex const > const & packList ) const;
 
  array4d< real64 > m_dNdX;
 
  array2d< real64 > m_detJ;
 
  FaceMapType m_toFacesRelation;
 
  ArrayOfArrays< array1d< globalIndex > > m_2dElemToCollocatedNodesBuckets;
 
#ifdef GEOSX_USE_SEPARATION_COEFFICIENT
  array1d< real64 > m_separationCoefficient;
#endif
 
};
 
} /* namespace geos */
 
#endif /* GEOS_MESH_FACEELEMENTSUBREGION_HPP_ */