stormbird-setup 0.1.0__py3-none-any.whl

stormbird_setup/__init__.py

@@ -0,0 +1,11 @@
+"""
+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)
+"""
+
+from .spatial_vector import SpatialVector
+
+__all__ = [
+    "SpatialVector"
+]

stormbird_setup/actuator_line/__init__.py

@@ -0,0 +1,15 @@
+"""
+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)
+"""
+
+from .actuator_line_builder import ActuatorLineBuilder
+from .corrections import LiftingLineCorrectionBuilder, EmpiricalCirculationCorrection
+from .settings import Gaussian, ProjectionSettings, SamplingSettings, SolverSettings
+
+__all__ = [
+    "ActuatorLineBuilder",
+    "LiftingLineCorrectionBuilder", "EmpiricalCirculationCorrection",
+    "Gaussian", "ProjectionSettings", "SamplingSettings", "SolverSettings"
+]

stormbird_setup/actuator_line/actuator_line_builder.py

@@ -0,0 +1,24 @@
+"""
+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)
+"""
+
+from ..base_model import StormbirdSetupBaseModel
+from ..line_force_model import LineForceModelBuilder
+
+from .settings import ProjectionSettings, SolverSettings, SamplingSettings
+from .corrections import LiftingLineCorrectionBuilder, EmpiricalCirculationCorrection
+
+from ..controller import ControllerBuilder
+
+class ActuatorLineBuilder(StormbirdSetupBaseModel):
+    line_force_model: LineForceModelBuilder
+    projection_settings: ProjectionSettings = ProjectionSettings()
+    solver_settings: SolverSettings = SolverSettings()
+    sampling_settings: SamplingSettings = SamplingSettings()
+    write_iterations_full_result: int = 100
+    start_time: float = 0
+    controller: ControllerBuilder | None = None
+    lifting_line_correction: LiftingLineCorrectionBuilder | None = None
+    empirical_circulation_correction: EmpiricalCirculationCorrection | None = None

stormbird_setup/actuator_line/corrections.py

@@ -0,0 +1,18 @@
+"""
+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)
+"""
+
+from ..base_model import StormbirdSetupBaseModel
+
+from ..lifting_line.wake import SymmetryCondition
+
+class LiftingLineCorrectionBuilder(StormbirdSetupBaseModel):
+    wake_length_factor: float = 100.0
+    symmetry_condition: SymmetryCondition = SymmetryCondition.NoSymmetry
+    initialization_time: float | None = None
+
+class EmpiricalCirculationCorrection(StormbirdSetupBaseModel):
+    exp_factor: float = 10.0
+    overall_correction: float = 1.0

stormbird_setup/actuator_line/settings.py

@@ -0,0 +1,29 @@
+"""
+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)
+"""
+
+from ..base_model import StormbirdSetupBaseModel
+
+class Gaussian(StormbirdSetupBaseModel):
+    chord_factor: float = 0.25
+    thickness_factor: float = 0.25
+
+class ProjectionSettings(StormbirdSetupBaseModel):
+    projection_function: Gaussian = Gaussian()
+    realign_sectional_forces: bool = True
+    realign_to_local_velocity_at_each_cell: bool = False
+    project_viscous_lift: bool = False
+    project_sectional_drag: bool = False
+
+class SamplingSettings(StormbirdSetupBaseModel):
+    use_point_sampling: bool = False
+    span_projection_factor: float = 0.5
+    neglect_span_projection: bool = False
+    extrapolate_end_velocities: bool = False
+    remove_span_velocity: bool = False
+    correction_factor: float = 1.0
+
+class SolverSettings(StormbirdSetupBaseModel):
+    damping_factor: float = 0.1

stormbird_setup/base_model.py

