pyfoiltools 0.0.1__tar.gz

pyfoiltools-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Xero64
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyfoiltools-0.0.1/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: pyfoiltools
+Version: 0.0.1
+Summary: Python Package containing tools for pyfoil
+Author-email: Xero64 <xero64@gmail.com>
+License-Expression: MIT
+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
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib>=3.10.5
+Requires-Dist: pygeom>=0.0.13
+Requires-Dist: numpy>=2.2.6
+Requires-Dist: py2md>=0.1.3
+Dynamic: license-file
+
+# pyfoiltools
+
+Python Package containing tools for pyfoil

pyfoiltools-0.0.1/README.md

@@ -0,0 +1,3 @@
+# pyfoiltools
+
+Python Package containing tools for pyfoil

pyfoiltools-0.0.1/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "pyfoiltools"
+version = "0.0.1"
+authors = [
+  { name="Xero64", email="xero64@gmail.com" },
+]
+description = "Python Package containing tools for pyfoil"
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+dependencies = [
+    "matplotlib>=3.10.5",
+    "pygeom>=0.0.13",
+    "numpy>=2.2.6",
+    "py2md>=0.1.3",
+]
+
+[project.urls]
+Homepage = "https://github.com/Xero64/pyfoiltools"
+Issues = "https://github.com/Xero64/pyfoiltools/issues"

pyfoiltools-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyfoiltools-0.0.1/src/pyfoiltools/airfoil.py

