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,
                        string_view setName,
                        bool dataOutputEnabled );
 
  string_view getTargetName() const
  { return getName(); }
 
  string_view getSetName() const
  { return m_setName; }
 
private:
  string const m_setName;
};
 
template< typename T >
struct StatsAggregatorTraits;
 
template< typename Impl >
class StatsAggregatorBase
{
public:
 
  using SolverType = typename StatsAggregatorTraits< Impl >::SolverType;
 
  using StatsGroupType = typename StatsAggregatorTraits< Impl >::StatsGroupType;
 
  using SetType = SortedArray< localIndex >;
 
  using SetViewType = SortedArrayView< localIndex const >;
 
  template< typename OwnerType >
  using RegionStatsFunc = std::function< void ( OwnerType,
                                                StatsGroupType & ) >;
 
  using RegionStatsRegisterFunc = std::function< StatsGroupType & ( dataRepository::Group &,
                                                                    string const &,
                                                                    string_view,
                                                                    bool ) >;
 
  struct ViewKeys
  {
    constexpr static string_view statisticsString() { return "statistics"; }
    constexpr static string_view setsStatisticsString() { return "setsStatistics"; }
    constexpr static string_view compoundSetNameString() { return "__compound"; }
  };
 
  struct MeshLevelSet
  {
    MeshLevel & mesh;
    string_view setName;
  };
 
  StatsAggregatorBase( dataRepository::DataContext const & ownerDataContext,
                       dataRepository::Group & meshBodies,
                       bool statsOutputEnabled );
 
  void initStatisticsAggregation( SolverType & solver );
 
  void setDirty();
 
  bool computeRegionsStatistics( real64 const timeRequest );
 
 
  void forRegionStatistics( RegionStatsFunc< MeshLevel & > const & functor ) const;
 
  void forRegionStatistics( MeshLevel & mesh,
                            StatsGroupType & meshSetsStats,
                            bool enableCompoundSet,
                            RegionStatsFunc< MeshLevelSet > const & functor ) const;
 
  void forRegionStatistics( MeshLevelSet meshSet,
                            StatsGroupType & setStats,
                            RegionStatsFunc< CellElementRegion & > const & functor ) const;
 
  void forRegionStatistics( CellElementRegion & region,
                            StatsGroupType & setRegionStats,
                            RegionStatsFunc< CellElementSubRegion & > const & functor ) const;
 
  dataRepository::Group & getInstanceStatisticsGroup( MeshLevel & mesh ) const;
 
  StatsGroupType & getMeshLevelStatistics( MeshLevel & mesh ) const;
 
  StatsGroupType & getSetStatistics( MeshLevel & mesh, string_view setName = "" ) const;
 
  StatsGroupType & getRegionStatistics( MeshLevel & mesh, string_view regionName, string_view setName = "" ) const;
 
 
  bool isComputed( real64 const timeRequest, StatsGroupType const & stats );
 
  bool isRestrictedToSets()
  {return !( m_setNames.empty() || ( m_setNames.size() == 1 && m_setNames.count( "all" ) > 0 ) ); }
 
  bool isTargetingMultipleSets()
  { return m_setNames.size() > 1; }
 
  string const & getOwnerName() const
  { return m_ownerDataContext.getTargetName(); }
 
  stdVector< string > const & getWarnings() const
  { return m_warnings; }
 
protected:
 
  struct StatsState
  {
    bool m_isEnabled = false;
    bool m_isDirty = false;
  };
 
  using SetsCompound = stdMap< string, stdMap< string, SetType > >;
 
  struct DiscretizationSetPath
  {
    localIndex m_meshBody;
    localIndex m_meshLevel;
    string_array m_setNames;
    string_array m_regionNames;
    SetsCompound m_setsCompound;
  };
 
  dataRepository::DataContext const & m_ownerDataContext;
 
  bool const m_dataOutputEnabled;
 
  dataRepository::Group & m_meshBodies;
 
  stdVector< DiscretizationSetPath > m_discretizationsPaths;
 
  std::set< string > m_setNames;
 
  bool m_isAnySetsIntersecting;
 
  stdVector< string > m_warnings;
 
  StatsState m_regionStatsState;
 
  void enableRegionStatisticsAggregation( RegionStatsRegisterFunc && registerStatsFunc,
                                          string_array const & setNames );
 
  MeshLevel & getMeshLevel( DiscretizationSetPath const & path ) const;
 
  StatsGroupType & getCompoundSetStatistics( MeshLevel & mesh ) const;
 
  bool isCompoundSetStatistics( StatsGroupType const & stats ) const;
 
  static std::set< string > getMeshLevelPartialSetNames( MeshLevel const & mesh,
                                                         string_array const & regionNames );
 
  void setTargetSets( string_array const & setNames );
 
  void initStats( StatsGroupType & stats, real64 time ) const
  { static_cast< Impl const * >(this)->initStats( stats, time ); }
 
  void computeSubRegionRankStats( CellElementSubRegion & subRegion,
                                  StatsGroupType & subRegionStats,
                                  SetType const & targetSet ) const
  { static_cast< Impl const * >(this)->computeSubRegionRankStats( subRegion, subRegionStats, targetSet ); }
 
  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_ */