CellElementSubRegion.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_MESH_CELLELEMENTSUBREGION_HPP_
#define GEOS_MESH_CELLELEMENTSUBREGION_HPP_
 
#include "mesh/generators/CellBlockABC.hpp"
#include "mesh/NodeManager.hpp"
#include "mesh/FaceManager.hpp"
#include "mesh/utilities/ComputationalGeometry.hpp"
#include "ElementSubRegionBase.hpp"
 
 
namespace geos
{
 
class MeshLevel;
 
class CellElementSubRegion : public ElementSubRegionBase
{
public:
 
  using NodeMapType = InterObjectRelation< array2d< localIndex, cells::NODE_MAP_PERMUTATION > >;
  using EdgeMapType = FixedOneToManyRelation;
  using FaceMapType = FixedOneToManyRelation;
  using EmbSurfMapType = InterObjectRelation< ArrayOfArrays< localIndex > >;
 
  static string catalogName()
  { return "CellElementSubRegion"; }
 
  virtual string getCatalogName() const override final
  { return catalogName(); }
 
 
  CellElementSubRegion( string const & name, Group * const parent );
 
 
 
  void copyFromCellBlock( CellBlockABC const & cellBlock );
 
 
  void addFracturedElement( localIndex const cellElemIndex,
                            localIndex const embSurfIndex );
 
  virtual void resizePerElementValues( localIndex const numNodesPerElement,
                                       localIndex const numEdgesPerElement,
                                       localIndex const numFacesPerElement ) override;
 
 
 
  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;
 
  localIndex packFracturedElementsSize( arrayView1d< localIndex const > const & packList,
                                        arrayView1d< globalIndex const > const & embeddedSurfacesLocalToGlobal ) const;
  localIndex packFracturedElements( buffer_unit_type * & buffer,
                                    arrayView1d< localIndex const > const & packList,
                                    arrayView1d< globalIndex const > const & embeddedSurfacesLocalToGlobal ) const;
 
  localIndex unpackFracturedElements( buffer_unit_type const * & buffer,
                                      localIndex_array & packList,
                                      unordered_map< globalIndex, localIndex > const & embeddedSurfacesGlobalToLocal );
 
  virtual void fixUpDownMaps( bool const clearIfUnmapped ) final override;
 
 
 
  template< typename LAMBDA >
  void forMaterials( LAMBDA lambda )
  {
 
    for( auto & constitutiveGroup : m_constitutiveGrouping )
    {
      lambda( constitutiveGroup );
    }
  }
 
 
  struct viewKeyStruct : public ElementSubRegionBase::viewKeyStruct
  {
    static constexpr char const * constitutivePointVolumeFractionString() { return "ConstitutivePointVolumeFraction"; }
    static constexpr char const * dNdXString() { return "dNdX"; }
    static constexpr char const * detJString() { return "detJ"; }
    static constexpr char const * constitutiveGroupingString() { return "ConstitutiveGrouping"; }
    static constexpr char const * constitutiveMapString() { return "ConstitutiveMap"; }
    static constexpr char const * toEmbSurfString() { return "ToEmbeddedSurfaces"; }
    static constexpr char const * fracturedCellsString() { return "fracturedCells"; }
    static constexpr char const * bubbleCellsString() { return "bubbleCells"; }
    static constexpr char const * toFaceElementsString() { return "toFaceElements"; }
 
    dataRepository::ViewKey constitutiveGrouping  = { constitutiveGroupingString() };
    dataRepository::ViewKey constitutiveMap       = { constitutiveMapString() };
  }
  m_CellBlockSubRegionViewKeys;
 
  virtual viewKeyStruct & viewKeys() override { return m_CellBlockSubRegionViewKeys; }
  virtual viewKeyStruct const & viewKeys() const override { return m_CellBlockSubRegionViewKeys; }
 
  localIndex getFaceNodes( localIndex const elementIndex,
                           localIndex const localFaceIndex,
                           Span< localIndex > const nodeIndices ) const;
 
  NodeMapType & nodeList() { return m_toNodesRelation; }
 
  NodeMapType const & nodeList() const { return m_toNodesRelation; }
 
