stormbird 0.9.0

A library for modeling modern wind propulsion devices
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

// Copyright (C) 2024, NTNU
// Author: Jarle Vinje Kramer <jarlekramer@gmail.com; jarle.a.kramer@ntnu.no>
// License: GPL v3.0 (see separate file LICENSE or https://www.gnu.org/licenses/gpl-3.0.html)

//! Implementations of a controller for wind propulsion devices intended to be used together
//! with the simulation models in the library. 

pub mod builder;
pub mod input;
pub mod output;
pub mod measurements;
pub mod set_points;
pub mod prelude;

use input::ControllerInput;
use output::ControllerOutput;
use set_points::ControllerSetPoints;
use measurements::FlowMeasurementSettings;

use stormath::type_aliases::Float;

#[derive(Debug, Clone)]
pub struct Controller {
    /// Vector containing the set points for all the sails
    pub set_points: Vec<ControllerSetPoints>,
    /// Structure defining how to measure the representative flow conditions on the sail
    pub flow_measurement_settings: FlowMeasurementSettings,
    /// How often to update the controller
    pub time_steps_between_updates: usize,
    /// When to start using the controller
    pub start_time: Float,
    /// Internal variable to keep track of the number of time steps executed
    pub time_step_index: usize,
    /// Switch to determine which velocity to use when measuring the apparent wind direction
    pub use_input_velocity_for_apparent_wind_direction: bool,
}

impl Controller {
    pub fn update(
        &self,
        time: Float,
        time_step: Float, 
        input: &[ControllerInput],
    ) -> Option<Vec<ControllerOutput>> {
        let initialization_done = time >= self.start_time;
        let time_to_update =  self.time_step_index % self.time_steps_between_updates == 0;
        let first_time_step = self.time_step_index == 1;
        
        if first_time_step || (time_to_update && initialization_done) {
            let nr_wings = self.set_points.len();
            
            let mut out = Vec::with_capacity(nr_wings);
            
            for i in 0..nr_wings {
                let output_single = self.set_points[i].get_new_output(&input[i], time_step);
                
                out.push(output_single)
            }
            
            return Some(out)
        }

        None
    }
}