Line data Source code
1 0 : // Distributed under the MIT License.
2 : // See LICENSE.txt for details.
3 :
4 : #pragma once
5 :
6 : #include <array>
7 : #include <cstddef>
8 : #include <memory>
9 : #include <optional>
10 : #include <string>
11 : #include <tuple>
12 : #include <vector>
13 :
14 : #include "ControlSystem/Component.hpp"
15 : #include "DataStructures/DataVector.hpp"
16 : #include "Domain/FunctionsOfTime/FunctionOfTime.hpp"
17 : #include "Domain/FunctionsOfTime/QuaternionFunctionOfTime.hpp"
18 : #include "IO/Observer/ReductionActions.hpp"
19 : #include "Parallel/GlobalCache.hpp"
20 : #include "Parallel/Info.hpp"
21 : #include "Parallel/Invoke.hpp"
22 :
23 : namespace control_system {
24 : /*!
25 : * \ingroup ControlSystemGroup
26 : * \brief Writes all components of a function of time to disk at a specific time
27 : * from a control system after it updates the functions of time.
28 : *
29 : * \details The columns of data written are:
30 : * - %Time
31 : * - FunctionOfTime
32 : * - dtFunctionOfTime
33 : * - d2tFunctionOfTime
34 : * - ControlError
35 : * - dtControlError
36 : * - DampingTimescale
37 : *
38 : * Data will be stored in the reduction file. All subfiles for the control
39 : * system within the H5 file will be under the group "/ControlSystems".
40 : * Within this group, there will be one group for each control system. The name
41 : * of each group will be the result of the `name()` function from each control
42 : * system. An example would look like
43 : *
44 : * - /ControlSystems/SystemA
45 : * - /ControlSystems/SystemB
46 : * - /ControlSystems/SystemC
47 : *
48 : * Then, within each system group, there will be one subfile for each component
49 : * of the function of time that is being controlled. The name of this subfile is
50 : * the name of the component. The name of each component will be the result of
51 : * the `component_name(i)` function from the control system, where `i` is the
52 : * index of the component. For example, if "SystemA" has 3 components with names
53 : * "X", "Y", and "Z", then the subfiles would look like
54 : *
55 : * - /ControlSystems/SystemA/X.dat
56 : * - /ControlSystems/SystemA/Y.dat
57 : * - /ControlSystems/SystemA/Z.dat
58 : */
59 : template <typename ControlSystem, typename Metavariables>
60 1 : void write_components_to_disk(
61 : const double time, Parallel::GlobalCache<Metavariables>& cache,
62 : const std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>&
63 : function_of_time,
64 : const std::array<DataVector, 2>& q_and_dtq, const DataVector& timescales) {
65 : auto& observer_writer_proxy = Parallel::get_parallel_component<
66 : observers::ObserverWriter<Metavariables>>(cache);
67 :
68 : constexpr size_t deriv_order = ControlSystem::deriv_order;
69 : std::array<DataVector, 3> function_at_current_time{};
70 : const auto* const quat_func_of_time = dynamic_cast<
71 : const domain::FunctionsOfTime::QuaternionFunctionOfTime<deriv_order>*>(
72 : function_of_time.get());
73 : if (quat_func_of_time == nullptr) {
74 : // Just call the usual `func_and_2_derivs` member.
75 : function_at_current_time = function_of_time->func_and_2_derivs(time);
76 : } else {
77 : // If we are working with a QuaternionFunctionOfTime, we aren't actually
78 : // controlling a quaternion. We are controlling a small change in angle
79 : // associated with the angular velocity in each direction. Because of this,
80 : // we want to write the component data of the thing we are actually
81 : // controlling. This is accessed by the `angle_func_and_2_derivs` member of
82 : // a QuaternionFunctionOfTime. Since `angle_func_and_2_derivs` is not a
83 : // virtual function of the FunctionOfTime base class, we need to down cast
84 : // the original function to a QuaternionFunctionOfTime.
85 : function_at_current_time = quat_func_of_time->angle_func_and_2_derivs(time);
86 : }
87 :
88 : // Each control system is its own group under the overarching `ControlSystems`
89 : // group. There is a different subfile for each component, so loop over them.
90 : // Eg. translation files will look like
91 : //
92 : // ControlSystems/Translation/X.dat
93 : // ControlSystems/Translation/Y.dat
94 : // ControlSystems/Translation/Z.dat
95 : const size_t num_components = function_at_current_time[0].size();
96 : for (size_t i = 0; i < num_components; ++i) {
97 : const std::optional<std::string> component_name_opt =
98 : ControlSystem::component_name(i, num_components);
99 : if (not component_name_opt) {
100 : continue;
101 : }
102 : // Currently all reduction data is written to the reduction file so preface
103 : // everything with ControlSystems/
104 : const std::string subfile_name{"/ControlSystems/" + ControlSystem::name() +
105 : "/" + *component_name_opt};
106 : std::vector<std::string> legend{"Time",
107 : "FunctionOfTime",
108 : "dtFunctionOfTime",
109 : "d2tFunctionOfTime",
110 : "ControlError",
111 : "dtControlError",
112 : "DampingTimescale"};
113 :
114 : Parallel::threaded_action<
115 : observers::ThreadedActions::WriteReductionDataRow>(
116 : // Node 0 is always the writer
117 : observer_writer_proxy[0], subfile_name, std::move(legend),
118 : std::make_tuple(
119 : // clang-format off
120 : time,
121 : function_at_current_time[0][i],
122 : function_at_current_time[1][i],
123 : function_at_current_time[2][i],
124 : q_and_dtq[0][i],
125 : q_and_dtq[1][i],
126 : timescales[i])
127 : // clang-format on
128 : );
129 : }
130 : }
131 : } // namespace control_system
|
