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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

// 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)


use std::ops::Range;

use serde::{Deserialize, Serialize};

use stormath::statistics;
use stormath::type_aliases::Float;

use crate::{
    common_utils::results::simulation::SimulationResult, 
    line_force_model::LineForceModel, 
    wind::environment::WindEnvironment,
};

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub enum MeasurementType {
    #[default]
    Mean,
    Max,
    Min,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
/// Settings used when measuring flow characteristics from a simulation, when the intention is to 
/// generate input to a controller.
pub struct MeasurementSettings {
    #[serde(default)]
    pub measurement_type: MeasurementType,
    #[serde(default)]
    pub start_index: usize,
    #[serde(default)]
    pub end_offset: usize,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct FlowMeasurementSettings {
    #[serde(default)]
    pub angle_of_attack: MeasurementSettings,
    #[serde(default)]
    pub wind_direction: MeasurementSettings,
    #[serde(default)]
    pub wind_velocity: MeasurementSettings,
}

pub fn measure_float_values(
    values: &[Float],
    wing_indices: Vec<Range<usize>>,
    measurement_settings: &MeasurementSettings,
) -> Vec<Float> {

    let nr_wings = wing_indices.len();

    let mut out = vec![0.0; nr_wings];

    for i in 0..nr_wings {
        let wing_values = values[wing_indices[i].clone()].to_vec();
        let nr_strips = wing_values.len();

        let start_index = measurement_settings.start_index;
        let end_index = (nr_strips - measurement_settings.end_offset - 1).max(start_index+1).min(nr_strips-1);

        out[i] = match measurement_settings.measurement_type {
            MeasurementType::Mean => statistics::mean(
                &wing_values[start_index..end_index]
            ),
            MeasurementType::Max => statistics::max(
                &wing_values[start_index..end_index]
            ),
            MeasurementType::Min => statistics::min(
                &wing_values[start_index..end_index]
            )
        };
    }

    out
}

pub fn measure_angles_of_attack(
    simulation_result: &SimulationResult,
    measurement_settings: &MeasurementSettings,
) -> Vec<Float> {
    measure_float_values(
        &simulation_result.force_input.angles_of_attack,
        simulation_result.wing_indices.clone(),
        measurement_settings
    )
}

pub fn measure_wind_velocity_magnitude(
    simulation_result: &SimulationResult,
    measurement_settings: &MeasurementSettings,
) -> Vec<Float> {
    let velocity_magnitude: Vec<Float> = simulation_result.force_input.velocity
        .iter()
        .map(|v| v.length())
        .collect();

    measure_float_values(
        &velocity_magnitude,
        simulation_result.wing_indices.clone(),
        measurement_settings
    )
}

pub fn measure_apparent_wind_direction(
    simulation_result: &SimulationResult,
    measurement_settings: &MeasurementSettings,
    wind_environment: &WindEnvironment,
    line_force_model: &LineForceModel,
    use_input_velocity: bool,
) -> Vec<Float> {
    let relevant_velocities = if use_input_velocity {
        simulation_result.felt_input_velocity_minus_rotational_motion()
    } else {
        simulation_result.felt_velocity_minus_rotational_motion()
    };

    let wind_directions = wind_environment
        .apparent_wind_direction_from_velocity_and_line_force_model(
            &relevant_velocities, 
            line_force_model
        );

    measure_float_values(
        &wind_directions, 
        simulation_result.wing_indices.clone(),
        measurement_settings
    )
}