ElementSubRegionBase.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * 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_ELEMENTSUBREGIONBASE_HPP_
#define GEOS_MESH_ELEMENTSUBREGIONBASE_HPP_
 
#include "mesh/ElementType.hpp"
#include "mesh/ObjectManagerBase.hpp"
#include "LvArray/src/tensorOps.hpp"
 
namespace geos
{
 
class NodeManager;
class FaceManager;
class MeshLevel;
 
namespace constitutive
{
class ConstitutiveBase;
}
 
class ElementSubRegionBase : public ObjectManagerBase
{
public:
 
 
  ElementSubRegionBase( string const & name, dataRepository::Group * const parent );
 
  ~ElementSubRegionBase();
 
 
 
  virtual void calculateElementGeometricQuantities( NodeManager const & nodeManager,
                                                    FaceManager const & faceManager ) = 0;
 
  virtual void setupRelatedObjectsInRelations( MeshLevel const & mesh ) = 0;
 
  virtual void fixUpDownMaps( bool const clearIfUnmapped ) { GEOS_UNUSED_VAR( clearIfUnmapped ); }
 
 
  virtual void resizePerElementValues( localIndex const numNodesPerElement,
                                       localIndex const numEdgesPerElement,
                                       localIndex const numFacesPerElement );
 
 
 
  localIndex const & numNodesPerElement() const { return m_numNodesPerElement; }
 
  virtual localIndex numNodesPerElement( localIndex const k ) const { GEOS_UNUSED_VAR( k ); return m_numNodesPerElement; }
 
  localIndex const & numFacesPerElement() const { return m_numFacesPerElement; }
 
  localIndex const & numEdgesPerElement() const { return m_numEdgesPerElement; }
 
  arrayView2d< real64 const > getElementCenter() const
  { return m_elementCenter; }
 
  array2d< real64 > & getElementCenter()
  { return m_elementCenter; }
 
  arrayView1d< real64 const > getElementVolume() const
  { return m_elementVolume; }
 
  dataRepository::Group const & getConstitutiveModels() const
  { return m_constitutiveModels; }
 
  dataRepository::Group & getConstitutiveModels()
  { return m_constitutiveModels; }
 
  template< typename T = constitutive::ConstitutiveBase >
  T const & getConstitutiveModel( string const & name ) const
  { return m_constitutiveModels.getGroup< T >( name ); }
 
  template< typename T = constitutive::ConstitutiveBase >
  T & getConstitutiveModel( string const & name )
  { return m_constitutiveModels.getGroup< T >( name ); }
 
  ElementType getElementType() const
  { return m_elementType; }
 
  void setElementType( ElementType const elemType )
  { m_elementType = elemType; }
 
 
 
  struct viewKeyStruct : ObjectManagerBase::viewKeyStruct
  {
    static constexpr char const * numNodesPerElementString() { return "numNodesPerElement"; }
    static constexpr char const * nodeListString() { return "nodeList"; }
    static constexpr char const * numEdgesPerElementString() { return "numEdgesPerElement"; }
    static constexpr char const * edgeListString() { return "edgeList"; }
    static constexpr char const * numFacesPerElementString() { return "numFacesPerElement"; }
    static constexpr char const * faceListString() { return "faceList"; }
    static constexpr char const * elementCenterString() { return "elementCenter"; }
    static constexpr char const * elementVolumeString() { return "elementVolume"; }
  };
 
  struct groupKeyStruct : public ObjectManagerBase::groupKeyStruct
  {
    static constexpr auto constitutiveModelsString() { return "ConstitutiveModels"; }
  };
 
private:
  dataRepository::Group m_constitutiveModels;
 
protected:
  localIndex m_numNodesPerElement;
 
  localIndex m_numEdgesPerElement;
 
  localIndex m_numFacesPerElement;
 
  array2d< real64 > m_elementCenter;
 
  array1d< real64 > m_elementVolume;
 
  ElementType m_elementType;
 
  template< class NODE_MAP >
  void calculateElementCenters( NODE_MAP const & toNodesRelation,
                                arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const & X ) const
  {
    arrayView2d< real64 > const & elementCenters = m_elementCenter;
    auto const e2n = toNodesRelation.toViewConst();
 
    forAll< parallelHostPolicy >( size(), [=]( localIndex const k )
    {
      LvArray::tensorOps::copy< 3 >( elementCenters[k], X[e2n( k, 0 )] );
      localIndex const numNodes = this->numNodesPerElement( k );
      for( localIndex a = 1; a < numNodes; ++a )
      {
        LvArray::tensorOps::add< 3 >( elementCenters[k], X[e2n( k, a )] );
      }
 
      LvArray::tensorOps::scale< 3 >( elementCenters[k], 1.0 / numNodes );
    } );
  }
};
 
} /* namespace geos */
 
#endif /* GEOS_MESH_ELEMENTSUBREGIONBASE_HPP_ */