StatisticsAggregatorBase.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 SRC_CORECOMPONENTS_PHYSICSSOLVERS_STATISTICSAGGREGATOR_HPP_
#define SRC_CORECOMPONENTS_PHYSICSSOLVERS_STATISTICSAGGREGATOR_HPP_
 
#include "common/DataTypes.hpp"
#include "dataRepository/DataContext.hpp"
#include "dataRepository/Group.hpp"
#include "mesh/CellElementRegion.hpp"
#include "mesh/MeshBody.hpp"
#include "mesh/MeshLevel.hpp"
 
namespace geos
{
 
class RegionStatisticsBase : public dataRepository::Group
{
public:
 
  real64 m_time;
 
  RegionStatisticsBase( string const & targetName,
                        dataRepository::Group * const parent,
                        bool statsOutputEnabled );
 
  string_view getTargetName() const
  { return getName(); }
 
};
 
template< typename T >
struct StatsAggregatorTraits;
 
template< typename Impl >
class StatsAggregatorBase
{
public:
 
  using SolverType = typename StatsAggregatorTraits< Impl >::SolverType;
 
  using StatsGroupType = typename StatsAggregatorTraits< Impl >::StatsGroupType;
 
  template< typename OwnerType >
  using RegionStatsFunc = std::function< void ( OwnerType &,
                                                StatsGroupType & ) >;
 
  using RegionStatsRegisterFunc = std::function< StatsGroupType & ( dataRepository::Group &,
                                                                    string const & ) >;
 
  struct ViewKeys
  {
    constexpr static char const * statisticsString() { return "statistics"; }
    constexpr static char const * regionsStatisticsString() { return "regionsStatistics"; }
  };
 
  StatsAggregatorBase( dataRepository::DataContext const & ownerDataContext,
                       dataRepository::Group & meshBodies,
                       bool statsOutputEnabled );
 
  void initStatisticsAggregation( SolverType & solver );
 
  void forRegionStatistics( RegionStatsFunc< MeshLevel > const & functor ) const;
 
  void forRegionStatistics( MeshLevel & mesh,
                            StatsGroupType & meshRegionsStatistics,
                            RegionStatsFunc< CellElementRegion > const & functor ) const;
 
  void forRegionStatistics( CellElementRegion & region,
                            StatsGroupType & regionStatistics,
                            RegionStatsFunc< CellElementSubRegion > const & functor ) const;
 
  bool isComputed( real64 const timeRequest, StatsGroupType const & stats );
 
  void setDirty();
 
  bool computeRegionsStatistics( real64 const timeRequest );
 
  string const & getOwnerName() const
  { return m_ownerDataContext.getTargetName(); }
 
  stdVector< string > const & getWarnings() const
  { return m_warnings; }
 
  dataRepository::Group & getInstanceStatisticsGroup( MeshLevel & mesh ) const;
 
  StatsGroupType & getRegionsStatistics( MeshLevel & mesh ) const;
 
  StatsGroupType & getRegionStatistics( MeshLevel & mesh, string_view regionName ) const;
 
protected:
 
  struct StatsState
  {
    bool m_isEnabled = false;
    bool m_isDirty = false;
  };
 
  struct DiscretizationGroupPath
  {
    localIndex m_meshBody;
    localIndex m_meshLevel;
    string_array m_regionNames;
  };
 
  dataRepository::DataContext const & m_ownerDataContext;
 
  bool const m_statsOutputEnabled;
 
  dataRepository::Group & m_meshBodies;
 
  stdVector< DiscretizationGroupPath > m_discretizationsPaths;
 
  stdVector< string > m_warnings;
 
  StatsState m_regionStatsState;
 
  void enableRegionStatisticsAggregation( RegionStatsRegisterFunc && registerStatsFunc );
 
  MeshLevel & getMeshLevel( DiscretizationGroupPath const & path ) const;
 
  void initStats( StatsGroupType & stats, real64 time ) const
  { static_cast< Impl const * >(this)->initStats( stats, time ); }
 
  void computeSubRegionRankStats( CellElementSubRegion & subRegion, StatsGroupType & subRegionStats ) const
  { static_cast< Impl const * >(this)->computeSubRegionRankStats( subRegion, subRegionStats ); }
 
  void aggregateStats( StatsGroupType & stats, StatsGroupType const & other ) const
  { static_cast< Impl const * >(this)->aggregateStats( stats, other ); }
 
  void mpiAggregateStats( StatsGroupType & stats ) const
  { static_cast< Impl const * >(this)->mpiAggregateStats( stats ); }
 
  void postAggregateStats( StatsGroupType & stats )
  { static_cast< Impl * >(this)->postAggregateStats( stats ); }
 
};
 
} /* namespace geos */
 
#endif /* SRC_CORECOMPONENTS_PHYSICSSOLVERS_STATISTICSAGGREGATOR_HPP_ */