CellBlock.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_CELLBLOCK_HPP_
#define GEOS_MESH_CELLBLOCK_HPP_
 
#include "dataRepository/Group.hpp"
#include "mesh/generators/CellBlockABC.hpp"
#include "mesh/ElementType.hpp"
 
namespace geos
{
 
class CellBlock : public CellBlockABC
{
public:
 
 
  CellBlock( string const & name, Group * const parent );
 
 
 
 
 
  void setElementType( ElementType elementType );
 
  ElementType getElementType() const override
  { return m_elementType; }
 
  localIndex numNodesPerElement() const override
  { return m_numNodesPerElement; }
 
  localIndex numEdgesPerElement() const override
  { return m_numEdgesPerElement; }
 
  localIndex numFacesPerElement() const override
  { return m_numFacesPerElement; }
 
  localIndex numElements() const override
  { return size(); }
 
  localIndex maxNodesPerFace() const
  { return m_maxNodesPerFace; }
 
  localIndex getFaceNodes( localIndex const cellIndex,
                           localIndex const faceNum,
                           Span< localIndex > nodesInFace ) const;
 
  arrayView2d< localIndex, cells::NODE_MAP_USD > getElemToNode()
  { return m_elementsToNodes; }
 
  arrayView2d< localIndex const, cells::NODE_MAP_USD > getElemToNode() const
  { return m_elementsToNodes; }
 
  array2d< localIndex, cells::NODE_MAP_PERMUTATION > getElemToNodes() const override
  { return m_elementsToNodes; }
 
  array2d< localIndex > getElemToEdges() const override
  { return m_elementsToEdges; }
 
  array2d< localIndex > getElemToFaces() const override
  { return m_elementsToFaces; }
 
  arrayView2d< localIndex const > getElemToFacesConstView() const
  { return m_elementsToFaces.toViewConst(); }
 
  void setElementToFaces( localIndex const cellIndex,
                          localIndex const faceNum,
                          localIndex const faceIndex )
  {
    m_elementsToFaces( cellIndex, faceNum ) = faceIndex;
  }
 
  void setElementToEdges( localIndex const cellIndex,
                          localIndex const edgeNum,
                          localIndex const edgeIndex )
  {
    m_elementsToEdges( cellIndex, edgeNum ) = edgeIndex;
  }
 
  bool hasElementToEdges( localIndex const cellIndex,
                          localIndex const edgeNum,
                          localIndex const edgeIndex ) const
  {
    return m_elementsToEdges( cellIndex, edgeNum ) == edgeIndex;
  }
 
  arrayView1d< globalIndex > localToGlobalMap()
  { return m_localToGlobalMap; }
 
  array1d< globalIndex > localToGlobalMap() const override
  { return m_localToGlobalMap; }
 
  arrayView1d< globalIndex const > localToGlobalMapConstView() const
  { return m_localToGlobalMap.toViewConst(); }
 
  void resize( dataRepository::indexType const numElements ) override final;
 
  void resizeNumNodes ( dataRepository::indexType const numNodes );
 
 
 
private:
 
  localIndex m_numNodesPerElement = -1;
 
  localIndex m_numEdgesPerElement = -1;
 
  localIndex m_numFacesPerElement = -1;
 
  localIndex m_maxNodesPerFace = -1;
 
  array2d< localIndex, cells::NODE_MAP_PERMUTATION > m_elementsToNodes;
 
  array2d< localIndex > m_elementsToEdges;
 
  array2d< localIndex > m_elementsToFaces;
 
  array1d< globalIndex > m_localToGlobalMap;
 
  string_array m_externalPropertyNames;
 
  ElementType m_elementType;
 
  std::list< dataRepository::WrapperBase const * > getExternalProperties() const override
  {
    std::list< dataRepository::WrapperBase const * > result;
    for( string const & externalPropertyName : m_externalPropertyNames )
    {
      result.push_back( &this->getWrapperBase( externalPropertyName ) );
    }
    return result;
  }
};
 
}
 
#endif /* GEOS_MESH_CELLBLOCK_HPP_ */