update ballooning reference length

Author: hiaselhans

openglider/glider/cell/basic_cell.py

@@ -21,16 +21,16 @@ def point_basic_cell(self, y: int=0, ik: float=0) -> euklid.vector.Vector3D:
         return self.midrib(y).get(ik)
 
     def midrib(self, y_value: float, ballooning: bool=True, arc_argument: bool=True, close_trailing_edge: bool=False) -> Profile3D:
-        if y_value <= 0:              # left side
+        # return early for left and right side
+        if y_value <= 0:
             return self.prof1
-        elif y_value >= 1:            # right side
+        elif y_value >= 1:
             return self.prof2
-        else:                   # somewhere else
-
-            # Ballooning is considered to be arcs, following 2 (two!) simple rules:
-            # 1: x1 = x*d
-            # 2: x2 = R*normvekt*(cos(phi2)-cos(phi)
-            # 3: norm(d)/r*(1-x) = 2*sin(phi(2))
+        else:
+            # Ballooning is considered to be arcs, these simple rules:
+            # 1: x = y_value * diff_vector
+            # 2: y = ballooning_radius * normal * (cos(phi2)-cos(phi))
+            # 3: 2 * sin(phi2) * ballooning_radius = norm(diff_vector)
 
             x_values: list[float] = []
             distances = []
