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/outputs_config.hpp"
#include "interfaces/components/turbine.hpp"
#include "interfaces/host_constraints.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;
struct OutputsConfig;
}  // 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 = {},
        const components::OutputsConfig& outputs_config = {}
    );
 
    TurbineInterface(TurbineInterface& other) = delete;
 
    TurbineInterface(TurbineInterface&& other) = delete;
 
    TurbineInterface& operator=(const TurbineInterface&) = delete;
 
    TurbineInterface& operator=(TurbineInterface&&) = delete;
 
    ~TurbineInterface() = default;
 
    [[nodiscard]] components::Turbine& Turbine() { return this->turbine; }
 
    [[nodiscard]] components::Aerodynamics& Aerodynamics() {
        if (!aerodynamics) {
            throw std::runtime_error("Aerodynamics component not initialized in TurbineInterface.");
        }
        return *aerodynamics;
    }
 
    void UpdateAerodynamicLoads(
        double fluid_density,
        const std::function<std::array<double, 3>(const std::array<double, 3>&)>& inflow_function
    );
 
    std::array<double, 3> GetHubNodePosition() const;
 
    void SetHubInflow(const std::array<double, 3>& inflow);
 
    void ApplyController(double t);
 
    [[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;
 
    void WriteOutput();
 
    void OpenOutputFile();
 
    void CloseOutputFile();
 
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;     
    HostConstraints<DeviceType> host_constraints;         
    std::unique_ptr<Outputs> outputs;                     
    std::unique_ptr<util::TurbineController> controller;  
    std::unique_ptr<components::Aerodynamics> aerodynamics;  
    std::array<double, 3> hub_inflow{0., 0., 0.};            
 
    void WriteTimeSeriesData() const;
 
    void InitializeController(
        const components::TurbineInput& turbine_input,
        const components::SolutionInput& solution_input
    );
};
 
}  // namespace kynema::interfaces