Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <string>
       7              : #include <vector>
       8              : 
       9              : #include "ControlSystem/Actions/PrintCurrentMeasurement.hpp"
      10              : #include "Domain/FunctionsOfTime/Tags.hpp"
      11              : #include "Evolution/Deadlock/PrintDgElementArray.hpp"
      12              : #include "Evolution/Deadlock/PrintFunctionsOfTime.hpp"
      13              : #include "Parallel/ArrayCollection/IsDgElementCollection.hpp"
      14              : #include "Parallel/ArrayCollection/SimpleActionOnElement.hpp"
      15              : #include "Parallel/GlobalCache.hpp"
      16              : #include "Parallel/Invoke.hpp"
      17              : #include "ParallelAlgorithms/ApparentHorizonFinder/PrintDeadlockAnalysis.hpp"
      18              : #include "ParallelAlgorithms/Interpolation/Actions/PrintInterpolationTargetForDeadlock.hpp"
      19              : #include "Utilities/FileSystem.hpp"
      20              : #include "Utilities/PrettyType.hpp"
      21              : #include "Utilities/TMPL.hpp"
      22              : 
      23              : /// \cond
      24              : namespace intrp {
      25              : template <class Metavariables, typename InterpolationTargetTag>
      26              : struct InterpolationTarget;
      27              : }  // namespace intrp
      28              : namespace observers {
      29              : template <class Metavariables>
      30              : struct ObserverWriter;
      31              : }  // namespace observers
      32              : /// \endcond
      33              : 
      34            0 : namespace gh::deadlock {
      35              : template <typename DgElementArray, typename ControlComponents,
      36              :           typename InterpolationTargetTags, typename AhFinders,
      37              :           typename Metavariables>
      38            0 : void run_deadlock_analysis_simple_actions(
      39              :     Parallel::GlobalCache<Metavariables>& cache,
      40              :     const std::vector<std::string>& deadlocked_components) {
      41              :   const std::string deadlock_dir{"deadlock"};
      42              :   if (file_system::check_if_dir_exists(deadlock_dir)) {
      43              :     file_system::rm(deadlock_dir, true);
      44              :   }
      45              : 
      46              :   file_system::create_directory(deadlock_dir);
      47              : 
      48              :   Parallel::simple_action<::deadlock::PrintFunctionsOfTime>(
      49              :       Parallel::get_parallel_component<
      50              :           observers::ObserverWriter<Metavariables>>(cache),
      51              :       deadlock_dir + "/functions_of_time.out");
      52              : 
      53              :   {
      54              :     auto cache_proxy = cache.get_this_proxy();
      55              : 
      56              :     cache_proxy.print_mutable_cache_callbacks(deadlock_dir +
      57              :                                               "/mutable_cache_callbacks.out");
      58              :   }
      59              : 
      60              :   if constexpr (tmpl::size<InterpolationTargetTags>::value > 0) {
      61              :     const std::string intrp_target_file =
      62              :         deadlock_dir + "/interpolation_targets.out";
      63              :     tmpl::for_each<InterpolationTargetTags>(
      64              :         [&cache, &intrp_target_file](const auto tag_v) {
      65              :           using TargetTag = tmpl::type_from<decltype(tag_v)>;
      66              : 
      67              :           Parallel::simple_action<::deadlock::PrintInterpolationTarget>(
      68              :               Parallel::get_parallel_component<
      69              :                   intrp::InterpolationTarget<Metavariables, TargetTag>>(cache),
      70              :               intrp_target_file);
      71              :         });
      72              :   }
      73              : 
      74              :   if constexpr (tmpl::size<AhFinders>::value > 0) {
      75              :     tmpl::for_each<AhFinders>([&cache,
      76              :                                &deadlock_dir](const auto horizon_metavars_v) {
      77              :       using HorizonMetavars = tmpl::type_from<decltype(horizon_metavars_v)>;
      78              :       const std::string ah_finder_file =
      79              :           deadlock_dir + "/" + pretty_type::name<HorizonMetavars>() + ".out";
      80              :       Parallel::simple_action<ah::Actions::PrintDeadlockAnalysis>(
      81              :           Parallel::get_parallel_component<
      82              :               ah::Component<Metavariables, HorizonMetavars>>(cache),
      83              :           ah_finder_file);
      84              :     });
      85              :   }
      86              : 
      87              :   if (alg::count(deadlocked_components, pretty_type::name<DgElementArray>()) ==
      88              :       1) {
      89              :     if constexpr (tmpl::size<ControlComponents>::value > 0) {
      90              :       tmpl::for_each<ControlComponents>(
      91              :           [&cache, &deadlock_dir](auto component_v) {
      92              :             using component = tmpl::type_from<decltype(component_v)>;
      93              :             Parallel::simple_action<
      94              :                 control_system::Actions::PrintCurrentMeasurement>(
      95              :                 Parallel::get_parallel_component<component>(cache),
      96              :                 deadlock_dir + "/control_systems.out");
      97              :           });
      98              :     }
      99              : 
     100              :     const std::string element_array_file =
     101              :         deadlock_dir + "/dg_element_array.out";
     102              :     if constexpr (Parallel::is_dg_element_collection_v<DgElementArray>) {
     103              :       Parallel::threaded_action<Parallel::Actions::SimpleActionOnElement<
     104              :           ::deadlock::PrintElementInfo, true>>(
     105              :           Parallel::get_parallel_component<DgElementArray>(cache),
     106              :           element_array_file);
     107              :     } else {
     108              :       Parallel::simple_action<::deadlock::PrintElementInfo>(
     109              :           Parallel::get_parallel_component<DgElementArray>(cache),
     110              :           element_array_file);
     111              :     }
     112              :   }
     113              : }
     114              : }  // namespace gh::deadlock