@@ -0,0 +1,50 @@
+"""
+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)
+"""
+
+from typing import TypeVar, Type
+from pathlib import Path
+
+from pydantic import BaseModel, ConfigDict
+
+T = TypeVar('T', bound='StormbirdSetupBaseModel')
+
+class StormbirdSetupBaseModel(BaseModel):
+    '''
+    Base class for the classes that define the setup of stormbird simulations.
+    '''
+    model_config = ConfigDict(
+        frozen=False,
+        validate_assignment=True,
+        extra='forbid',
+        populate_by_name=True,
+        use_enum_values=False,
+        validate_default=True
+    )
+
+    @classmethod
+    def from_json_string(cls: Type[T], json_string: str) -> T:
+        return cls.model_validate_json(json_string)
+
+    @classmethod
+    def from_json_file(cls: Type[T], file_path: Path) -> T:
+        return cls.model_validate_json(file_path.read_text())
+
+    def to_json_string(self) -> str:
+        return self.model_dump_json(exclude_none=True, indent=4)
+
+    def to_json_file(self, file_path: Path | str) -> None:
+
+        if isinstance(file_path, str):
+            file_path_out = Path(file_path)
+        elif isinstance(file_path, Path):
+            file_path_out = file_path
+        else:
+            raise TypeError(f"Input must be of type Path or str. Right now it is {type(file_path)}")
+
+        file_path_out.write_text(self.to_json_string())
+
+    def to_dict(self) -> dict:
+        return self.model_dump(exclude_none=True, mode='json')

stormbird_setup/circulation_corrections.py

@@ -0,0 +1,138 @@
+"""
+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)
+"""
+
+from .base_model import StormbirdSetupBaseModel
+
+from pydantic import model_serializer, model_validator
+
+from enum import Enum
+
+class WindowSize(Enum):
+    Five = "Five"
+    Seven = "Seven"
+    Nine = "Nine"
+
+class GaussianSmoothingBuilder(StormbirdSetupBaseModel):
+    smoothing_length_factor: float = 0.1
+
+class CubicPolynomialSmoothingBuilder(StormbirdSetupBaseModel):
+    window_size: WindowSize = WindowSize.Five
+
+class CirculationSmoothingBuilder(StormbirdSetupBaseModel):
+    smoothing_type: GaussianSmoothingBuilder = GaussianSmoothingBuilder()
+
+    @model_serializer
+    def ser_model(self):
+        if isinstance(self.smoothing_type, GaussianSmoothingBuilder):
+            return {
+                "smoothing_type": {
+                    "Gaussian":self.smoothing_type.model_dump()
+                }
+            }
+        else:
+            raise NotImplementedError("Only Gaussian smoothing is implemented")
+            
+    @model_validator(mode='before')
+    @classmethod
+    def deserialize_from_rust_enum(cls, data):
+        if not isinstance(data, dict):
+            return data
+        
+        if not data:
+            return data
+        
+        # Check if smoothing_type needs to be unwrapped from Rust enum format
+        if 'smoothing_type' in data:
+            st = data['smoothing_type']
+            if isinstance(st, dict):
+                if 'Gaussian' in st:
+                    return {'smoothing_type': GaussianSmoothingBuilder(**st['Gaussian'])}
+                elif 'CubicPolynomial' in st:
+                    return {'smoothing_type': CubicPolynomialSmoothingBuilder(**st['CubicPolynomial'])}
+        
+        return data
+            
+class PrescribedCirculationShape(StormbirdSetupBaseModel):
+    inner_power: float = 2.0
+    outer_power: float = 0.5
+            
+class PrescribedCirculation(StormbirdSetupBaseModel):
+    shape: PrescribedCirculationShape = PrescribedCirculationShape()
+    curve_fit_shape_parameters: bool = False
+
+class CirculationCorrectionBuilder(StormbirdSetupBaseModel):
+    correction: CirculationSmoothingBuilder | PrescribedCirculation | None = None
+
+    @classmethod
+    def new_gaussian_smoothing(
+        cls, 
+        smoothing_length_factor: float = 0.1,
+    ):
+        return cls(
+            correction = CirculationSmoothingBuilder(
+                smoothing_type = GaussianSmoothingBuilder(
+                    smoothing_length_factor = smoothing_length_factor
+                )
+            )
+        )
+        
+    @classmethod
+    def new_prescribed_circulation(
+        cls, 
+        inner_power: float = 2.0, 
+        outer_power: float = 0.5, 
+        curve_fit_shape_parameters: bool = False
+    ):
+        return cls(
+            correction = PrescribedCirculation(
+                shape = PrescribedCirculationShape(
+                    inner_power = inner_power,
+                    outer_power = outer_power
+                ),
+                curve_fit_shape_parameters = curve_fit_shape_parameters
+            )
+        )
+        
+    @model_validator(mode='before')
+    @classmethod
+    def deserialize_from_rust_enum(cls, data):
+        # Handle the "None" string case
+        if data == "None":
+            return {'correction': None}
+        
+        if not isinstance(data, dict):
+            return data
+        
+        if not data:
+            return data
+        
+        # Already in Python/Pydantic form
+        if 'correction' in data:
+            return data
+        
+        # Rust externally-tagged enum format
+        if 'Prescribed' in data:
+            return {'correction': PrescribedCirculation(**data['Prescribed'])}
+        elif 'Smoothing' in data:
+            # Use model_validate so it goes through CirculationSmoothingBuilder's validator
+            return {'correction': CirculationSmoothingBuilder.model_validate(data['Smoothing'])}
+        else:
+            raise ValueError(f"Unknown circulation correction variant: {list(data.keys())}")
+        
+    @model_serializer
+    def ser_model(self):
+        if self.correction is None:
+            return "None"
+        elif isinstance(self.correction, PrescribedCirculation):
+            return {
+                "Prescribed": self.correction.model_dump(exclude_none=True)
+            }
+        elif isinstance(self.correction, CirculationSmoothingBuilder):
+            return {
+                "Smoothing": self.correction.ser_model()
+            }
+        else:
+            raise ValueError("Invalid correction type")

