SurfaceElementSubRegion.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_SURFACEELEMENTSUBREGION_HPP_
#define GEOS_MESH_SURFACEELEMENTSUBREGION_HPP_
 
#include "ElementSubRegionBase.hpp"
#include "InterObjectRelation.hpp"
#include "ToElementRelation.hpp"
#include "EdgeManager.hpp"
#include "CellElementSubRegion.hpp"
 
namespace geos
{
 
class SurfaceElementSubRegion : public ElementSubRegionBase
{
public:
 
  using NodeMapType = InterObjectRelation< ArrayOfArrays< localIndex > >;
 
  using EdgeMapType = InterObjectRelation< ArrayOfArrays< localIndex > >;
 
 
  static string catalogName()
  { return "SurfaceElementSubRegion"; }
 
  virtual string getCatalogName() const override
  {
    return catalogName();
  }
 
 
 
  SurfaceElementSubRegion( string const & name,
                           dataRepository::Group * const parent );
 
 
  virtual ~SurfaceElementSubRegion() override;
 
  void calculateElementCenters( arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const & X ) const
  {
    ElementSubRegionBase::calculateElementCenters( m_toNodesRelation, X );
  }
 
 
 
  NodeMapType const & nodeList() const
  {
    return m_toNodesRelation;
  }
 
  NodeMapType & nodeList()
  {
    return m_toNodesRelation;
  }
 
  localIndex & nodeList( localIndex const k, localIndex a ) { return m_toNodesRelation( k, a ); }
 
  localIndex const & nodeList( localIndex const k, localIndex a ) const { return m_toNodesRelation( k, a ); }
 
  EdgeMapType const & edgeList() const
  {
    return m_toEdgesRelation;
  }
 
  EdgeMapType & edgeList()
  {
    return m_toEdgesRelation;
  }
 
  using ElementSubRegionBase::numNodesPerElement;
 
  localIndex numNodesPerElement( localIndex const k ) const final
  { return m_toNodesRelation[k].size(); }
 
  OrderedVariableToManyElementRelation & getToCellRelation()
  {
    return m_2dElemToElems;
  }
 
  OrderedVariableToManyElementRelation const & getToCellRelation() const
  {
    return m_2dElemToElems;
  }
 
 
 
 
  arrayView1d< real64 > getElementAperture() { return m_elementAperture; }
 
  arrayView1d< real64 const > getElementAperture() const { return m_elementAperture; }
 
  arrayView1d< real64 > getElementArea() { return m_elementArea; }
 
  arrayView1d< real64 const > getElementArea() const { return m_elementArea; }
 
  arrayView2d< real64 const > getNormalVector() const { return m_normalVector; }
 
  arrayView2d< real64 > getNormalVector() { return m_normalVector; }
 
  arraySlice1d< real64 const > getNormalVector( localIndex k ) const { return m_normalVector[k]; }
 
  arrayView2d< real64 const > getTangentVector1() const { return m_tangentVector1; }
 
  arrayView2d< real64 > getTangentVector1() { return m_tangentVector1; }
 
  arraySlice1d< real64 const > getTangentVector1( localIndex const k ) const { return m_tangentVector1[k]; }
 
  arrayView2d< real64 const > getTangentVector2() const { return m_tangentVector2.toViewConst(); }
 
  arrayView2d< real64 > getTangentVector2() { return m_tangentVector2; }
 
  arraySlice1d< real64 const > getTangentVector2( localIndex const k ) const { return m_tangentVector2[k];}
 
 
 
  struct viewKeyStruct : ElementSubRegionBase::viewKeyStruct
  {
    static constexpr char const * surfaceElementsToCellRegionsString() { return "fractureElementsToCellRegions"; }
 
    static constexpr char const * surfaceElementsToCellSubRegionsString() { return "fractureElementsToCellSubRegions"; }
 
    static constexpr char const * surfaceElementsToCellIndexString() { return "fractureElementsToCellIndices"; }
 
    constexpr static char const * creationMassString() { return "creationMass"; }
 
    constexpr static char const * surfaceElementToParentPlaneString() { return "surfaceElementToParentPlane"; }
  };
 
protected:
 
  OrderedVariableToManyElementRelation m_2dElemToElems;
 
  map< localIndex, array1d< globalIndex > > m_unmappedGlobalIndicesInToNodes;
 
  NodeMapType m_toNodesRelation;
 
  EdgeMapType m_toEdgesRelation;
 
  array1d< real64 > m_elementAperture;
 
  array1d< real64 > m_elementArea;
 
  array2d< real64 > m_normalVector;
 
  array2d< real64 > m_tangentVector1;
 
  array2d< real64 > m_tangentVector2;
 
};
 
} /* namespace geos */
 
#endif /* SRC_CORECOMPONENTS_MESH_SURFACEELEMENTSUBREGION_HPP_ */