EdgeManager.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_EDGEMANAGER_HPP_
#define GEOS_MESH_EDGEMANAGER_HPP_
 
#include "mesh/ObjectManagerBase.hpp"
#include "mesh/generators/CellBlockManagerABC.hpp"
#include "InterObjectRelation.hpp"
#include "ToElementRelation.hpp"
#include "LvArray/src/tensorOps.hpp"
 
 
namespace geos
{
class FaceManager;
class NodeManager;
 
class EdgeManager : public ObjectManagerBase
{
public:
 
  using NodeMapType = FixedOneToManyRelation;
 
  using FaceMapType = InterObjectRelation< ArrayOfSets< localIndex > >;
 
 
  static string catalogName()
  { return "EdgeManager"; }
 
 
  virtual string getCatalogName() const override
  { return catalogName(); }
 
 
  static constexpr localIndex faceMapOverallocation()
  { return CellBlockManagerABC::faceMapExtraSpacePerEdge(); }
 
 
  EdgeManager( string const & name,
               Group * const parent );
 
 
  virtual void resize( localIndex const newSize ) override;
 
  void setDomainBoundaryObjects( FaceManager const & faceManager );
 
  void setIsExternal( FaceManager const & faceManager );
 
  void buildSets( NodeManager const & nodeManager );
 
  void setGeometricalRelations( CellBlockManagerABC const & cellBlockManager, bool isBaseMeshLevel );
 
  void setupRelatedObjectsInRelations( NodeManager const & nodeManager,
                                       FaceManager const & faceManager );
 
  void buildEdges( localIndex const numNodes,
                   ArrayOfArraysView< localIndex const > const & faceToNodeMap,
                   ArrayOfArrays< localIndex > & faceToEdgeMap );
 
 
  virtual ArrayOfSets< globalIndex >
  extractMapFromObjectForAssignGlobalIndexNumbers( ObjectManagerBase const & nodeManager ) 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,
                                       localIndex_array & packList,
                                       bool const overwriteUpMaps,
                                       bool const overwriteDownMaps ) override;
 
  void fixUpDownMaps( bool const clearIfUnmapped );
 
  void compressRelationMaps();
 
  void depopulateUpMaps( std::set< localIndex > const & receivedEdges,
                         ArrayOfArraysView< localIndex const > const & facesToEdges );
 
  bool hasNode( const localIndex edgeIndex, const localIndex nodeIndex ) const;
 
  template< typename OUT_VECTOR >
  void calculateCenter( localIndex const edgeIndex,
                        arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const & X,
                        OUT_VECTOR && edgeCenter ) const;
 
  template< typename OUT_VECTOR >
  void calculateLength( localIndex const edgeIndex,
                        arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const & X,
                        OUT_VECTOR && edgeVector ) const;
 
 
  struct viewKeyStruct : ObjectManagerBase::viewKeyStruct
  {
    static constexpr char const * nodeListString() { return "nodeList"; }
    static constexpr char const * faceListString() { return "faceList"; }
    static constexpr char const * elementRegionListString() { return "elemRegionList"; }
    static constexpr char const * elementSubRegionListString() { return "elemSubRegionList"; }
    static constexpr char const * elementListString() { return "elemList"; }
 
    dataRepository::ViewKey nodesList             = { nodeListString() };
    dataRepository::ViewKey faceList              = { faceListString() };
    dataRepository::ViewKey elementRegionList     = { elementRegionListString() };
    dataRepository::ViewKey elementSubRegionList  = { elementSubRegionListString() };
    dataRepository::ViewKey elementList           = { elementListString() };
  }
  viewKeys;
 
 
 
  NodeMapType & nodeList()       { return m_toNodesRelation; }
 
  NodeMapType const & nodeList() const { return m_toNodesRelation; }
 
  localIndex & nodeList( localIndex const edgeIndex, localIndex const nodeIndex )
  { return m_toNodesRelation( edgeIndex, nodeIndex ); }
 
  localIndex nodeList( localIndex const edgeIndex, localIndex const nodeIndex ) const
  { return m_toNodesRelation( edgeIndex, nodeIndex ); }
 
  FaceMapType & faceList()       { return m_toFacesRelation; }
 
  FaceMapType const & faceList() const { return m_toFacesRelation; }
 
 
private:
 
  NodeMapType m_toNodesRelation;
 
  FaceMapType m_toFacesRelation;
 
  map< localIndex, array1d< globalIndex > > m_unmappedGlobalIndicesInToNodes;
 
  map< localIndex, SortedArray< globalIndex > > m_unmappedGlobalIndicesInToFaces;
 
  template< bool DO_PACKING >
  localIndex packUpDownMapsImpl( buffer_unit_type * & buffer,
                                 arrayView1d< localIndex const > const & packList ) const;
 
};
 
template< typename OUT_VECTOR >
inline void EdgeManager::calculateCenter( localIndex const edgeIndex,
                                          arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const & X,
                                          OUT_VECTOR && edgeCenter ) const
{
  LvArray::tensorOps::copy< 3 >( edgeCenter, X[m_toNodesRelation[edgeIndex][0]] );
  LvArray::tensorOps::add< 3 >( edgeCenter, X[m_toNodesRelation[edgeIndex][1]] );
  LvArray::tensorOps::scale< 3 >( edgeCenter, 0.5 );
}
 
template< typename OUT_VECTOR >
inline void EdgeManager::calculateLength( localIndex const edgeIndex,
                                          arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const & X,
                                          OUT_VECTOR && edgeSegment ) const
{
  LvArray::tensorOps::copy< 3 >( edgeSegment, X[m_toNodesRelation[edgeIndex][1]] );
  LvArray::tensorOps::subtract< 3 >( edgeSegment, X[m_toNodesRelation[edgeIndex][0]] );
}
 
}
#endif /* GEOS_MESH_EDGEMANAGER_HPP_ */