MeshForLoopInterface.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_MESHFORLOOPINTERFACE_HPP
#define GEOS_MESH_MESHFORLOOPINTERFACE_HPP
 
#include "finiteElement/FiniteElementDiscretization.hpp"
#include "finiteElement/FiniteElementDiscretizationManager.hpp"
#include "common/GEOS_RAJA_Interface.hpp"
 
#include "common/DataTypes.hpp"
#include "mesh/MeshLevel.hpp"
 
namespace geos
{
 
template< class POLICY=serialPolicy, typename LAMBDA=void >
void forAllElemsInMesh( MeshLevel const & mesh, LAMBDA && lambda )
{
 
  ElementRegionManager const & elemManager = mesh.getElemManager();
  elemManager.forElementSubRegionsComplete< ElementSubRegionBase >( [&] ( localIndex const er,
                                                                          localIndex const esr,
                                                                          ElementRegionBase const &,
                                                                          ElementSubRegionBase const & subRegion )
  {
    forAll< POLICY >( subRegion.size(), [&]( localIndex const k ) { lambda( er, esr, k ); } );
  } );
}
 
template< typename LAMBDA >
auto
minLocOverElemsInMesh( MeshLevel const & mesh, LAMBDA && lambda )
{
  using NUMBER = decltype( lambda( 0, 0, 0 ) );
 
  NUMBER minVal = std::numeric_limits< NUMBER >::max();
  localIndex minReg = -1, minSubreg = -1, minIndex = -1;
 
  ElementRegionManager const & elemManager = mesh.getElemManager();
 
  for( localIndex er = 0; er < elemManager.numRegions(); ++er )
  {
    ElementRegionBase const & elemRegion = elemManager.getRegion( er );
 
    elemRegion.forElementSubRegionsIndex< ElementSubRegionBase >( [&]( localIndex const esr, ElementSubRegionBase const & subRegion )
    {
      localIndex const size = subRegion.size();
      for( localIndex k = 0; k < size; ++k )
      {
        NUMBER const val = lambda( er, esr, k );
        if( val < minVal )
        {
          minVal = val;
          minReg = er;
          minSubreg = esr;
          minIndex = k;
        }
      }
    } );
  }
 
  return std::make_pair( minVal, std::make_tuple( minReg, minSubreg, minIndex ));
}
 
template< typename LAMBDA >
auto
minLocOverElemsInRegion( ElementRegionBase const & region, LAMBDA && lambda )
{
  using NUMBER = decltype( lambda( 0, 0 ) );
 
  NUMBER minVal = std::numeric_limits< NUMBER >::max();
  localIndex minSubreg = -1, minIndex = -1;
 
  region.forElementSubRegionsIndex< ElementSubRegionBase >( [&]( localIndex const esr, ElementSubRegionBase const & subRegion )
  {
    localIndex const size = subRegion.size();
    for( localIndex k = 0; k < size; ++k )
    {
      NUMBER const val = lambda( esr, k );
      if( val < minVal )
      {
        minVal = val;
        minSubreg = esr;
        minIndex = k;
      }
    }
  } );
 
  return std::make_pair( minVal, std::make_tuple( minSubreg, minIndex ));
}
 
template< typename LAMBDA >
auto
minLocOverElemsInSubRegion( ElementSubRegionBase const & subRegion, LAMBDA && lambda )
{
  using NUMBER = decltype( lambda( 0 ) );
 
  NUMBER minVal = std::numeric_limits< NUMBER >::max();
  localIndex minIndex = -1;
 
  localIndex const size = subRegion.size();
  for( localIndex k = 0; k < size; ++k )
  {
    NUMBER const val = lambda( k );
    if( val < minVal )
    {
      minVal = val;
      minIndex = k;
    }
  }
 
  return std::make_pair( minVal, minIndex );
}
 
} // namespace geos
 
#endif // GEOS_MESH_MESHFORLOOPINTERFACE_HPP