Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include "IO/Observer/Initialize.hpp"
       7              : #include "IO/Observer/Tags.hpp"
       8              : #include "Parallel/Algorithms/AlgorithmGroup.hpp"
       9              : #include "Parallel/Algorithms/AlgorithmNodegroup.hpp"
      10              : #include "Parallel/ArrayComponentId.hpp"
      11              : #include "Parallel/GlobalCache.hpp"
      12              : #include "Parallel/ParallelComponentHelpers.hpp"
      13              : #include "Parallel/Phase.hpp"
      14              : #include "Parallel/PhaseDependentActionList.hpp"
      15              : #include "Parallel/Tags/InputSource.hpp"
      16              : #include "ParallelAlgorithms/Actions/TerminatePhase.hpp"
      17              : #include "Utilities/TMPL.hpp"
      18              : 
      19              : namespace observers {
      20              : /*!
      21              :  * \ingroup ObserversGroup
      22              :  * \brief The group parallel component that is responsible for reducing data
      23              :  * to be observed.
      24              :  *
      25              :  * Once the data from all elements on the processing element (usually a core)
      26              :  * has been collected, it is copied (not sent over the network) to the local
      27              :  * nodegroup parallel component, `ObserverWriter`, for writing to disk.
      28              :  */
      29              : template <class Metavariables>
      30            1 : struct Observer {
      31            0 :   using chare_type = Parallel::Algorithms::Group;
      32            0 :   static constexpr bool checkpoint_data = false;
      33            0 :   using metavariables = Metavariables;
      34            0 :   using phase_dependent_action_list = tmpl::list<
      35              :       Parallel::PhaseActions<Parallel::Phase::Initialization,
      36              :                              tmpl::list<Actions::Initialize<Metavariables>,
      37              :                                         Parallel::Actions::TerminatePhase>>>;
      38            0 :   using simple_tags_from_options = Parallel::get_simple_tags_from_options<
      39              :       Parallel::get_initialization_actions_list<phase_dependent_action_list>>;
      40              : 
      41            0 :   static void execute_next_phase(
      42              :       const Parallel::Phase /*next_phase*/,
      43              :       Parallel::CProxy_GlobalCache<Metavariables>& /*global_cache*/) {}
      44              : };
      45              : 
      46              : /*!
      47              :  * \ingroup ObserversGroup
      48              :  * \brief The nodegroup parallel component that is responsible for writing data
      49              :  * to disk.
      50              :  */
      51              : template <class Metavariables>
      52            1 : struct ObserverWriter {
      53            0 :   using chare_type = Parallel::Algorithms::Nodegroup;
      54            0 :   static constexpr bool checkpoint_data = false;
      55            0 :   using const_global_cache_tags =
      56              :       tmpl::list<Tags::ReductionFileName, Tags::VolumeFileName,
      57              :                  ::Parallel::Tags::InputSource>;
      58            0 :   using metavariables = Metavariables;
      59            0 :   using phase_dependent_action_list = tmpl::list<Parallel::PhaseActions<
      60              :       Parallel::Phase::Initialization,
      61              :       tmpl::list<Actions::InitializeWriter<Metavariables>,
      62              :                  Parallel::Actions::TerminatePhase>>>;
      63            0 :   using simple_tags_from_options = Parallel::get_simple_tags_from_options<
      64              :       Parallel::get_initialization_actions_list<phase_dependent_action_list>>;
      65              : 
      66            0 :   static void execute_next_phase(
      67              :       const Parallel::Phase /*next_phase*/,
      68              :       Parallel::CProxy_GlobalCache<Metavariables>& /*global_cache*/) {}
      69              : };
      70              : }  // namespace observers