pyfoiltools 0.0.1__tar.gz → 0.0.2__tar.gz

{pyfoiltools-0.0.1 → pyfoiltools-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyfoiltools
-Version: 0.0.1
+Version: 0.0.2
 Summary: Python Package containing tools for pyfoil
 Author-email: Xero64 <xero64@gmail.com>
 License-Expression: MIT
@@ -8,7 +8,7 @@ Project-URL: Homepage, https://github.com/Xero64/pyfoiltools
 Project-URL: Issues, https://github.com/Xero64/pyfoiltools/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: matplotlib>=3.10.5

{pyfoiltools-0.0.1 → pyfoiltools-0.0.2}/pyproject.toml

@@ -1,12 +1,16 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
 [project]
 name = "pyfoiltools"
-version = "0.0.1"
+version = "0.0.2"
 authors = [
   { name="Xero64", email="xero64@gmail.com" },
 ]
 description = "Python Package containing tools for pyfoil"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.13"
 classifiers = [
     "Programming Language :: Python :: 3",
     "Operating System :: OS Independent",

{pyfoiltools-0.0.1 → pyfoiltools-0.0.2}/src/pyfoiltools/fitting/airfoilbspline.py

@@ -6,6 +6,7 @@ from numpy.linalg import lstsq, norm
 from py2md.classes import MDReport
 from pygeom.geom2d import BSplineCurve2D, Vector2D
 from pygeom.tools.solvers import solve_clsq
+from pygeom.tools.spacing import full_cosine_spacing
 
 from .airfoilpoly import AirfoilPoly, AirfoilPolyFit
 from .airfoilshape import AirfoilShape, AirfoilShapeFit
@@ -19,25 +20,25 @@ if TYPE_CHECKING:
 class AirfoilBSpline():
     name: str = None
     adef: AirfoilPoly | AirfoilShape = None
-    bspline_u: 'BSplineCurve2D' = None
-    bspline_l: 'BSplineCurve2D' = None
+    bspline: 'BSplineCurve2D' = None
     c: float = None
     num: int = None
-    _spacing: 'ChordSpacing' = None
+    _tu: 'NDArray' = None
     _xu: 'NDArray' = None
     _yu: 'NDArray' = None
+    _tl: 'NDArray' = None
     _xl: 'NDArray' = None
     _yl: 'NDArray' = None
+    # _t: 'NDArray' = None
     _x: 'NDArray' = None
     _y: 'NDArray' = None
 
     def __init__(self, name: str, adef: AirfoilPoly | AirfoilShape,
-                 bspline_u: 'BSplineCurve2D', bspline_l: 'BSplineCurve2D',
+                 bspline: 'BSplineCurve2D',
                  c: float = 1.0, num: int = 101) -> None:
         self.name = name
         self.adef = adef
-        self.bspline_u = bspline_u
-        self.bspline_l = bspline_l
+        self.bspline = bspline
         self.c = c
         self.num = num
 
@@ -50,53 +51,65 @@ class AirfoilBSpline():
         self.c = c
 
     @property
-    def spacing(self) -> ChordSpacing:
-        if self._spacing is None:
-            self._spacing = ChordSpacing.from_num(self.num)
-        return self._spacing
-
-    @property
-    def th(self) -> 'NDArray':
-        return self.spacing.th
+    def tu(self) -> 'NDArray':
+        if self._tu is None:
+            self._tu = full_cosine_spacing(self.num)*0.5 + 0.5
+        return self._tu
 
     @property
     def xu(self) -> 'NDArray':
         if self._xu is None:
-            pnts_u = self.bspline_u.evaluate_points_at_t(self.spacing.s)
+            pnts_u = self.bspline.evaluate_points_at_t(self.tu)
             self._xu, self._yu = pnts_u.to_xy()
         return self._xu
 
     @property
     def yu(self) -> 'NDArray':
         if self._yu is None:
-            pnts_u = self.bspline_u.evaluate_points_at_t(self.spacing.s)
+            pnts_u = self.bspline.evaluate_points_at_t(self.tu)
             self._xu, self._yu = pnts_u.to_xy()
         return self._yu
 
+    @property
+    def tl(self) -> 'NDArray':
+        if self._tl is None:
+            self._tl = (full_cosine_spacing(self.num)*0.5)[::-1]
+        return self._tl
+
     @property
     def xl(self) -> 'NDArray':
         if self._xl is None:
-            pnts_l = self.bspline_l.evaluate_points_at_t(self.spacing.s)
+            pnts_l = self.bspline.evaluate_points_at_t(self.tl)
             self._xl, self._yl = pnts_l.to_xy()
         return self._xl
 
     @property
     def yl(self) -> 'NDArray':
         if self._yl is None:
-            pnts_l = self.bspline_l.evaluate_points_at_t(self.spacing.s)
+            pnts_l = self.bspline.evaluate_points_at_t(self.tl)
             self._xl, self._yl = pnts_l.to_xy()
         return self._yl
 
+    @property
+    def t(self) -> 'NDArray':
+        if self._t is None:
+            self._t = concatenate((self.tl[::-1], self.tu[1:]))
+        return self._t
+
     @property
     def x(self) -> 'NDArray':
         if self._x is None:
             self._x = hstack((self.xl[::-1], self.xu[1:]))
+            # pnts = self.bspline.evaluate_points_at_t(self.t)
+            # self._x, self._y = pnts.to_xy()
         return self._x
 
     @property
     def y(self) -> 'NDArray':
         if self._y is None:
             self._y = hstack((self.yl[::-1], self.yu[1:]))
+            # pnts = self.bspline.evaluate_points_at_t(self.t)
+            # self._x, self._y = pnts.to_xy()
         return self._y
 
     def plot_shape(self, ax: 'Axes' = None, **kwargs: dict[str, Any]) -> 'Axes':
@@ -123,13 +136,12 @@ class AirfoilBSpline():
         return self.to_mdobj()._repr_markdown_()
 
     def __str__(self) -> str:
-        return f'AirfoilBSpline: {self.name:s}\nBSpline_u = \n{self.bspline_u}\nBSpline_l = \n{self.bspline_l}'
+        return f'AirfoilBSpline: {self.name:s}\nBSpline = \n{self.bspline}\n'
 
 
 class AirfoilBSplineFit():
     afit: AirfoilPolyFit | AirfoilShapeFit = None
-    Nu: int = None
-    Nl: int = None
+    Nb: int = None
     _adef: AirfoilPoly | AirfoilShape = None
     _spcu: ChordSpacing = None
     _THu: 'NDArray' = None
@@ -157,10 +169,9 @@ class AirfoilBSplineFit():
     _lmda: 'NDArray' = None
 
     def __init__(self, afit: AirfoilPolyFit | AirfoilShapeFit,
-                 Nu: int, Nl: int) -> None:
+                 Nb: int) -> None:
         self.afit = afit
-        self.Nu = Nu
-        self.Nl = Nl
+        self.Nb = Nb
 
     @property
     def adef(self) -> AirfoilPoly | AirfoilShape:
@@ -176,7 +187,7 @@ class AirfoilBSplineFit():
     @property
     def spcu(self) -> ChordSpacing:
         if self._spcu is None:
-            self._spcu = ChordSpacing.from_num(self.Nu)
+            self._spcu = ChordSpacing.from_num(self.Nb)
         return self._spcu
 
     @property
@@ -220,7 +231,7 @@ class AirfoilBSplineFit():
     @property
     def spcl(self) -> ChordSpacing:
         if self._spcl is None:
-            self._spcl = ChordSpacing.from_num(self.Nl)
+            self._spcl = ChordSpacing.from_num(self.Nb)
         return self._spcl
 
     @property
@@ -265,37 +276,46 @@ class AirfoilBSplineFit():
     def aspl(self) -> AirfoilBSpline:
         if self._aspl is None:
 
-            ctlpnts_u = Vector2D.zeros(self.Nu + 1)
-            ctlpnts_u.x[1:] = self.Xcu + self.Ucu*self.Tcu
-            ctlpnts_u.y[1:] = self.Ycu + self.Vcu*self.Tcu
-            bspline_u = BSplineCurve2D(ctlpnts_u, degree=self.Nu)
+            Xl = self.Xcl + self.Ucl*self.Tcl
+            Yl = self.Ycl + self.Vcl*self.Tcl
+
+            Xu = self.Xcu + self.Ucu*self.Tcu
+            Yu = self.Ycu + self.Vcu*self.Tcu
+
+            Xb = concatenate((Xl[::-1], zeros((1,)), Xu))
+            Yb = concatenate((Yl[::-1], zeros((1,)), Yu))
+
+            ctlpnts = Vector2D(Xb, Yb)
 
-            ctlpnts_l = Vector2D.zeros(self.Nl + 1)
-            ctlpnts_l.x[1:] = self.Xcl + self.Ucl*self.Tcl
-            ctlpnts_l.y[1:] = self.Ycl + self.Vcl*self.Tcl
-            bspline_l = BSplineCurve2D(ctlpnts_l, degree=self.Nl)
+            bspline = BSplineCurve2D(ctlpnts, degree=self.Nb)
 
             self._aspl = AirfoilBSpline(self.adef.name, self.adef,
-                                        bspline_u, bspline_l)
+                                        bspline)
 
         return self._aspl
 
     @property
     def tu(self) -> 'NDArray':
         if self._tu is None:
-            self._tu = self.afit.spcu.s.copy()
-            self._tu = bspline_lstsq_fit_t(self.aspl.bspline_u, self.afit.xu,
+            self._tu = self.afit.spcu.s.copy()*0.5 + 0.5
+            self._tu = bspline_lstsq_fit_t(self.aspl.bspline, self.afit.xu,
                                            self.afit.yu, self._tu)
         return self._tu
 
     @property
     def tl(self) -> 'NDArray':
         if self._tl is None:
-            self._tl = self.afit.spcl.s.copy()
-            self._tl = bspline_lstsq_fit_t(self.aspl.bspline_l, self.afit.xl,
+            self._tl = (self.afit.spcl.s.copy()*0.5)[::-1]
+            self._tl = bspline_lstsq_fit_t(self.aspl.bspline, self.afit.xl,
                                            self.afit.yl, self._tl)
         return self._tl
 
+    @property
+    def t(self) -> 'NDArray':
+        if self._t is None:
+            self._t = concatenate((self.tu, self.tl))
+        return self._t
+
     @property
     def num_Tu(self) -> int:
         return self.Tcu.size - 1
@@ -373,16 +393,12 @@ class AirfoilBSplineFit():
         ax = self.adef.plot_shape(ax=ax)
         ax = self.afit.airfoil.plot(ax=ax)
 
-        pnts_u = self.aspl.bspline_u.evaluate_points(100)
-        pnts_l = self.aspl.bspline_l.evaluate_points(100)
+        pnts = self.aspl.bspline.evaluate_points(100)
 
-        ctls_u = self.aspl.bspline_u.ctlpnts
-        ctls_l = self.aspl.bspline_l.ctlpnts
+        ctls = self.aspl.bspline.ctlpnts
 
-        ax.plot(pnts_u.x, pnts_u.y, label='BSpline Fit Upper')
-        ax.plot(pnts_l.x, pnts_l.y, label='BSpline Fit Lower')
-        ax.plot(ctls_u.x, ctls_u.y, '-o', label='Control Points Upper')
-        ax.plot(ctls_l.x, ctls_l.y, '-o', label='Control Points Lower')
+        ax.plot(pnts.x, pnts.y, label='BSpline Fit')
+        ax.plot(ctls.x, ctls.y, '-o', label='Control Points')
         ax.plot(self.afit.xu, self.afit.yu, 'x', label='Target Points Upper')
         ax.plot(self.afit.xl, self.afit.yl, 'x', label='Target Points Lower')
         _ = ax.legend()
@@ -390,41 +406,45 @@ class AirfoilBSplineFit():
 
     def improved_fit(self, display: bool = False) -> tuple[float, float]:
 
-        xu, yu = self.aspl.bspline_u.evaluate_points_at_t(self.tu).to_xy()
+        xu, yu = self.aspl.bspline.evaluate_points_at_t(self.tu).to_xy()
 
         Dxu = xu - self.afit.xu
         Dyu = yu - self.afit.yu
 
-        xl, yl = self.aspl.bspline_l.evaluate_points_at_t(self.tl).to_xy()
+        xl, yl = self.aspl.bspline.evaluate_points_at_t(self.tl).to_xy()
 
         Dxl = xl - self.afit.xl
         Dyl = yl - self.afit.yl
 
         f = concatenate((Dxu, Dyu, Dxl, Dyl))
 
-        Ntu = self.aspl.bspline_u.basis_functions(self.tu).transpose()
+        Nt = self.aspl.bspline.basis_functions(self.tu).transpose()
+
+        Ntu = Nt[:, self.Nb:]
 
-        dDxudXu = Ntu[:, 1:self.Nu]
-        dDyudYu = Ntu[:, 1:self.Nu]
+        dDxudXu = Ntu[:, 1:self.Nb]
+        dDyudYu = Ntu[:, 1:self.Nb]
 
-        Ntl = self.aspl.bspline_l.basis_functions(self.tl).transpose()
+        Nt = self.aspl.bspline.basis_functions(self.tl).transpose()
 
-        dDxldXl = Ntl[:, 1:self.Nl]
-        dDyldYl = Ntl[:, 1:self.Nl]
+        Ntl = Nt[:, self.Nb::-1]
+
+        dDxldXl = Ntl[:, 1:self.Nb]
+        dDyldYl = Ntl[:, 1:self.Nb]
 
         dDxudTu = dDxudXu@self.dXudTu + dDyudYu@self.dYudTu
-        dDxudTl = zeros((xu.size, self.Nl - 1))
+        dDxudTl = zeros((xu.size, self.Nb - 1))
 
         dDyudTu = dDyudYu@self.dYudTu + dDyudYu@self.dYudTu
-        dDyudTl = zeros((yu.size, self.Nl - 1))
+        dDyudTl = zeros((yu.size, self.Nb - 1))
 
         dDxldTl = dDxldXl@self.dXldTl + dDyldYl@self.dYldTl
-        dDxldTu = zeros((xl.size, self.Nu - 1))
+        dDxldTu = zeros((xl.size, self.Nb - 1))
 
         dDyldTl = dDyldYl@self.dYldTl + dDyldYl@self.dYldTl
-        dDyldTu = zeros((yl.size, self.Nu - 1))
+        dDyldTu = zeros((yl.size, self.Nb - 1))
 
-        dDxudtu, dDyudtu = self.aspl.bspline_u.evaluate_first_derivatives_at_t(self.tu).to_xy()
+        dDxudtu, dDyudtu = self.aspl.bspline.evaluate_first_derivatives_at_t(self.tu).to_xy()
 
         dDxudtu = diag(dDxudtu)
         dDxudtl = zeros((xu.size, self.tl.size))
@@ -432,7 +452,7 @@ class AirfoilBSplineFit():
         dDyudtu = diag(dDyudtu)
         dDyudtl = zeros((yu.size, self.tl.size))
 
-        dDxldtl, dDyldtl = self.aspl.bspline_l.evaluate_first_derivatives_at_t(self.tl).to_xy()
+        dDxldtl, dDyldtl = self.aspl.bspline.evaluate_first_derivatives_at_t(self.tl).to_xy()
 
         dDxldtl = diag(dDxldtl)
         dDxldtu = zeros((xl.size, self.tu.size))
@@ -441,9 +461,9 @@ class AirfoilBSplineFit():
         dDyldtu = zeros((yl.size, self.tu.size))
 
         dfdTt = block([[dDxudTu, dDxudTl, dDxudtu, dDxudtl],
-                    [dDyudTu, dDyudTl, dDyudtu, dDyudtl],
-                    [dDxldTu, dDxldTl, dDxldtu, dDxldtl],
-                    [dDyldTu, dDyldTl, dDyldtu, dDyldtl]])
+                       [dDyudTu, dDyudTl, dDyudtu, dDyudtl],
+                       [dDxldTu, dDxldTl, dDxldtu, dDxldtl],
+                       [dDyldTu, dDyldTl, dDyldtu, dDyldtl]])
 
         dvTt, dlTt = solve_clsq(dfdTt, f, self.carr, self.darr)
 