  localIndex & nodeList( localIndex k, localIndex a ) { return m_toNodesRelation( k, a ); }
 
  localIndex const & nodeList( localIndex k, localIndex a ) const { return m_toNodesRelation( k, a ); }
 
  FixedOneToManyRelation & edgeList() { return m_toEdgesRelation; }
 
  FixedOneToManyRelation const & edgeList() const { return m_toEdgesRelation; }
 
  FixedOneToManyRelation & faceList() { return m_toFacesRelation; }
 
  FixedOneToManyRelation const & faceList() const { return m_toFacesRelation; }
 
  localIndex faceList( localIndex k, localIndex a ) const { return m_toFacesRelation( k, a ); }
 
  array4d< real64 > & dNdX()
  { return m_dNdX; }
 
  arrayView4d< real64 const > dNdX() const
  { return m_dNdX; }
 
  array2d< real64 > & detJ()
  { return m_detJ; }
 
  arrayView2d< real64 const > detJ() const
  { return m_detJ; }
 
  SortedArray< localIndex > & fracturedElementsList()
  { return m_fracturedCells; }
 
  SortedArrayView< localIndex const > const fracturedElementsList() const
  { return m_fracturedCells.toViewConst(); }
 
  EmbSurfMapType & embeddedSurfacesList() { return m_toEmbeddedSurfaces; }
 
  EmbSurfMapType const & embeddedSurfacesList() const { return m_toEmbeddedSurfaces; }
 
  void setBubbleElementsList( arrayView1d< localIndex const > const bubbleCells )
  { m_bubbleCells = bubbleCells; }
 
  arrayView1d< localIndex const > const bubbleElementsList() const
  { return m_bubbleCells.toViewConst(); }
 
  void setFaceElementsList( arrayView2d< localIndex const > const faceElemsList )
  { m_toFaceElements = faceElemsList; }
 
  arrayView2d< localIndex const > const faceElementsList() const
  { return m_toFaceElements.toViewConst(); }
 
  void calculateElementCenters( arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const & X ) const
  {
    ElementSubRegionBase::calculateElementCenters( m_toNodesRelation, X );
  }
 
  void calculateElementGeometricQuantities( NodeManager const & nodeManager,
                                            FaceManager const & faceManager ) override;
 
private:
 
  map< string, localIndex_array > m_constitutiveGrouping;
 
  array3d< real64 > m_constitutivePointVolumeFraction;
 
  NodeMapType m_toNodesRelation;
 
  EdgeMapType m_toEdgesRelation;
 
  FaceMapType m_toFacesRelation;
 
  string_array m_externalPropertyNames;
 
  void calculateCellVolumesKernel( localIndex const k,
                                   arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const & X ) const;
 
  void calculateElementCenterAndVolume( localIndex const k,
                                        arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const & X ) const;
 
  array4d< real64 > m_dNdX;
 
  array2d< real64 > m_detJ;
 
  map< localIndex, array1d< globalIndex > > m_unmappedGlobalIndicesInNodelist;
 
  map< localIndex, array1d< globalIndex > > m_unmappedGlobalIndicesInEdgelist;
 
  map< localIndex, array1d< globalIndex > > m_unmappedGlobalIndicesInFacelist;
 
  SortedArray< localIndex > m_fracturedCells;
 
  EmbSurfMapType m_toEmbeddedSurfaces;
 
  array1d< localIndex > m_bubbleCells;
 
  array2d< localIndex > m_toFaceElements;
 
  template< bool DO_PACKING >
  localIndex packUpDownMapsImpl( buffer_unit_type * & buffer,
                                 arrayView1d< localIndex const > const & packList ) const;
 
  void setupRelatedObjectsInRelations( MeshLevel const & mesh ) override;
 
  template< bool DO_PACKING >
  localIndex packFracturedElementsImpl( buffer_unit_type * & buffer,
                                        arrayView1d< localIndex const > const & packList,
                                        arrayView1d< globalIndex const > const & embeddedSurfacesLocalToGlobal ) const;
};
 
} /* namespace geos */
 
#endif /* GEOS_MESH_CELLELEMENTSUBREGION_HPP_ */