planformcreator2 4.3.0__tar.gz → 4.3.2__tar.gz

{planformcreator2-4.3.0 → planformcreator2-4.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: planformcreator2
-Version: 4.3.0
+Version: 4.3.2
 Summary: Design a wing planform
 Project-URL: Homepage, https://github.com/jxjo/PlanformCreator2
 Project-URL: Issues, https://github.com/jxjo/PlanformCreator2/issues
@@ -12,12 +12,12 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.12
-Requires-Dist: airfoileditor~=4.3.0
+Requires-Dist: airfoileditor~=4.3.2
 Description-Content-Type: text/markdown
 
 ![PC2](https://github.com/jxjo/PlanformCreator2/blob/main/images/PC2_logo.png?raw=true)
 
-# v4.3.0
+# v4.3.2
 
 **PlanformCreator2** (PC2) is an app for designing wing planforms, with a focus on model planes.
 

{planformcreator2-4.3.0 → planformcreator2-4.3.2}/README.md

@@ -2,7 +2,7 @@
 ![PC2](images/PC2_logo.png "Logo")
 
 
-# v4.3.0
+# v4.3.2
 
 **PlanformCreator2** (PC2) is an app for designing wing planforms, with a focus on model planes.
 

{planformcreator2-4.3.0 → planformcreator2-4.3.2}/doc/README_PyPi.md

@@ -1,6 +1,6 @@
 ![PC2](https://github.com/jxjo/PlanformCreator2/blob/main/images/PC2_logo.png?raw=true)
 
-# v4.3.0
+# v4.3.2
 
 **PlanformCreator2** (PC2) is an app for designing wing planforms, with a focus on model planes.
 

{planformcreator2-4.3.0 → planformcreator2-4.3.2}/planformcreator2/app.py

@@ -66,7 +66,7 @@ logger = logging.getLogger(__name__)
 #-------------------------------------------------------------------------------
 
 APP_NAME         = "PlanformCreator2"
-__version__      = "4.3.0"                            # hatch "version dynamic" reads this version for build
+__version__      = "4.3.2"                            # hatch "version dynamic" reads this version for build
 
 
 class Main (QMainWindow):
@@ -220,6 +220,11 @@ class Main (QMainWindow):
     def closeEvent  (self, event : QCloseEvent):
         """ main window is closed """
 
+        current_mode = self._modes_manager.current_mode if self._modes_manager else None
+        if current_mode is not None and not current_mode.confirm_close():
+            event.ignore()
+            return
+
         # terminate polar watchdog thread, clean up working dir 
         self._app_model.close()                           
 

{planformcreator2-4.3.0 → planformcreator2-4.3.2}/planformcreator2/app_model.py

@@ -70,9 +70,7 @@ class App_Model (QObject):
     sig_new_polars              = pyqtSignal()          # new polars generated
     sig_paneling_changed        = pyqtSignal()          # paneling definition changed
 
-    sig_vlm_polar_reset         = pyqtSignal()          # VLM reset - new polar will be generated on demand
-    sig_vlm_polar_changed       = pyqtSignal()          # current VLM polar changed
-    sig_vlm_opPoint_changed     = pyqtSignal()          # current VLM operating point changed
+    sig_vlm_changed             = pyqtSignal()          # current VLM polar/op-point changed
 
 
     def __init__(self, workingDir_default: str = None):
@@ -113,6 +111,23 @@ class App_Model (QObject):
         return f"<App_Model {self.wing}>"
 
 
+    def _set_cur_polar_def_default(self, silent: bool = False):
+        """Initialize or repair the current polar definition explicitly."""
+
+        new_polar_def = self.cur_polar_def
+        if new_polar_def == self._cur_polar_def:
+            return
+
+        self._cur_polar_def = new_polar_def
+        logger.debug (f"{self} set cur_polar_def to {new_polar_def}")
+
+        if self.vlm_alpha_fixed_to_max:
+            self._cur_vlm_alpha = None
+
+        if not silent:
+            self.sig_vlm_changed.emit()
+
+
     def _init_watchdog (self):
         """ initialize watchdog thread to check for new polars and xo2 state changes """
 
@@ -272,35 +287,29 @@ class App_Model (QObject):
     def cur_polar_def (self) -> Polar_Definition:
         """ selected T1 polar definition of wingSection at root"""
 
-        new_polar_def = self._cur_polar_def
+        if self._cur_polar_def in self.polar_definitions_T1:
+            return self._cur_polar_def
 
-        # ensure current polar def is in existing polar definitions
-        if self._cur_polar_def not in self.polar_definitions_T1:
-            new_polar_def = None
+        if self.polar_definitions_T1:
+            return self.polar_definitions_T1[0]
 
-        if self._cur_polar_def is None and self.polar_definitions_T1:
-            new_polar_def = self.polar_definitions_T1[0] 
-
-        if new_polar_def != self._cur_polar_def:
-            self._cur_polar_def = new_polar_def
-            logger.debug (f"{self} set cur_polar_def to {new_polar_def}")
-
-            # reset current VLM opPoint 
-            self._cur_vlm_alpha = None if self.vlm_alpha_fixed_to_max else 0.0
-            self.sig_vlm_opPoint_changed.emit()
-
-        return self._cur_polar_def
+        return None
 
 
     def set_cur_polar_def (self, polar_def : Polar_Definition):
         """ set selected polar definition of wingSection at root"""
 
-        if polar_def != self._cur_polar_def and polar_def in self.wing.polar_definitions:
-            self._cur_polar_def = polar_def
-            logger.debug (f"{self} set cur_polar_def to {polar_def}")
+        if polar_def in self.wing.polar_definitions:
+            if polar_def != self._cur_polar_def:
+                self._cur_polar_def = polar_def
+                logger.debug (f"{self} set cur_polar_def to {polar_def}")
 
-            # reset current VLM opPoint 
-            self.notify_polar_definitions_changed ()    
+                if self.vlm_alpha_fixed_to_max:
+                    self._cur_vlm_alpha = None
+
+                self.sig_vlm_changed.emit()
+            else:
+                self.sig_vlm_changed.emit()
  
 
     @property
@@ -311,16 +320,15 @@ class App_Model (QObject):
 
     @property
     def cur_vlm_polar (self) -> VLM_Polar:
-        """ current VLM polar based on cur polar_def at root chord """
+        """ current VLM polar based on the selected root polar definition """
 
         if self.wing.vlm_wing and self.cur_polar_def:
-            v = self.cur_polar_def.calc_v_for_chord(self.wing.planform.chord_root)
-            new_polar =  self.wing.vlm_wing.polar_at (v) 
+            new_polar = self.wing.vlm_wing.polar_at (self.cur_polar_def)
             # do change detection for signal  
             if new_polar != self._cur_vlm_polar:
                 self._cur_vlm_polar = new_polar
                 logger.debug (f"{self} set cur_vlm_polar to {new_polar}")
-                self.sig_vlm_polar_changed.emit()
+                self.sig_vlm_changed.emit()
             return new_polar
         else:
             return None
@@ -338,7 +346,7 @@ class App_Model (QObject):
         aVal = clip (aVal, -20, 20)
         if self._cur_vlm_alpha != aVal:
             self._cur_vlm_alpha = aVal
-            self.sig_vlm_opPoint_changed.emit()
+            self.sig_vlm_changed.emit()
 
     @property
     def vlm_alpha_fixed_to_max (self) -> bool:
@@ -352,7 +360,7 @@ class App_Model (QObject):
             if aBool:                                               # try to set to max now  
                 self._cur_vlm_alpha = self._get_vlm_alpha_max ()
             
-            self.sig_vlm_opPoint_changed.emit()
+            self.sig_vlm_changed.emit()
 
     @property
     def cur_vlm_opPoint (self) -> VLM_OpPoint:
@@ -380,6 +388,7 @@ class App_Model (QObject):
         self._cur_wingSection = None
         self._cur_vlm_alpha   = None
         self._cur_polar_def   = None
+        self._set_cur_polar_def_default(silent=True)
 
         self.sig_new_wing.emit()
 
@@ -404,13 +413,12 @@ class App_Model (QObject):
         """ notify self that polar definitions have changed """
 
         # as polar definitions could have changed, ensure a new initialized polarSet 
-        self.wing.planform.wingSections.refresh_polar_sets (ensure=True)
+        self.wing.planform.wingSections.refresh_polar_sets (reset=True)
+        self._set_cur_polar_def_default(silent=True)
         self.sig_polar_set_changed.emit()
 
-        # reset alpha - may angle won't be available anymore
-        self._cur_vlm_alpha = None if self.vlm_alpha_fixed_to_max else 0.0
- 
-        QTimer.singleShot(0, self.sig_vlm_polar_reset.emit)         # notify after current events processed
+
+        QTimer.singleShot(0, self.sig_vlm_changed.emit)             # notify after current events processed
 
 
     def notify_planform_changed (self):
@@ -446,7 +454,7 @@ class App_Model (QObject):
         if self.vlm_alpha_fixed_to_max:
             self._cur_vlm_alpha = None 
 
-        QTimer.singleShot(0, self.sig_vlm_polar_reset.emit)   # notify after current events processed
+        QTimer.singleShot(0, self.sig_vlm_changed.emit)       # notify after current events processed
 
 
     def notify_fileName_changed (self):

{planformcreator2-4.3.0 → planformcreator2-4.3.2}/planformcreator2/app_modes.py

@@ -163,6 +163,12 @@ class Mode_Abstract (QObject):
         logger.debug(f"Exiting {self.__class__.__name__}")
 
 
+    def confirm_close(self) -> bool:
+        """ Default close confirmation for modes that do not need special handling. """
+
+        return True
+
+
     def prepare_check_enter(self, on_arg=None) -> object:
         """ Check if the mode can be entered. Prepare and Return initial object. """
         # to be overridden in subclasses if needed.
@@ -252,10 +258,11 @@ class Mode_Modify (Mode_Abstract):
         super().on_leave()
 
 
-    def _on_leaving_planform (self) -> bool:
+    @override
+    def confirm_close (self) -> bool:
         """ 
-        Do checks and handle if user wants to leave current planform.
-        Returns True if leaving ok, False if cancelled 
+        Do checks and handle if user wants to close or leave the current planform.
+        Returns True if leaving ok, False if cancelled.
         """
 
         leave = True
@@ -280,7 +287,7 @@ class Mode_Modify (Mode_Abstract):
                 leave = False
 
         if leave:
-            self.app_model.cleanup_wing (all = clean_up_all)
+            self.app_model.cleanup_wing (all = clean_up_all or self.wing.is_new_wing)
 
         return leave
 
@@ -288,7 +295,7 @@ class Mode_Modify (Mode_Abstract):
     def open (self):
         """ open a new wing definition and load it"""
 
-        if not self._on_leaving_planform ():                                    # changes made? user cancelled?
+        if not self.confirm_close ():                                           # changes made? user cancelled?
             return
         
         filters    = "PlanformCreator2 files (*.pc2)"
@@ -341,7 +348,7 @@ class Mode_Modify (Mode_Abstract):
     def new (self):
         """ reset - and start with example definition"""
 
-        if not self._on_leaving_planform ():                                    # changes made? user cancelled?
+        if not self.confirm_close ():                                           # changes made? user cancelled?
             return
 
         # select a new template 
@@ -399,14 +406,7 @@ class Mode_Modify (Mode_Abstract):
     def exit (self):
         """ User action: leave current mode and app. """
 
-        leave = self._on_leaving_planform ()            # changes made? user cancelled?
-
-        if leave:
-            # still new wing? - remove temp dir of airfoil strak etc
-            if self.wing.is_new_wing:
-                self.app_model.cleanup_wing (all = True)
-
-            self.sig_exit_requested.emit ()
+        self.sig_exit_requested.emit ()
 
     
     @property
@@ -631,7 +631,6 @@ class Modes_Manager (QObject):
 
     def exit(self):
         """ exit mode and close app if in view mode """
-
         if self.current_mode is not None:
             self.current_mode.on_leave()
 

{planformcreator2-4.3.0 → planformcreator2-4.3.2}/planformcreator2/model/VLM_wing.py

@@ -19,18 +19,23 @@ Wing build with VLM_Panels based on Planform_Paneled
                 |-- VLM_OpPoint         - angle of attack 
         !-- aerogrid                    - input data structure of PanelAero 
 """
-        
+from __future__                     import annotations  # for forward type references in annotations (wingSection, Planform_Paneled)
+
 import numpy as np
+from copy                           import copy
 from enum                           import StrEnum
 from typing                         import NamedTuple, TYPE_CHECKING
 from math                           import isclose, degrees, radians
 
 from .VLM                           import calc_Qjj
-from airfoileditor.model.polar_set  import Polar_Set, RE_SCALE_ROUND_TO, re_from_v, Polar
+from airfoileditor.model.polar_set  import Polar_Set, RE_SCALE_ROUND_TO, polarType, Polar, Polar_Definition
 
 if TYPE_CHECKING:
     from .wing                      import Planform_Paneled, WingSection           # avoid circular import
 
+
+VLM_Polar_CacheEntry = tuple[Polar_Definition, 'VLM_Polar']
+
 import logging
 logger = logging.getLogger(__name__)
 # logger.setLevel(logging.DEBUG)
@@ -227,7 +232,7 @@ class VLM_Wing:
         self._b_stripes     = None                  # width of stripes 
 
         self._y_sections    = None                  # y position of wing sections in m
-        self._polars        = {}                    # dict of polars
+        self._polars: list[VLM_Polar_CacheEntry] = []    # list of (root polar def, VLM polar)
 
 
     def __repr__(self) -> str:
@@ -235,7 +240,7 @@ class VLM_Wing:
         return f"<{type(self).__name__}>"
 
     @property
-    def wingSections(self) -> list :
+    def wingSections(self) -> list [WingSection]:
         """ wing sections of self._planform_paneled"""
 
         planform_paneled : Planform_Paneled = self._planform_paneled
@@ -350,34 +355,46 @@ class VLM_Wing:
 
 
 
-    def polar_at (self, vtas: float) -> 'VLM_Polar':
-        """ returns polar for air speed vtas"""
+    def _get_cached_polar (self, root_polar_def: Polar_Definition) -> 'VLM_Polar | None':
+        """ return cached VLM polar for a matching root polar definition """
 
-        if not isinstance (vtas, (int, float)) or vtas <= 0.0:
-            return None
+        for cached_root_polar_def, polar in self._polars:
+            if cached_root_polar_def.is_equal_to (root_polar_def):
+                return polar
+        return None
 
-        v = round (vtas, 1)                         #  ensure clean key for dict
 
-        polar = self._polars.get (v, None)          # already exisiting 
+    def polar_at (self, root_polar_def: Polar_Definition) -> 'VLM_Polar':
+        """ returns polar for a root airfoil polar definition """
+
+        if not isinstance (root_polar_def, Polar_Definition):
+            return None
+
+        polar = self._get_cached_polar (root_polar_def)          # already exisiting 
         
         if not polar:
-            polar = VLM_Polar (self, v)             # calculate new Polar and opPoints 
-            self._polars[v] = polar 
+            polar_def_copy = copy (root_polar_def)               # polar_def in cache must be inmutable 
+            polar = VLM_Polar (self, polar_def_copy)             # calculate new Polar and opPoints 
+            self._polars.append ((polar_def_copy, polar)) 
             
         return polar 
 
+
     def has_polars (self) -> bool:
         """ True if at least one polar is existing"""
         return bool (self._polars)
 
 
-    def remove_polar_at (self, vtas: float):
-        """ removes polar for air speed vtas - will be calculated new on next request"""
-        if not isinstance (vtas, (int, float)) or vtas <= 0.0:
+    def remove_polar_at (self, root_polar_def: Polar_Definition):
+        """ removes polar for a root airfoil polar definition - will be calculated new on next request"""
+
+        if not isinstance (root_polar_def, Polar_Definition):
             return 
 
-        v = round (vtas, 1)                         # ensure clean key for dict
-        self._polars.pop(v, None)                   # remove existing, None if not found
+        for i, (cached_root_polar_def, _) in enumerate (self._polars):
+            if cached_root_polar_def.is_equal_to (root_polar_def):
+                self._polars.pop (i)
+                break
 
 
 
@@ -544,13 +561,19 @@ class VLM_Polar:
     VLM solution for certain velocity 
     """
 
-    def __init__ (self, wing: VLM_Wing, vtas: float ):
+    def __init__ (self, wing: VLM_Wing, root_polar_def: Polar_Definition):
+
+        self.vlm_wing        = wing                     # my parent wing
+
+        # sanity - only T1 polars allowed for VLM calculation
+        if not isinstance (root_polar_def, Polar_Definition) or not root_polar_def.type == polarType.T1:
+            raise ValueError ("root polar definition must be a T1 polar definition")
 
-        self.vlm_wing       = wing 
-        self.vtas           = vtas                      # true air speed
+        self._root_polar_def = root_polar_def           # polar definition of root airfoil (wingSection 0) 
 
-        self._opPoints      = {}                        # dict of operating points
-        self._error_reason  = []                        # list of error messages eg polar couldn't be loaded 
+        self._vtas                      = None          # true air speed (derived from root polar def)
+        self._opPoints                  = {}            # dict of operating points
+        self._error_reason              = []            # list of error messages eg polar couldn't be loaded 
         self._generating_airfoil_polars = False         # airfoil polars are currently generated 
         self._use_viscous_loop          = True          # in opPoint calculation
 
@@ -572,6 +595,20 @@ class VLM_Polar:
         # overwrite to get a nice print string 
         return f"<{type(self).__name__} {self.vtas:.1f}m/s >"
 
+
+    @property
+    def vtas (self) -> float:
+        """ true air speed of self"""
+
+        if isinstance (self._root_polar_def, Polar_Definition) and self._vtas is None:
+
+            # calc v from airfoil polar and chord of root section
+            root_chord = self.vlm_wing.wingSections[0].c
+            self._vtas = self._root_polar_def.calc_v_for_chord(root_chord)
+
+        return self._vtas
+
+
     @property
     def name (self) -> str:
         """ name of polar like T1-22.3-VLM"""
@@ -774,6 +811,25 @@ class VLM_Polar:
     # ---- private ----
 
 
+    def _get_matching_polar (self, airfoil_polarSet: Polar_Set, section_re: float) -> Polar | None:
+        """ return the VLM polar that best matches root polar definition and section Re """
+
+        polar_def_target = copy (self._root_polar_def)
+        polar_def_target.set_re (section_re)
+
+        matching_polar = None
+        best_re_delta  = float("inf")
+
+        for polar in airfoil_polarSet.polars_VLM:
+            if polar.is_equal_to (polar_def_target, ignore_active=True, ignore_xtrip=True, re_abs_tolerance=RE_SCALE_ROUND_TO):
+                re_delta = abs (polar.re - section_re)
+                if re_delta < best_re_delta:
+                    matching_polar = polar
+                    best_re_delta = re_delta
+
+        return matching_polar
+
+
     def _get_airfoil_polars (self) -> list [Polar] | None:
         """ loads for all wingSections polar of airfoil"""
 
@@ -782,7 +838,7 @@ class VLM_Polar:
 
         # get airfoil polars for all wingSections
         airfoil_polars = []
-        section : WingSection
+
         for section in self.vlm_wing.wingSections:
 
             if not section.airfoil.isLoaded: 
@@ -806,26 +862,21 @@ class VLM_Polar:
 
             # find polar with matching Re of this wing section
 
-            section_re = re_from_v (self.vtas, section.c / 1000, round_to=RE_SCALE_ROUND_TO)
-
-            for polar in airfoil_polarSet.polars_VLM:
-
-                if isclose (polar.re, section_re, abs_tol=RE_SCALE_ROUND_TO):
-                    if polar.isLoaded:
-
-                        # there is a polar that fits to Re of wingSection
-                        airfoil_polars.append(polar)
+            section_re = self._root_polar_def.re * section.cn
+            matching_polar = self._get_matching_polar (airfoil_polarSet, section_re)
 
+            if matching_polar is not None:
+                if matching_polar.isLoaded:
+                    # there is a polar that fits to Re of wingSection
+                    airfoil_polars.append(matching_polar)
+                else: 
+                    if matching_polar.error_occurred: 
+                        self._error_reason.append (matching_polar.error_reason)
                     else: 
-                        if polar.error_occurred: 
-                            self._error_reason.append (polar.error_reason)
-                        else: 
-                            self._generating_airfoil_polars = True 
-                    break
-
-            if not isclose (polar.re, section_re, abs_tol=RE_SCALE_ROUND_TO): 
-                polars_re_list = [f"{p.re:.0f}" for p in airfoil_polarSet.polars_VLM]
-                msg = f"No polar with Re = {section_re:.0f} in Polarset of {section} with polars: {polars_re_list}" 
+                        self._generating_airfoil_polars = True 
+            else:
+                msg = (f"No VLM polar matching root definition within ±{RE_SCALE_ROUND_TO:.0f} Re "
+                       f"for section {section.id} (target Re={section_re:.0f}) " )
                 logger.error (msg)
                 self._error_reason.append (msg)