turbine_interface.hpp

Go to the documentation of this file.

#pragma once
 
#include "interfaces/components/aerodynamics.hpp"
#include "interfaces/components/aerodynamics_input.hpp"
#include "interfaces/components/controller_input.hpp"
#include "interfaces/components/turbine.hpp"
#include "interfaces/host_state.hpp"
#include "interfaces/outputs.hpp"
#include "model/model.hpp"
#include "step/step_parameters.hpp"
#include "utilities/controllers/turbine_controller.hpp"
 
namespace kynema::interfaces::components {
struct SolutionInput;
struct TurbineInput;
}  // namespace kynema::interfaces::components
 
namespace kynema::interfaces {
 
class TurbineInterface {
public:
    using DeviceType =
        Kokkos::Device<Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space>;
 
    explicit TurbineInterface(
        const components::SolutionInput& solution_input,
        const components::TurbineInput& turbine_input,
        const components::AerodynamicsInput& aerodynamics_input = {},
        const components::ControllerInput& controller_input = {}
    );
 
    [[nodiscard]] components::Turbine& Turbine();
 
    void UpdateAerodynamicLoads(
        double fluid_density,
        const std::function<std::array<double, 3>(const std::array<double, 3>&)>& inflow_function
    );
 
    [[nodiscard]] bool Step();
 
    void SaveState();
 
    void RestoreState();
 
    Model& GetModel() { return model; }
 
    HostState<DeviceType>& GetHostState() { return host_state; }
 
    [[nodiscard]] double CalculateAzimuthAngle() const;
 
    [[nodiscard]] double CalculateRotorSpeed() const;
 
private:
    Model model;                    
    components::Turbine turbine;    
    State<DeviceType> state;        
    Elements<DeviceType> elements;  
    Constraints<DeviceType> constraints;  
    StepParameters parameters;            
    Solver<DeviceType> solver;            
    State<DeviceType> state_save;         
    HostState<DeviceType> host_state;     
    std::unique_ptr<Outputs> outputs;     
    std::unique_ptr<util::TurbineController> controller;     
    std::unique_ptr<components::Aerodynamics> aerodynamics;  
 
    void WriteRotorTimeSeriesData();
 
    void InitializeController(
        const components::TurbineInput& turbine_input,
        const components::SolutionInput& solution_input
    );
 
    void ApplyController();
 
    void UpdateControllerInputs();
};
 
}  // namespace kynema::interfaces