SourceFluxStatistics.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 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 SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_SOURCEFLUXSTATISTICS_HPP_
#define SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_SOURCEFLUXSTATISTICS_HPP_
 
#include "../FieldStatisticsBase.hpp"
#include "FlowSolverBase.hpp"
#include "mesh/DomainPartition.hpp"
 
 
namespace geos
{
 
class SourceFluxStatsAggregator final : public FieldStatisticsBase< FlowSolverBase >
{
public:
 
  struct StatData
  {
    array1d< real64 > m_producedMass;
    array1d< real64 > m_productionRate;
    integer m_elementCount = 0;
 
    void allocate( integer phaseCount );
    void reset();
    integer getPhaseCount() const
    { return m_producedMass.size(); }
    void combine( StatData const & other );
    void mpiReduce();
  };
  class WrappedStats
  {
public:
    void setTarget( string_view aggregatorName, string_view fluxName );
 
    void gatherTimeStepStats( real64 currentTime, real64 dt,
                              arrayView1d< real64 const > const & producedMass,
                              integer elementCount );
 
    void finalizePeriod();
 
    StatData & stats()
    { return m_stats; }
 
    StatData const & stats() const
    { return m_stats; }
 
    real64 getStatsPeriodStart() const
    { return m_statsPeriodStart; }
 
    real64 getStatsPeriodDuration() const
    { return m_statsPeriodDT; }
 
    string_view getAggregatorName() const
    { return m_aggregatorName; }
 
    string_view getFluxName() const
    { return m_fluxName; }
private:
    StatData m_stats;
    real64 m_statsPeriodStart;
    real64 m_statsPeriodDT;
 
    struct PeriodStats
    {
      array1d< real64 > m_timeStepMass;
      array1d< real64 > m_periodPendingMass;
      real64 m_timeStepStart = 0.0;
      real64 m_timeStepDeltaTime = 0.0;
      real64 m_periodStart = 0.0;
      real64 m_periodPendingDeltaTime = 0.0;
      integer m_elementCount = 0;
      bool m_isGathering = false;
 
      void allocate( integer phaseCount );
      void reset();
      integer getPhaseCount() const
      { return m_timeStepMass.size(); }
    } m_periodStats;
 
    string m_aggregatorName;
    string m_fluxName;
  };
 
 
  SourceFluxStatsAggregator( const string & name,
                             Group * const parent );
 
  static string catalogName() { return "SourceFluxStatistics"; }
 
  virtual bool execute( real64 const time_n,
                        real64 const dt,
                        integer const cycleNumber,
                        integer const eventCounter,
                        real64 const eventProgress,
                        DomainPartition & domain ) override;
 
  template< typename LAMBDA >
  void forMeshLevelStatsWrapper( DomainPartition & domain, LAMBDA && lambda );
  template< typename LAMBDA >
  void forAllFluxStatsWrappers( MeshLevel & meshLevel, LAMBDA && lambda );
  template< typename LAMBDA >
  void forAllRegionStatsWrappers( MeshLevel & meshLevel, string_view fluxName, LAMBDA && lambda );
  template< typename LAMBDA >
  void forAllSubRegionStatsWrappers( ElementRegionBase & region, string_view fluxName, LAMBDA && lambda );
 
  template< typename LAMBDA >
  static void forAllFluxStatWrappers( Group & container, string_view fluxName, LAMBDA && lambda );
 
  inline string getStatWrapperName( string_view fluxName ) const;
 
 
  struct viewKeyStruct
  {
    constexpr inline static string_view fluxNamesString() { return "fluxNames"; }
    constexpr inline static string_view allRegionWrapperString() { return "all_regions"; }
    constexpr inline static string_view fluxSetWrapperString() { return "flux_set"; }
  };
 
 
private:
  using Base = FieldStatisticsBase< FlowSolverBase >;
 
  string_array m_fluxNames;
 
  void registerDataOnMesh( Group & meshBodies ) override;
 
  void postInputInitialization() override;
 
  dataRepository::Wrapper< WrappedStats > & registerWrappedStats( Group & group,
                                                                  string_view fluxName,
                                                                  string_view elementSetName );
 
  void writeStatsToLog( integer minLogLevel, string_view elementSetName, WrappedStats const & stats );
  void writeStatsToCSV( string_view elementSetName, WrappedStats const & stats, bool writeHeader );
 
};
 
 
template< typename LAMBDA >
void SourceFluxStatsAggregator::forAllFluxStatWrappers( Group & container,
                                                        string_view fluxName,
                                                        LAMBDA && lambda )
{
  container.forWrappers< WrappedStats >( [&]( dataRepository::Wrapper< WrappedStats > & statsWrapper )
  {
    if( statsWrapper.referenceAsView().getFluxName() == fluxName )
    {
      lambda( statsWrapper.reference() );
    }
  } );
}
 
template< typename LAMBDA >
void SourceFluxStatsAggregator::forMeshLevelStatsWrapper( DomainPartition & domain,
                                                          LAMBDA && lambda )
{
  m_solver->forDiscretizationOnMeshTargets( domain.getMeshBodies(),
                                            [&] ( string const &,
                                                  MeshLevel & meshLevel,
                                                  arrayView1d< string const > const & )
  {
    string const wrapperName = getStatWrapperName( viewKeyStruct::fluxSetWrapperString() );
    WrappedStats & stats = meshLevel.getWrapper< WrappedStats >( wrapperName ).reference();
 
    lambda( meshLevel, stats );
  } );
}
template< typename LAMBDA >
void SourceFluxStatsAggregator::forAllFluxStatsWrappers( MeshLevel & meshLevel,
                                                         LAMBDA && lambda )
{
  for( string const & fluxName : m_fluxNames )
  {
    string const wrapperName = getStatWrapperName( fluxName );
    WrappedStats & stats = meshLevel.getWrapper< WrappedStats >( wrapperName ).reference();
 
    lambda( meshLevel, stats );
  }
}
template< typename LAMBDA >
void SourceFluxStatsAggregator::forAllRegionStatsWrappers( MeshLevel & meshLevel,
                                                           string_view fluxName,
                                                           LAMBDA && lambda )
{
  string const wrapperName = getStatWrapperName( fluxName );
  meshLevel.getElemManager().forElementRegions( [&]( ElementRegionBase & region )
  {
    WrappedStats & stats = region.getWrapper< WrappedStats >( wrapperName ).reference();
 
    lambda( region, stats );
  } );
}
template< typename LAMBDA >
void SourceFluxStatsAggregator::forAllSubRegionStatsWrappers( ElementRegionBase & region,
                                                              string_view fluxName,
                                                              LAMBDA && lambda )
{
  string const wrapperName = getStatWrapperName( fluxName );
  region.forElementSubRegions( [&]( ElementSubRegionBase & subRegion )
  {
    WrappedStats & stats = subRegion.getWrapper< WrappedStats >( wrapperName ).reference();
 
    lambda( subRegion, stats );
  } );
}
 
inline string SourceFluxStatsAggregator::getStatWrapperName( string_view fluxName ) const
{ return GEOS_FMT( "{}_region_stats_for_{}", fluxName, getName() ); }
 
 
} /* namespace geos */
 
#endif /* SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_SOURCEFLUXSTATISTICS_HPP_ */