@@ -473,11 +493,13 @@ class AirfoilBSplineFit():
 
         return normdcon, normdvar
 
-    def improved_fit_loop(self, tol_dcon: float = 1e-12, tol_dvar: float = 1e-3,
-                          max_iter: int = 50, display: bool = False) -> tuple[float, float]:
+    def improved_fit_loop(self, tol_dcon: float = 1e-12,
+                          tol_dvar: float = 1e-3, max_iter: int = 50,
+                          display: bool = False) -> tuple[float, float, bool]:
 
         normdcon, normdvar = float('inf'), float('inf')
 
+        conv = True
         iter = 1
         while normdcon > tol_dcon or normdvar > tol_dvar:
             normdcon, normdvar = self.improved_fit()
@@ -487,11 +509,14 @@ class AirfoilBSplineFit():
                 print(f'normdvar = {normdvar:.12f}')
                 print()
             if iter >= max_iter:
+                conv = False
                 err = f'Maximum number of iterations ({max_iter}) reached.'
-                raise RuntimeError(err)
+                print(err)
+                break
+                # raise RuntimeError(err)
             iter += 1
 
-        return normdcon, normdvar
+        return normdcon, normdvar, conv
 
     def __repr__(self) -> str:
         return f'<AirfoilBSplineFit: {self.adef.name:s}>'