stormbird_setup/controller.py

@@ -0,0 +1,133 @@
+"""
+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)
+"""
+
+from .base_model import StormbirdSetupBaseModel
+
+from enum import Enum
+
+from pydantic import field_serializer, Field
+
+import numpy as np
+
+class InternalStateType(Enum):
+    Generic = "Generic"
+    SpinRatio = "SpinRatio"
+
+class SpinRatioConversion(StormbirdSetupBaseModel):
+    diameter: float
+    max_rps: float
+
+class ControllerSetPoints(StormbirdSetupBaseModel):
+    apparent_wind_directions_data: list[float]
+    angle_of_attack_data: list[float] | None = None
+    section_model_internal_state_data: list[float] | None = None
+    internal_state_type: InternalStateType = InternalStateType.Generic
+    internal_state_conversion: SpinRatioConversion | None = Field(default=None, exclude=True)
+    use_effective_angle_of_attack: bool = False
+    max_local_wing_angle_change_rate: float | None = None
+    max_internal_section_state_change_rate: float | None = None
+
+    @field_serializer('internal_state_type')
+    def serialize_internal_state_type(self, value: InternalStateType):
+        match value:
+            case InternalStateType.Generic:
+                return "Generic"
+            case InternalStateType.SpinRatio:
+                if self.internal_state_conversion is None:
+                    raise ValueError("SpinRatioConversion must be provided for SpinRatio internal state type.")
+                return {
+                    "SpinRatio": self.internal_state_conversion.model_dump()
+                }
+            case _:
+                raise ValueError("Unsupported internal state type:", value)
+                
+    @classmethod
+    def new_default_wing_sail_single_element(cls, max_angle_deg: float = 15.0):
+        apparent_wind_directions_data = np.radians([-180, -15, -10, 10, 15, 180])
+        angle_of_attack_data = np.radians([-max_angle_deg, -max_angle_deg, 0.0, 0.0, max_angle_deg, max_angle_deg])
+
+        return ControllerSetPoints(
+            apparent_wind_directions_data = apparent_wind_directions_data.tolist(),
+            angle_of_attack_data = angle_of_attack_data.tolist()
+        )
+        
+    @classmethod
+    def new_default_wing_sail_two_element(cls, max_angle_deg: float = 12.0):
+        apparent_wind_directions_data = np.radians([-180, -15, -10, 10, 15, 180])
+        angle_of_attack_data = np.radians([-max_angle_deg, -max_angle_deg, 0.0, 0.0, max_angle_deg, max_angle_deg])
+        section_model_internal_state_data = np.radians([-30.0, -30.0, 0.0, 0.0, 30.0, 30.0])
+
+        return ControllerSetPoints(
+            apparent_wind_directions_data = apparent_wind_directions_data.tolist(),
+            angle_of_attack_data = angle_of_attack_data.tolist(),
+            section_model_internal_state_data = section_model_internal_state_data.tolist()
+        )
+        
+    @classmethod
+    def new_default_rotor_sail(cls, *, diameter: float, max_rps: float):
+        '''
+        Helper function to quickly set up a suitable controller for a rotor sail. Assumed to be
+        fairly general
+        '''
+        apparent_wind_directions_data = np.radians([-180, -40, -15, 15, 40, 180])
+        section_model_internal_state_data = [3.0, 3.0, 0.0, 0.0, -3.0, -3.0]
+
+        internal_state_type = InternalStateType.SpinRatio
+        internal_state_conversion = SpinRatioConversion(
+            diameter = diameter,
+            max_rps = max_rps
+        )
+
+        return ControllerSetPoints(
+            apparent_wind_directions_data = apparent_wind_directions_data.tolist(),
+            section_model_internal_state_data = section_model_internal_state_data,
+            internal_state_type = internal_state_type,
+            internal_state_conversion = internal_state_conversion
+        )
+        
+    @classmethod
+    def new_default_suction_sail(cls, max_aoa_deg: float=30.0, max_ca: float = 0.3):        
+        apparent_wind_directions_data = np.radians([-180, -15, -10, 10, 15, 180]).tolist()
+        
+        angle_of_attack_data = np.radians([
+            -max_aoa_deg, -max_aoa_deg, 0.0, 
+            0.0, max_aoa_deg, max_aoa_deg
+        ]).tolist()
+        
+        section_model_internal_state_data = [
+            -max_ca, -max_ca, 0.0, 
+            0.0, max_ca, max_ca
+        ]
+
+        return ControllerSetPoints(
+            apparent_wind_directions_data = apparent_wind_directions_data,
+            angle_of_attack_data = angle_of_attack_data,
+            section_model_internal_state_data = section_model_internal_state_data
+        )
+
+
+class MeasurementType(Enum):
+    Mean = "Mean"
+    Max = "Max"
+    Min = "Min"
+
+class MeasurementSettings(StormbirdSetupBaseModel):
+    measurement_type: MeasurementType = MeasurementType.Mean
+    start_index: int = 1
+    end_offset: int = 1
+
+class FlowMeasurementSettings(StormbirdSetupBaseModel):
+    angle_of_attack: MeasurementSettings = MeasurementSettings()
+    wind_direction: MeasurementSettings = MeasurementSettings()
+    wind_velocity: MeasurementSettings = MeasurementSettings()
+
+class ControllerBuilder(StormbirdSetupBaseModel):
+    set_points: list[ControllerSetPoints]
+    flow_measurement_settings: FlowMeasurementSettings = FlowMeasurementSettings()
+    time_steps_between_updates: int = 1
+    start_time: float = 0.0
+    moving_average_window_size: int | None = None
+    use_input_velocity_for_apparent_wind_direction: bool = False