@@ -41,7 +41,6 @@ def midrib(self, y_value: float, ballooning: bool=True, arc_argument: bool=True,
 
             if not ballooning:
                 midrib = self.prof1.curve.add(diff * y_value)
-            
             else:
                 for i in range(len(self.prof1.curve.nodes)):  # Arc -> phi(bal) -> r  # oder so...
                     x_left = self.prof1.x_values[i]
@@ -53,7 +52,7 @@ def midrib(self, y_value: float, ballooning: bool=True, arc_argument: bool=True,
                         d = y_value
                         h = 0.
 
-                    elif ballooning_radius > 1e-10:
+                    elif ballooning_radius is not None:
                         phi = self.ballooning_phi[i]    # phi is half only the half
 
                         if arc_argument:
@@ -92,15 +91,15 @@ def normvectors(self) -> euklid.vector.PolyLine3D:
         return euklid.vector.PolyLine3D(normals)
 
     @cached_property('ballooning_phi', 'prof1', 'prof2')
-    def ballooning_radius(self) -> list[float]:
+    def ballooning_radius(self) -> list[float | None]:
         prof1 = self.prof1.curve.nodes
         prof2 = self.prof2.curve.nodes
 
-        radius: list[float] = []
+        radius: list[float | None] = []
 
         for p1, p2, phi in zip(prof1, prof2, self.ballooning_phi):
             if phi < 1e-10:
-                radius.append(0.)
+                radius.append(None)
             else:
                 r = (p1-p2).length() / (2 * math.sin(phi) + (phi==0))
                 radius.append(r)

openglider/glider/cell/cell.py

@@ -3,7 +3,7 @@
 import logging
 import math
 from collections.abc import Sequence
-from typing import ClassVar
+from typing import ClassVar, Literal
 
 import euklid
 import openglider.utils
@@ -43,23 +43,19 @@ def at_position(self, y: Percentage) -> euklid.vector.PolyLine2D:
 class Cell(BaseModel):
     rib1: Rib
     rib2: Rib
+
     ballooning: BallooningBase
-    attachment_points: list[CellAttachmentPoint] = Field(default_factory=list)
-    miniribs: list[MiniRib] = Field(default_factory=list)
+    ballooning_modifiers: list[BallooningModifier] = Field(default_factory=list)
+    ballooning_reference: Literal["local", "cell"] = "local"
+
     panels: list[Panel] = Field(default_factory=list)
     diagonals: list[DiagonalRib] = Field(default_factory=list)
     straps: list[TensionStrap] = Field(default_factory=list)
     rigidfoils: list[PanelRigidFoil] = Field(default_factory=list)
-    name: str = "unnamed"
-
-    ballooning_modifiers: list[BallooningModifier] = Field(default_factory=list)
+    attachment_points: list[CellAttachmentPoint] = Field(default_factory=list)
+    miniribs: list[MiniRib] = Field(default_factory=list)
 
-    diagonal_naming_scheme: ClassVar[str] = "{cell.name}d{diagonal_no}"
-    strap_naming_scheme: ClassVar[str] = "{cell.name}s{side}{diagonal_no}"
-    panel_naming_scheme: ClassVar[str] = "{cell.name}p{panel_no}"
-    panel_naming_scheme_upper: ClassVar[str] = "{cell.name}pu{panel_no}"
-    panel_naming_scheme_lower: ClassVar[str] = "{cell.name}pl{panel_no}"
-    minirib_naming_scheme: ClassVar[str] = "{cell.name}mr{minirib_no}"
+    name: str = "unnamed"
 
     def __hash__(self) -> int:
         return hash_list(self.rib1, self.rib2, *self.miniribs, *self.diagonals)
@@ -74,18 +70,18 @@ def sort_func(panel: Panel) -> float:
             lower.sort(key=sort_func)
 
             for panel_no, panel in enumerate(upper):
-                panel.name = self.panel_naming_scheme_upper.format(cell=self, panel_no=panel_no+1)
+                panel.name = f"{cell_no}pu{panel_no+1}"
             for panel_no, panel in enumerate(lower):
-                panel.name = self.panel_naming_scheme_lower.format(cell=self, panel_no=panel_no+1)
+                panel.name = f"{cell_no}pl{panel_no+1}"
 
         else:
             self.panels.sort(key=lambda panel: panel.mean_x())
             for panel_no, panel in enumerate(self.panels):
-                panel.name = self.panel_naming_scheme.format(cell=self, panel=panel, panel_no=panel_no+1)
+                panel.name = f"{cell_no}p{panel_no+1}"
 
     def rename_diagonals(self, diagonals: Sequence[DiagonalRib | TensionStrap], cell_no: int, naming_scheme: str) -> None:
-        upper = []
-        lower = []
+        upper: list[DiagonalRib | TensionStrap] = []
+        lower: list[DiagonalRib | TensionStrap] = []
 
         for diagonal in diagonals:
             if diagonal.get_average_x() > 0:
@@ -105,14 +101,24 @@ def rename_diagonals(self, diagonals: Sequence[DiagonalRib | TensionStrap], cell
 
 
     def rename_parts(self, cell_no: int, seperate_upper_lower: bool=False) -> None:
-        self.rename_diagonals(self.diagonals, cell_no, self.diagonal_naming_scheme)
-        self.rename_diagonals(self.straps, cell_no, self.strap_naming_scheme)
+        self.rename_diagonals(self.diagonals, cell_no, "{cell.name}d{diagonal_no}")
+        self.rename_diagonals(self.straps, cell_no, "{cell.name}s{side}{diagonal_no}")
 
         for minirib_no, minirib in enumerate(self.miniribs):
-            minirib.name = self.minirib_naming_scheme.format(cell=self, minirib=minirib, minirib_no=minirib_no+1)
+            minirib.name = f"{self.name}mr{minirib_no+1}"
 
         self.rename_panels(cell_no, seperate_upper_lower=seperate_upper_lower)
 
+    @cached_property('prof1', 'prof2')
+    def width(self) -> float:
+        # get the distance between the two profiles
+        # project the base point of prof2 on the line of prof1
+
+        diff = self.rib2.pos - self.rib1.pos
+        rib1_chord_line = self.rib1.rotation_matrix.apply(euklid.vector.Vector2D([1, 0]))
+
+        return diff.cross(rib1_chord_line).length()
+
     @cached_property('rib1', 'rib2', 'ballooning_phi')
     def basic_cell(self) -> BasicCell:
         profile1 = self.rib1.profile_3d
@@ -300,10 +306,19 @@ def ballooning_modified(self) -> BallooningBase:
         return ballooning
 
     @cached_property('ballooning_modified')
-    def ballooning_phi(self) -> HashedList:
+    def ballooning_phi(self) -> HashedList[float]:
+        # get ballooning arc angles for each x value of the profiles
+
         x_values = [max(-1, min(1, x)) for x in self.rib1.profile_2d.x_values]
-        balloon = [self.ballooning_modified[i] for i in x_values]
-        return HashedList([BallooningBase.arcsinc(1. / (1+bal)) if bal > 0 else 0 for bal in balloon])
+        balloon = [max(0., self.ballooning_modified[i]) for i in x_values]
+
+        if self.ballooning_reference == "cell":
+            lengths = [(p1 - p2).length() for p1, p2 in zip(self.rib1.profile_3d.curve.nodes, self.rib2.profile_3d.curve.nodes)]
+            width = self.width
+            sinc = [length / (length + width * bal) for length, bal in zip(lengths, balloon)]
+        else:
+            sinc = [1. / (1+bal) for bal in balloon]
+        return HashedList([BallooningBase.arcsinc(x) if x < 1. else 0. for x in sinc])
 
     @cached_property('ballooning', '_child_cells')
     def ballooning_tension_factors(self) -> list[float]:

openglider/glider/cell/diagonals.py

@@ -168,8 +168,8 @@ def get_side_controlpoints(
                 p2_1 = left_2d.nodes[-1]
                 p2_2 = right_2d.get(ik2)
 
-            cp1 = p1_1 + (p1_2-p1_1) * self.curve_factor
-            cp2 = p2_1 + (p2_2 - p2_1) * self.curve_factor
+            cp1 = p1_1 + (p1_2-p1_1) * self.curve_factor.si
+            cp2 = p2_1 + (p2_2 - p2_1) * self.curve_factor.si
 
             return cp1, cp2
 
@@ -370,8 +370,8 @@ def get_side_controlpoints(
             normal_2 = rotation.apply(right_2-left_2).normalized() * normal_size
 
             return (
-                left_1 + (right_1 - left_1) * 0.5 + normal_1 * self.curve_factor,
-                left_2 + (right_2 - left_2) * 0.5 - normal_2 * self.curve_factor,
+                left_1 + (right_1 - left_1) * 0.5 + normal_1 * self.curve_factor.si,
+                left_2 + (right_2 - left_2) * 0.5 - normal_2 * self.curve_factor.si,
             )
 
         return None

openglider/glider/cell/panel.py

@@ -34,7 +34,7 @@ class PanelCut(BaseModel):
     x_right: Percentage
     cut_type: PANELCUT_TYPES
     seam_allowance: Length = Field(default_factory=lambda: Length(0))
-    cut_3d_amount: list[float] = Field(default_factory=lambda: [0, 0])
+    cut_3d_amount: list[float] = Field(default_factory=lambda: [0., 0.])
     cut_3d_sigma: float = 0.077
     x_center: Percentage | None = None
 

openglider/glider/parametric/glider.py

@@ -9,6 +9,7 @@
 import euklid
 from openglider.glider.parametric.config import ParametricGliderConfig, SewingAllowanceConfig
 from openglider.glider.parametric.table.base.parser import Parser
+from openglider.glider.parametric.table.cell.ballooning import BallooningData
 import openglider.materials
 import pyfoil
 from openglider.glider.ballooning.base import BallooningBase
@@ -101,7 +102,7 @@ def get_arc_angles(self) -> list[float]:
         """
         return self.arc.get_rib_angles(self.shape.rib_x_values)
 
-    def merge_ballooning(self, factor: float, multiplier: float) -> BallooningBase:
+    def merge_ballooning(self, factor: float, multiplier: float | None) -> BallooningBase:
         factor = max(0, min(len(self.balloonings)-1, factor))
         k = factor % 1
         i = int(factor // 1)
@@ -112,7 +113,10 @@ def merge_ballooning(self, factor: float, multiplier: float) -> BallooningBase:
         else:
             result = first
 
-        return result * multiplier
+        if multiplier is not None:
+            result *= multiplier
+
+        return result
 
     def get_merge_profile(self, factor: float) -> pyfoil.Airfoil:
         factor = max(0, min(len(self.profiles)-1, factor))
@@ -240,18 +244,19 @@ def get_profile_merge_values(self) -> list[float]:
         profile_merge_curve = euklid.vector.Interpolation(self.profile_merge_curve.get_sequence(self.num_interpolate).nodes)
         return [profile_merge_curve.get_value(abs(x)) for x in self.shape.rib_x_values]
 
-    def get_ballooning_merge(self) -> list[tuple[float, float]]:
+    def get_ballooning_data(self) -> list[BallooningData]:
         ballooning_merge_curve = euklid.vector.Interpolation(self.ballooning_merge_curve.get_sequence(self.num_interpolate).nodes)
-        factors = [ballooning_merge_curve.get_value(abs(x)) for x in self.shape.cell_x_values]
-
-        table = self.tables.ballooning_modifiers
+        merge_factors = [ballooning_merge_curve.get_value(abs(x)) for x in self.shape.cell_x_values]
 
-        if table is not None:
-            all_factors = table.get_merge_factors(factors)
-        else:
-            all_factors = [(factor, 1) for factor in factors]
+        result = []
 
-        return [(max(0, x), y) for x,y in all_factors]
+        for rib_no, merge_factor in enumerate(merge_factors):
+            modifier = self.tables.ballooning_modifiers.get_ballooning_data(rib_no, self.resolvers)
+            if modifier.merge_factor is None:
+                modifier.merge_factor = merge_factor
+            result.append(modifier)
+        
+        return result
 
     def apply_shape_and_arc(self, glider: Glider) -> None:
         x_values = [abs(x) for x in self.shape.rib_x_values]
@@ -455,17 +460,19 @@ def get_glider_3d(self, glider: Glider=None, num: int=50, num_profile: int | Non
 
         logger.info("create cells")
 
-        ballooning_factors = self.get_ballooning_merge()
+        ballooning_data = self.get_ballooning_data()
         glider.cells = []
         for cell_no, (rib1, rib2) in enumerate(zip(ribs[:-1], ribs[1:])):
 
-            ballooning_factor = ballooning_factors[cell_no]
-            ballooning = self.merge_ballooning(*ballooning_factor)
+            ballooning_factor = ballooning_data[cell_no]
+            assert ballooning_factor.merge_factor is not None
+            ballooning = self.merge_ballooning(ballooning_factor.merge_factor, ballooning_factor.ballooning_factor)
 
             cell = Cell(
                 rib1=rib1,
                 rib2=rib2,
                 ballooning=ballooning,
+                ballooning_reference=ballooning_factor.ballooning_reference,
                 name=f"c{cell_no+1}",
                 attachment_points=[],
                 ballooning_modifiers=self.tables.ballooning_modifiers.get_modifiers(cell_no, resolvers=resolvers)
@@ -517,15 +524,16 @@ def apply_ballooning(self, glider3d: Glider | None=None) -> list[BallooningBase]
         for ballooning in self.balloonings:
             ballooning.apply_splines()
 
-        ballooning_factors = self.get_ballooning_merge()
+        ballooning_factors = self.get_ballooning_data()
         balloonings = []
 
-        for cell_no in range(len(ballooning_factors)):
-            ballooning_factor = ballooning_factors[cell_no]
-            ballooning = self.merge_ballooning(*ballooning_factor)
+        for cell_no, ballooning_factor in enumerate(ballooning_factors):
+            assert ballooning_factor.merge_factor is not None
+            ballooning = self.merge_ballooning(ballooning_factor.merge_factor, ballooning_factor.ballooning_factor)
             if glider3d is not None:
                 cell = glider3d.cells[cell_no]
                 cell.ballooning = ballooning
+                cell.ballooning_reference = ballooning_factor.ballooning_reference
 
             balloonings.append(ballooning)
 

openglider/glider/parametric/shape.py

@@ -171,13 +171,13 @@ def get_half_shape(self, zrot: list[Angle | None] | None = None) -> Shape:
             return base_shape
 
         baseline = base_shape.get_baseline(self.config.baseline_pct).nodes
-        front_new = []
-        back_new = []
+        front_new: list[euklid.vector.Vector2D] = []
+        back_new: list[euklid.vector.Vector2D] = []
 
         for rib_no, angle in enumerate(zrot):
             if angle is None:
-                front_new.append(front[rib_no])
-                back_new.append(back[rib_no])
+                front_new.append(euklid.vector.Vector2D(front[rib_no]))
+                back_new.append(euklid.vector.Vector2D(back[rib_no]))
             else:
                 rotation = euklid.vector.Rotation2D(angle.si)
                 front_new.append(

openglider/glider/parametric/table/base/table.py

@@ -151,7 +151,7 @@ def _prepare_dto_data(self, row: int, dto: type[DTO], data: list[Any], resolvers
                 )
                 index = index + 1 + max(tuple_type.index_offset)
             else:
-                if field.annotation == str:
+                if field.annotation is str or typing.get_origin(field.annotation) == typing.Literal:
                     dct[field_name] = data[index]
                 else:
                     dct[field_name] = resolvers[row].parse(data[index])

openglider/glider/parametric/table/cell/ballooning.py

@@ -1,5 +1,7 @@
 import logging
+from typing import Literal, Self
 
+from openglider.glider.cell.cell import Cell
 from openglider.glider.parametric.table.base import CellTable, Keyword
 from openglider.glider.parametric.table.base.dto import DTO
 from openglider.glider.parametric.table.base.parser import Parser
@@ -17,6 +19,14 @@ class BallooningRampDTO(DTO):
 
     def get_object(self) -> EntryRamp:
         return EntryRamp(ramp_distance=self.ramp_distance)
+    
+class BallooningData(DTO):
+    ballooning_reference: Literal["local", "cell"]
+    merge_factor: float | None
+    ballooning_factor: float | None
+
+    def get_object(self)-> Self:
+        return self
 
 
 class BallooningModifierTable(CellTable):
@@ -26,8 +36,26 @@ class BallooningModifierTable(CellTable):
     }
     dtos = {
         "BallooningRamp": BallooningRampDTO,
+        "BallooningModifier": BallooningData
     }
 
+    def get_ballooning_data(self, row: int, resolvers: list[Parser]) -> BallooningData:
+        value: BallooningData | None = self.get_one(row_no=row, keywords=["BallooningModifier"], resolvers=resolvers)
+        if value is None:
+            value = BallooningData(ballooning_reference="local", merge_factor=None, ballooning_factor=None)
+        
+        if value.merge_factor is None:
+            merge_factors = self.get(row_no=row, keywords=["BallooningMerge"], resolvers=resolvers)
+            if merge_factors:
+                value.merge_factor = merge_factors[-1]["merge_factor"]
+        
+        if value.ballooning_factor is None:
+            ballooning_factors = self.get(row_no=row, keywords=["BallooningFactor"], resolvers=resolvers)
+            if ballooning_factors:
+                value.ballooning_factor = ballooning_factors[-1]["amount_factor"]
+
+        return value
+
     def get_merge_factors(self, factor_list: list[float]) -> list[tuple[float, float]]:
 
         merge_factors = factor_list[:]

openglider/glider/parametric/table/cell/miniribs.py

@@ -1,4 +1,3 @@
-from typing import Any
 from openglider.glider.parametric.table.base.dto import DTO
 from openglider.glider.rib import MiniRib
 
@@ -9,7 +8,7 @@ class MiniRibDTO(DTO):
     y_value: Percentage
     front_cut: Percentage
     back_cut: Percentage
-    trailing_edge_cut: Length | Percentage
+    trailing_edge_cut: Length
     material_code: str
 
     def get_object(self) -> MiniRib: