CellBlockManager.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_CELLBLOCKMANAGER_H_
#define GEOS_MESH_CELLBLOCKMANAGER_H_
 
#include "mesh/generators/CellBlock.hpp"
#include "mesh/generators/FaceBlock.hpp"
#include "mesh/generators/InternalWellGenerator.hpp"
#include "mesh/generators/LineBlock.hpp"
#include "mesh/generators/LineBlockABC.hpp"
#include "mesh/generators/CellBlockManagerABC.hpp"
#include "mesh/generators/PartitionDescriptor.hpp"
 
namespace geos
{
 
class CellBlockManager : public CellBlockManagerABC
{
public:
 
  CellBlockManager( string const & name, Group * const parent );
 
  virtual Group * createChild( string const & childKey, string const & childName ) override;
 
  static constexpr int maxNodesPerFace()
  { return 64; }
 
  array2d< real64, nodes::REFERENCE_POSITION_PERM > getNodePositions() const override;
 
  arrayView2d< real64, nodes::REFERENCE_POSITION_USD > getNodePositions();
 
  ArrayOfArrays< localIndex > getNodeToEdges() const override;
 
  ArrayOfArrays< localIndex > getNodeToFaces() const override;
 
  ToCellRelation< ArrayOfArrays< localIndex > > getNodeToElements() const override;
 
  array2d< localIndex > getEdgeToNodes() const override;
 
  ArrayOfArrays< localIndex > getEdgeToFaces() const override;
 
  ArrayOfArrays< localIndex > getFaceToNodes() const override;
 
  ArrayOfArrays< localIndex > getFaceToEdges() const override;
 
  ToCellRelation< array2d< localIndex > > getFaceToElements() const override;
 
  array1d< globalIndex > getNodeLocalToGlobal() const override;
 
  arrayView1d< globalIndex > getNodeLocalToGlobal();
 
  std::map< string, SortedArray< localIndex > > const & getNodeSets() const override;
 
  std::map< string, SortedArray< localIndex > > & getNodeSets();
 
  void setNumNodes( localIndex numNodes );
 
  void generateHighOrderMaps( localIndex const order,
                              globalIndex const maxVertexGlobalID,
                              globalIndex const maxEdgeGlobalID,
                              globalIndex const maxFaceGlobalID,
                              arrayView1d< globalIndex const > const edgeLocalToGlobal,
                              arrayView1d< globalIndex const > const faceLocalToGlobal ) override;
 
  localIndex numNodes() const override;
 
  localIndex numEdges() const override;
 
  localIndex numFaces() const override;
 
  using Group::resize;
 
  void resize( integer_array const & numElements,
               string_array const & regionNames );
 
  void buildMaps();
 
  CellBlock & getCellBlock( string const & name )
  {
    return this->getGroup( viewKeyStruct::cellBlocks() ).getGroup< CellBlock >( name );
  }
 
  const Group & getCellBlocks() const override;
 
  Group & getCellBlocks() override;
 
  Group const & getFaceBlocks() const override;
 
  Group & getFaceBlocks() override;
 
  LineBlockABC const & getLineBlock( string name ) const override;
 
  CellBlock & registerCellBlock( string const & name );
 
  FaceBlock & registerFaceBlock( string const & name );
 
  LineBlock & registerLineBlock( string const & name );
  template< typename LAMBDA >
  void forElementSubRegions( LAMBDA lambda )
  {
    this->getGroup( viewKeyStruct::cellBlocks() ).forSubGroups< CellBlock >( lambda );
  }
 
  real64 getGlobalLength() const override { return m_globalLength; }
 
  void setGlobalLength( real64 globalLength ) { m_globalLength = globalLength; }
 
private:
 
  struct viewKeyStruct
  {
    static constexpr char const * cellBlocks()
    { return "cellBlocks"; }
 
    static constexpr char const * faceBlocks()
    { return "faceBlocks"; }
 
    static constexpr char const * lineBlocks()
    { return "lineBlocks"; }
  };
 
  Group & getLineBlocks();
 
  CellBlock const & getCellBlock( localIndex const blockIndex ) const;
 
  localIndex numCellBlocks() const;
 
  void buildNodeToEdges();
 
  void buildFaceMaps();
 
  template< typename BASEMAP, typename FUNC >
  void buildToCellMap( localIndex const cellIndex,
                       ToCellRelation< BASEMAP > & toCells,
                       FUNC cellToObjectGetter,
                       localIndex const overAlloc = 0 ) const;
 
  array2d< real64, nodes::REFERENCE_POSITION_PERM > m_nodesPositions;
 
  ArrayOfArrays< localIndex > m_nodeToEdges;
  ArrayOfArrays< localIndex > m_edgeToFaces;
  array2d< localIndex > m_edgeToNodes;
  ArrayOfArrays< localIndex > m_faceToNodes;
  ArrayOfArrays< localIndex > m_faceToEdges;
  ToCellRelation< array2d< localIndex > > m_faceToCells;
 
  array1d< globalIndex > m_nodeLocalToGlobal;
 
  std::map< string, SortedArray< localIndex > > m_nodeSets;
 
  real64 m_globalLength;
 
  localIndex m_numNodes;
  localIndex m_numFaces;
  localIndex m_numEdges;
};
 
}
#endif /* GEOS_MESH_CELLBLOCKMANAGER_H_ */