stormbird_setup/input_power.py

@@ -0,0 +1,128 @@
+"""
+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)
+"""
+
+from .base_model import StormbirdSetupBaseModel
+
+from enum import Enum
+
+from pydantic import model_serializer, model_validator
+
+import numpy as np
+
+class InputPowerData(StormbirdSetupBaseModel):
+    section_models_internal_state_data: list[float]
+    input_power_coefficient_data: list[float]
+
+class InputPowerDataType(Enum):
+    NoPower = "NoPower"
+    InternalStateAsPowerCoefficient = "InternalStateAsPowerCoefficient"
+    InterpolatePowerCoefficientFromInternalState = "InterpolatePowerCoefficientFromInternalState"
+    InterpolateFromInternalStateOnly = "InterpolateFromInternalStateOnly"
+
+class InputPowerModel(StormbirdSetupBaseModel):
+    '''
+    Interface to the input power model
+    '''
+    input_power_type: InputPowerDataType = InputPowerDataType.NoPower
+    input_power_data: InputPowerData | None = None
+    
+    @classmethod
+    def new_from_internal_state_as_power_coefficient(cls) -> "InputPowerModel":
+        return cls(
+            input_power_type = InputPowerDataType.InternalStateAsPowerCoefficient
+        )
+
+    @classmethod
+    def new_polynomial_rotor_sail_model(
+        cls,
+        max_power: float,
+        max_rps: float,
+        area: float,
+        poly_power: float = 2.5
+    ) -> "InputPowerModel":
+        '''
+        Simple model for the power based on a polynomial relationship between the power and RPS.
+
+        The polynomial power is set to 2.5, which comes from data fitted to data from the SWOPP
+        project. However, the actual power is scaled based on the supplied values for max_power
+        and max_rps.
+        '''
+
+        section_models_internal_state_data = np.linspace(0, max_rps, 20)
+
+        factor = max_power / (max_rps**poly_power * area)
+
+        input_power_coefficient_data = factor * (section_models_internal_state_data**poly_power)
+
+        return cls(
+            input_power_type = InputPowerDataType.InterpolateFromInternalStateOnly,
+            input_power_data = InputPowerData(
+                section_models_internal_state_data = section_models_internal_state_data.tolist(),
+                input_power_coefficient_data = input_power_coefficient_data.tolist()
+            )
+        )
+        
+    @model_validator(mode='before')
+    @classmethod
+    def deserialize_from_rust_enum(cls, data):
+        # Handle the "NoPower" string case (unit variant)
+        if data == "NoPower":
+            return {
+                'input_power_type': InputPowerDataType.NoPower,
+                'input_power_data': None
+            }
+        
+        if not isinstance(data, dict):
+            return data
+        
+        # Empty dict means use defaults
+        if not data:
+            return data
+        
+        # Already in Python/Pydantic form
+        if 'input_power_type' in data or 'input_power_data' in data:
+            return data
+        
+        # Rust externally-tagged enum format
+        if 'InterpolateFromInternalStateOnly' in data:
+            return {
+                'input_power_type': InputPowerDataType.InterpolateFromInternalStateOnly,
+                'input_power_data': InputPowerData(**data['InterpolateFromInternalStateOnly'])
+            }
+        elif 'InternalStateAsPowerCoefficient' in data:
+            return {
+                'input_power_type': InputPowerDataType.InternalStateAsPowerCoefficient,
+                'input_power_data': None
+            }
+        elif 'InterpolatePowerCoefficientFromInternalState' in data:
+            return {
+                'input_power_type': InputPowerDataType.InterpolatePowerCoefficientFromInternalState,
+                'input_power_data': InputPowerData(**data['InterpolatePowerCoefficientFromInternalState'])
+            }
+        else:
+            raise ValueError(f"Unknown input power model variant: {list(data.keys())}")
+
+    @model_serializer
+    def ser_model(self) -> dict[str, object] | str:
+        match self.input_power_type:
+            case InputPowerDataType.NoPower | InputPowerDataType.InternalStateAsPowerCoefficient:
+                return self.input_power_type.value
+            case InputPowerDataType.InterpolateFromInternalStateOnly:
+                if self.input_power_data is None:
+                    raise ValueError("input_power_data must be set for InterpolateFromInternalStateOnly")
+
+                return {
+                    "InterpolateFromInternalStateOnly": self.input_power_data.model_dump()
+                }
+            case InputPowerDataType.InterpolatePowerCoefficientFromInternalState:
+                if self.input_power_data is None:
+                    raise ValueError("input_power_data must be set for InterpolatePowerCoefficientFromInternalState")
+                
+                return {
+                    "InterpolatePowerCoefficientFromInternalState": self.input_power_data.model_dump()
+                }
+            case _:
+                raise ValueError("Unknown input power type", self.input_power_type)

