EmbeddedSurfaceSubRegion.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 Total, S.A
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */

#ifndef GEOSX_MESH_EMBEDDEDSURFACESUBREGION_HPP_
#define GEOSX_MESH_EMBEDDEDSURFACESUBREGION_HPP_

#include "SurfaceElementSubRegion.hpp"
#include "InterObjectRelation.hpp"
#include "ToElementRelation.hpp"
#include "EdgeManager.hpp"
#include "CellElementSubRegion.hpp"
#include "meshUtilities/SimpleGeometricObjects/BoundedPlane.hpp"

namespace geosx
{

class EmbeddedSurfaceSubRegion : public SurfaceElementSubRegion
{
public:

  using FaceMapType = FixedOneToManyRelation;


  static const string CatalogName()
  { return "EmbeddedSurfaceSubRegion"; }

  virtual const string getCatalogName() const override
  {
    return EmbeddedSurfaceSubRegion::CatalogName();
  }



  EmbeddedSurfaceSubRegion( string const & name,
                            dataRepository::Group * const parent );

  virtual ~EmbeddedSurfaceSubRegion() override;



  virtual void CalculateElementGeometricQuantities( NodeManager const & nodeManager,
                                                    FaceManager const & facemanager ) override;

  void CalculateElementGeometricQuantities( arrayView2d< real64 const > const intersectionPoints,
                                            localIndex k );

  bool AddNewEmbeddedSurface( localIndex const cellIndex,
                              localIndex const regionIndex,
                              localIndex const subRegionIndex,
                              NodeManager & nodeManager,
                              EdgeManager const & edgeManager,
                              FixedOneToManyRelation const & cellToEdges,
                              BoundedPlane const * fracture );

  void inheritGhostRank( array1d< array1d< arrayView1d< integer const > > > const & cellGhostRank );

  real64 ComputeHeavisideFunction( ArraySlice< real64 const, 1, nodes::REFERENCE_POSITION_USD - 1 > const nodeCoord,
                                   localIndex const k ) const;




  struct viewKeyStruct : SurfaceElementSubRegion::viewKeyStruct
  {
    static constexpr auto normalVectorString           = "normalVector";

    static constexpr auto t1VectorString           = "tangentVector1";

    static constexpr auto t2VectorString           = "tangentVector2";

    static constexpr auto connectivityIndexString     = "connectivityIndex";
  };

  virtual void setupRelatedObjectsInRelations( MeshLevel const * const mesh ) override;

  virtual string GetElementTypeString() const override final { return "Embedded"; }


  localIndex & numOfJumpEnrichments()       {return m_numOfJumpEnrichments;}

  localIndex const & numOfJumpEnrichments() const {return m_numOfJumpEnrichments;}

  array2d< real64 > & getNormalVector() { return m_normalVector; }

  arrayView2d< real64 const > getNormalVector() const { return m_normalVector; }

  arraySlice1d< real64 > getNormalVector( localIndex k ) { return m_normalVector[k]; }

  arraySlice1d< real64 const > getNormalVector( localIndex k ) const { return m_normalVector[k]; }

  array2d< real64 > & getTangentVector1() { return m_tangentVector1; }

  arrayView2d< real64 const > getTangentVector1() const { return m_tangentVector1; }

  arraySlice1d< real64 > getTangentVector1( localIndex k ) { return m_tangentVector1[k];}

  arraySlice1d< real64 const > getTangentVector1( localIndex k ) const { return m_tangentVector1[k]; }

  array2d< real64 > & getTangentVector2() { return m_tangentVector2; }

  arrayView2d< real64 const > getTangentVector2() const { return m_tangentVector2; }

  arraySlice1d< real64 > getTangentVector2( localIndex k ) { return m_tangentVector2[k];}

  arraySlice1d< real64 const > getTangentVector2( localIndex k ) const { return m_tangentVector2[k];}


  array1d< real64 > & getConnectivityIndex()   { return m_connectivityIndex;}

  array1d< real64 > const & getConnectivityIndex() const { return m_connectivityIndex;}



private:

  array2d< real64 > m_normalVector;

  // tangential direction 1
  array2d< real64 > m_tangentVector1;

  // tangential direction 2
  array2d< real64 > m_tangentVector2;

  localIndex m_numOfJumpEnrichments;

  array1d< real64 > m_connectivityIndex;
};


} /* namespace geosx */

#endif /* GEOSX_MESH_EMBEDDEDSURFACESUBREGION_HPP_ */