control_system::protocols::ControlSystem Struct Reference

Definition of a control system. More...

#include <ControlSystem.hpp>

Classes
struct	test

Detailed Description

Definition of a control system.

Defines a control system for controlling a FunctionOfTime.

A conforming class must provide the following functionality:

• a static function name returning a std::string. This corresponds to the name of the FunctionOfTime controlled by this system.
• a static function component_name returning a std::optional<std::string>. This gives a name associated to each component of the FunctionOfTime that is being controlled. E.g. a FunctionOfTime controlling translation will have three components with names "X", "Y", and "Z". This is useful when writing data to disk. The reason this is a std::optional rather than just a std::string is because of shape control. Since the vector of coefficients of the shape map is stored in ylm::Spherepack order, not all components of this vector correspond to an actual l,m pair (see ylm::Spherepack for why this is). Thus, this is a std::optional to signify if a component of the FunctionOfTime isn't actually used and shouldn't be written to disk.
• a type alias measurement to a struct implementing the Measurement protocol.
• a type alias simple_tags to a tmpl::list of simple tags needed for the control system. These tags will be added to the DataBox of the ControlComponent. The list may be empty.
• a type alias control_error to a struct that conforms to the ControlError protocol
• a static constexpr size_t deriv_order which is the order of the highest derivative of a FunctionOfTime that you wish to control. Typically, this is the order of the FunctionOfTime itself.

• a member struct (or type alias) process_measurement, defining the following:

  • a templated type alias argument_tags, which must produce a tmpl::list of tags when instantiated for any submeasurement of the control system's measurement.
  • a static function apply that accepts as arguments:
    • any submeasurement of the control system's measurement. For measurements with multiple submeasurements, this can be accomplished either by a template parameter or by overloading the function.
    • the values corresponding to argument_tags instantiated with the type of the first argument.
    • the global cache Parallel::GlobalCache<Metavariables>&
    • a const LinkedMessageId<double>& identifying the measurement, with the id field being the measurement time.

  The apply function will be called once for each submeasurement of the control system's measurement using data from the DataBox passed to RunCallbacks. It should communicate any necessary data to the control system singleton.

Here's an example for a class conforming to this protocol:

struct ExampleControlSystem
    : tt::ConformsTo<control_system::protocols::ControlSystem> {
  static std::string name() { return "ExampleControlSystem"; }
  static std::optional<std::string> component_name(
      const size_t i, const size_t num_components) {
    ASSERT(num_components == 3,
           "This control system expected 3 components but there are "
               << num_components << " instead.");
    return i == 0 ? "X" : (i == 1 ? "Y" : "Z");
  }
  using measurement = ExampleMeasurement;
 
  using simple_tags = tmpl::list<>;
 
  static constexpr size_t deriv_order = 2;
 
  using control_error = ExampleControlError;
 
  // This is not part of the required interface, but is used by this
  // control system to store the measurement data.  Most control
  // systems will do something like this.
  struct ExampleSubmeasurementQueueTag {
    using type = double;
  };
 
  // As with the previous struct, this is not part of the required
  // interface.
  struct MeasurementQueue : db::SimpleTag {
    using type =
        LinkedMessageQueue<double, tmpl::list<ExampleSubmeasurementQueueTag>>;
  };
 
  struct process_measurement {
    template <typename Submeasurement>
    using argument_tags = tmpl::list<MeasurementResultTag>;
 
    template <typename Metavariables>
    static void apply(ExampleSubmeasurement /*meta*/,
                      const double measurement_result,
                      Parallel::GlobalCache<Metavariables>& cache,
                      const LinkedMessageId<double>& measurement_id) {
      // Process the submeasurement results and send whatever is
      // necessary to the control system component.  Usually calls
      // some simple action.
      auto& control_system_proxy = Parallel::get_parallel_component<
          ControlComponent<Metavariables, ExampleControlSystem>>(cache);
      Parallel::simple_action<::Actions::UpdateMessageQueue<
          MeasurementQueue, SomeControlSystemUpdater,
          ExampleSubmeasurementQueueTag>>(control_system_proxy, measurement_id,
                                          measurement_result);
    }
  };
};

---

The documentation for this struct was generated from the following file:

• src/ControlSystem/Protocols/ControlSystem.hpp