{pyfoiltools-0.0.1 → pyfoiltools-0.0.2}/src/pyfoiltools/fitting/airfoilpoly.py

@@ -702,16 +702,16 @@ class AirfoilPoly():
     def to_mdobj(self) -> MDReport:
         report = MDReport()
         report.add_heading(f'Airfoil Shape: {self.name:s}', level=1)
-        table = report.add_table()
         if self.Cn.size > 0:
+            table = report.add_table()
             table.add_column('Leading Edge Camber %', '.3f', data=[self.yc_le/self.c])
             table.add_column('Trailing Edge Camber %', '.3f', data=[self.yc_te/self.c])
             table.add_column('Max Camber %', '.3f', data=[self.max_yc/self.c*100])
             table.add_column('Max Camber Position %', '.3f', data=[self.max_yc_pc*100])
             table.add_column('Leading Edge Angle (deg)', '.3f', data=[degrees(self.thy_le)])
             table.add_column('Trailing Edge Angle (deg)', '.3f', data=[degrees(self.thy_te)])
-        table = report.add_table()
         if self.Tn.size > 0:
+            table = report.add_table()
             table.add_column('Trailing Edge Thickness %', '.3f', data=[self.tc_te/self.c])
             table.add_column('Max Thickness %', '.3f', data=[self.max_tc/self.c*100])
             table.add_column('Max Thickness Position %', '.3f', data=[self.max_tc_pc*100])

{pyfoiltools-0.0.1 → pyfoiltools-0.0.2}/src/pyfoiltools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyfoiltools
-Version: 0.0.1
+Version: 0.0.2
 Summary: Python Package containing tools for pyfoil
 Author-email: Xero64 <xero64@gmail.com>
 License-Expression: MIT
@@ -8,7 +8,7 @@ Project-URL: Homepage, https://github.com/Xero64/pyfoiltools
 Project-URL: Issues, https://github.com/Xero64/pyfoiltools/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: matplotlib>=3.10.5