stormbird_setup/lifting_line/__init__.py

@@ -0,0 +1,19 @@
+"""
+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)
+"""
+
+from .solver import InducedVelocityCorrectionMethod, Linearized, SimpleIterative
+from .wake import SymmetryCondition, ViscousCoreLength, QuasiSteadyWakeSettings, DynamicWakeBuilder, ViscousCoreLengthEvolution, FirstWakePointsDirection
+from .simulation_builder import QuasiSteadySettings, DynamicSettings, SimulationBuilder
+from .velocity_corrections import VelocityCorrections
+from .complete_sail_model import CompleteSailModelBuilder
+
+__all__ = [
+    "InducedVelocityCorrectionMethod", "Linearized", "SimpleIterative",
+    "SymmetryCondition", "ViscousCoreLength", "QuasiSteadyWakeSettings", "DynamicWakeBuilder", "ViscousCoreLengthEvolution", "FirstWakePointsDirection",
+    "QuasiSteadySettings", "DynamicSettings", "SimulationBuilder",
+    "VelocityCorrections",
+    "CompleteSailModelBuilder"
+]

stormbird_setup/lifting_line/complete_sail_model.py

@@ -0,0 +1,16 @@
+"""
+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)
+"""
+
+from ..base_model import StormbirdSetupBaseModel
+
+from .simulation_builder import SimulationBuilder
+from ..wind import WindEnvironment
+from ..controller import ControllerBuilder
+
+class CompleteSailModelBuilder(StormbirdSetupBaseModel):
+    lifting_line_simulation: SimulationBuilder
+    controller: ControllerBuilder
+    wind_environment: WindEnvironment = WindEnvironment()