@@ -0,0 +1,207 @@
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
+
+from matplotlib.pyplot import figure
+from numpy import arctan2, argmax, asarray, cos, flip, sin, sqrt
+
+if TYPE_CHECKING:
+    from matplotlib.axes import Axes
+    from numpy.typing import NDArray
+
+
+class Airfoil():
+    name: str = None
+    x: 'NDArray' = None
+    y: 'NDArray' = None
+    _xte: float = None
+    _yte: float = None
+    _ile: int = None
+    _xle: float = None
+    _yle: float = None
+    _chord: float = None
+    _alrad: float = None
+    _tte: float = None
+    _area: float = None
+    _xu: 'NDArray' = None
+    _yu: 'NDArray' = None
+    _xl: 'NDArray' = None
+    _yl: 'NDArray' = None
+
+    def __init__(self, name: str, x: Iterable, y: Iterable) -> None:
+        self.name = name
+        self.x = asarray(x)
+        self.y = asarray(y)
+        self.validate_area()
+
+    def reset(self) -> None:
+        for attr in self.__dict__:
+            if attr.startswith('_'):
+                setattr(self, attr, None)
+
+    @property
+    def xte(self) -> float:
+        if self._xte is None:
+            self._xte = (self.x[-1] + self.x[0])/2
+        return self._xte
+
+    @property
+    def yte(self) -> float:
+        if self._yte is None:
+            self._yte = (self.y[-1] + self.y[0])/2
+        return self._yte
+
+    @property
+    def ile(self) -> int:
+        if self._ile is None:
+            dx = self.x - self.xte
+            dy = self.y - self.yte
+            d2 = dx**2 + dy**2
+            self._ile = argmax(d2)
+        return self._ile
+
+    @property
+    def xle(self) -> float:
+        if self._xle is None:
+            self._xle = self.x[self.ile]
+        return self._xle
+
+    @property
+    def yle(self) -> float:
+        if self._yle is None:
+            self._yle = self.y[self.ile]
+        return self._yle
+
+    def calc_alrad_chord(self) -> None:
+        dx = self.xte - self.xle
+        dy = self.yte - self.yle
+        self._chord = sqrt(dx**2 + dy**2)
+        self._alrad = arctan2(dy, dx)
+
+    @property
+    def alrad(self) -> float:
+        if self._alrad is None:
+            self.calc_alrad_chord()
+        return self._alrad
+
+    @property
+    def chord(self) -> float:
+        if self._chord is None:
+            self.calc_alrad_chord()
+        return self._chord
+
+    @property
+    def tte(self) -> float:
+        if self._tte is None:
+            dx = self.x[-1] - self.x[0]
+            dy = self.y[-1] - self.y[0]
+            self._tte = sqrt(dx**2 + dy**2)
+        return self._tte
+
+    def validate_area(self) -> None:
+        xa = self.x[:-1]
+        xb = self.x[1:]
+        ya = self.y[:-1]
+        yb = self.y[1:]
+        doubarea = xb*ya - xa*yb
+        xa = self.x[-1]
+        xb = self.x[0]
+        ya = self.y[-1]
+        yb = self.y[0]
+        doubarea = doubarea.sum() + xb*ya - xa*yb
+        if doubarea < 0.0:
+            self.reverse()
+            self._area = -doubarea/2
+        else:
+            self._area = doubarea/2
+
+    @property
+    def area(self) -> float:
+        if self._area is None:
+            self.validate_area()
+        return self._area
+
+    @property
+    def xu(self) -> 'NDArray':
+        if self._xu is None:
+            self._xu = self.x[self.ile:]
+        return self._xu
+
+    @property
+    def yu(self) -> 'NDArray':
+        if self._yu is None:
+            self._yu = self.y[self.ile:]
+        return self._yu
+
+    @property
+    def xl(self) -> 'NDArray':
+        if self._xl is None:
+            self._xl = flip(self.x[:self.ile+1])
+        return self._xl
+
+    @property
+    def yl(self) -> 'NDArray':
+        if self._yl is None:
+            self._yl = flip(self.y[:self.ile+1])
+        return self._yl
+
+    def scale(self, scale: float) -> None:
+        self.x = self.x*scale
+        self.y = self.y*scale
+        self.reset()
+
+    def translate(self, x: float, y: float) -> None:
+        self.x = self.x + x
+        self.y = self.y + y
+        self.reset()
+
+    def rotate(self, angle: float) -> None:
+        cosal = cos(angle)
+        sinal = sin(angle)
+        self.x = self.x*cosal - self.y*sinal
+        self.y = self.x*sinal + self.y*cosal
+        self.reset()
+
+    def normalise(self) -> None:
+        self.translate(-self.xle, -self.yle)
+        self.scale(1/self.chord)
+        self.rotate(-self.alrad)
+
+    def reverse(self) -> None:
+        self.x = self.x[::-1]
+        self.y = self.y[::-1]
+        self.reset()
+
+    def plot(self, ax: 'Axes' = None) -> 'Axes':
+        if ax is None:
+            fig = figure()
+            ax = fig.gca()
+            ax.grid(True)
+            ax.set_aspect('equal')
+        ax.plot(self.x, self.y, label=self.name)
+        return ax
+
+    def __repr__(self) -> str:
+        return f'<Airfoil: {self.name:s}>'
+
+    def __str__(self) -> str:
+        return f'Airfoil: {self.name:s}'
+
+    @classmethod
+    def from_dat(cls, datfilepath: str) -> 'Airfoil':
+
+        name = ''
+        x = []
+        y = []
+
+        with open(datfilepath, 'rt') as file:
+            for i, line in enumerate(file):
+                line = line.rstrip('\n')
+                if i == 0:
+                    name = line.strip()
+                else:
+                    split = line.split()
+                    if len(split) == 2:
+                        x.append(float(split[0]))
+                        y.append(float(split[1]))
+
+        return cls(name, x, y)

pyfoiltools-0.0.1/src/pyfoiltools/fitting/__init__.py

@@ -0,0 +1,7 @@
+from .airfoilbspline import AirfoilBSpline as AirfoilBSpline
+from .airfoilbspline import AirfoilBSplineFit as AirfoilBSplineFit
+from .airfoilpoly import AirfoilPoly as AirfoilPoly
+from .airfoilpoly import AirfoilPolyFit as AirfoilPolyFit
+from .airfoilshape import AirfoilShape as AirfoilShape
+from .airfoilshape import AirfoilShapeFit as AirfoilShapeFit
+from .chordspacing import ChordSpacing as ChordSpacing