Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <iosfwd>
       7              : #include <vector>
       8              : 
       9              : /// \cond
      10              : namespace Options {
      11              : class Option;
      12              : template <typename T>
      13              : struct create_from_yaml;
      14              : }  // namespace Options
      15              : /// \endcond
      16              : 
      17              : namespace Parallel {
      18              : 
      19              : /*!
      20              :  * \ingroup ParallelGroup
      21              :  * \brief The possible phases of an executable
      22              :  *
      23              :  * \details Spectre executables are split into distinct phases separated by
      24              :  * global synchronizations.  Each executable will start with phase
      25              :  * `Initialization` and end with phase `Exit`.  The metavariables of each
      26              :  * executable must define `default_phase_order`, an array of Parallel::Phase
      27              :  * that must contain at least `Initialization` as the first element and `Exit`
      28              :  * as the last element.  Usually the next phase is determined from the
      29              :  * `default_phase_order` provided by the metavariables.  If more complex
      30              :  * decision making is desired, use the PhaseControl infrastructure.
      31              :  *
      32              :  * \warning The phases are in alphabetical order.  Do not use the values of the
      33              :  * underlying integral type as they will change as new phases are added to the
      34              :  * list!
      35              :  *
      36              :  * \see PhaseChange and \ref dev_guide_parallelization_foundations
      37              :  * "Parallelization infrastructure" for details.
      38              :  *
      39              :  */
      40            1 : enum class Phase {
      41              :   // If you add a new phase: put it in the list alphabetically, add it to the
      42              :   // vector created by known_phases() below, and add it to the stream operator
      43              :   // If the new phase is the first or last in the list, update Test_Phase.
      44              : 
      45              :   ///  phase in which AMR adjusts the domain
      46              :   AdjustDomain,
      47              :   ///  phase in which elliptic problems construct a matrix representation
      48              :   BuildMatrix,
      49              :   ///  phase in which sanity checks are done after AMR
      50              :   CheckDomain,
      51              :   ///  a cleanup phase
      52              :   Cleanup,
      53              :   ///  a phase in which the rotation control system is disable and the
      54              :   ///  rotation function of time is switched to settling to a constant.
      55              :   DisableRotationControl,
      56              :   ///  phase in which AMR criteria are evaluated
      57              :   EvaluateAmrCriteria,
      58              :   ///  phase in which time steps are taken for an evolution executable
      59              :   Evolve,
      60              :   ///  generic execution phase of an executable
      61              :   Execute,
      62              :   ///  final phase of an executable
      63              :   Exit,
      64              :   ///  phase in which initial data is imported from volume files
      65              :   ImportInitialData,
      66              :   ///  initial phase of an executable
      67              :   Initialization,
      68              :   ///  phase in which quantities dependent on imported initial data are
      69              :   ///  initialized
      70              :   InitializeInitialDataDependentQuantities,
      71              :   ///  phase in which the time stepper executes a self-start procedure
      72              :   InitializeTimeStepperHistory,
      73              :   ///  phase in which components are migrated
      74              :   LoadBalancing,
      75              :   ///  phase in which components know an error occurred and they need to do some
      76              :   ///  sort of cleanup, such as dumping data to disk.
      77              :   PostFailureCleanup,
      78              :   ///  phase in which components register with other components
      79              :   Register,
      80              :   ///  phase in which components register with the data importer components
      81              :   RegisterWithElementDataReader,
      82              :   ///  phase run after a checkpoint-restart
      83              :   Restart,
      84              :   ///  phase in which something is solved
      85              :   Solve,
      86              :   ///  phase in which something is tested
      87              :   Testing,
      88              :   ///  phase in which options are changed after restart
      89              :   UpdateOptionsAtRestartFromCheckpoint,
      90              :   ///  phase in which array sections are updated
      91              :   UpdateSections,
      92              :   ///  phase in which checkpoint files are written to disk
      93              :   WriteCheckpoint
      94              : };
      95              : 
      96            0 : std::vector<Phase> known_phases();
      97              : 
      98              : /// Output operator for a Phase.
      99            1 : std::ostream& operator<<(std::ostream& os, const Phase& phase);
     100              : }  // namespace Parallel
     101              : 
     102              : template <>
     103            0 : struct Options::create_from_yaml<Parallel::Phase> {
     104              :   template <typename Metavariables>
     105            0 :   static Parallel::Phase create(const Options::Option& options) {
     106              :     return create<void>(options);
     107              :   }
     108              : };
     109              : 
     110              : template <>
     111            0 : Parallel::Phase Options::create_from_yaml<Parallel::Phase>::create<void>(
     112              :     const Options::Option& options);