archibald-design 1.0.0__tar.gz

archibald_design-1.0.0/MANIFEST.in

@@ -0,0 +1,4 @@
+# Ship only the archibald package (README, LICENSE and pyproject.toml are added automatically)
+graft archibald
+prune archibald/tests
+global-exclude *.py[cod] __pycache__ .DS_Store

archibald_design-1.0.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: archibald-design
+Version: 1.0.0
+Summary: Core computational and geometry processing library for Archibald.
+Author-email: Jules Richeux <j.richeux@neoline.eu>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/julesricheux/Archibald
+Project-URL: Repository, https://github.com/julesricheux/Archibald
+Project-URL: Issues, https://github.com/julesricheux/Archibald/issues
+Keywords: vpp,geometry,mesh
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: sympy
+Requires-Dist: casadi
+Requires-Dist: trimesh
+Requires-Dist: ezdxf
+Requires-Dist: mapbox-earcut
+Requires-Dist: polars
+Requires-Dist: sortedcontainers
+Requires-Dist: dill
+Requires-Dist: neuralfoil
+
+# [archibald 1.0.0](https://github.com/julesricheux/archibald/) :sailboat:✏️
+
+- 🐍 Archibald is a performance prediction package for sailboats and ships in the preliminary design stage. It is written in Python 3.
+- 🎓 It is aimed in particular at naval architecture students. It is still under development, but its modules are now ready to be used independently.
+- ✏️ In particular, [Rhino](https://www.rhino3d.com) and [AutoCAD](https://www.autodesk.com/products/autocad/overview) models and drawings can be directly imported for computation, giving an easy workflow to quickly assess the impact of design choices on performance, and play with it.
+
+# ⚓ Main features
+- Holtrop and Delft hull resistance method
+- Built-in mesh-based hydrostatics
+- Inviscid fluid-boundary layer coupling
+
+# 🧪 Experimental features
+- Sails computation with vertical wind gradient
+- Planing hull resistance computation
+- Post-stall aerodynamics model
+
+# 📌 Portfolio
+Archibald 1.0.0 was widely used in the following student projects:
+<table>
+    <tr>
+        <td width="33%" valign="top">
+            <p align="center">
+                MOLENEZ II - Sailing general cargo ship for Ponant Islands feeding
+            </p>
+            <img src="https://github.com/user-attachments/assets/ceba01a2-922a-421d-bd6c-c827573c1b30" alt="Molenez II Render">
+            <img src="https://github.com/user-attachments/assets/db25fa33-8740-48de-9531-691ed062cc27" alt="Molenez II Sail plan">
+            <img src="https://github.com/user-attachments/assets/e0e79c12-b445-46c4-895b-0544a536c75d" alt="Molenez II Stability">
+        </td>
+        <td width="33%" valign="top">
+            <p align="center">
+                NEREUS - Fast humanitarian aid vessel (tested in Centrale Nantes' towing tank)
+            </p>
+            <img src="https://github.com/user-attachments/assets/d63d57ea-cb07-4af6-bede-40f578e1951e" alt="Nereus render">
+            <img src="https://github.com/user-attachments/assets/9f410fe0-0764-407c-9208-8b29de3075d3" alt="Nereus towing tank">
+            <img src="https://github.com/user-attachments/assets/ea89a466-430e-4abe-b30e-adcf57495677" alt="Nereus Stability">
+        </td>
+        <td width="33%" valign="top">
+            <p align="center">
+                PAKI'AKA - Radical and high-performance bamboo 18ft skiff
+            </p>
+            <img src="https://github.com/user-attachments/assets/1d9cca6a-bce4-4243-a564-03f7da629c61" alt="Paki'aka render 1">
+            <img src="https://github.com/user-attachments/assets/cd04bdaa-1c12-40e7-ba01-869ccf1edff9" alt="Paki'aka render 1">
+        </td>
+    </tr>
+</table>
+
+# 💡 Examples
+
+Different examples of basic use can be found in /examples/:
+- Hydrostatics and stability curve computation
+- Hull resistance computation
+- Appendage hydrodynamics computation
+- Sails aerodynamics computation
+
+# 📜 References
+Papers used to write this code can be found in /refs/
+
+# 🔗 Dependencies
+## ⚓ For general use:
+NumPy
+SciPy
+Trimesh
+ezdxf
+Shapely
+csv
+tqdm
+Matplotlib
+
+## 🧪 For experimental features:
+AeroSandbox
+OpenPlaning
+
+# ⚖️ License
+Licensed under [MIT License, terms here](https://opensource.org/license/mit)

archibald_design-1.0.0/README.md

@@ -0,0 +1,74 @@
+# [archibald 1.0.0](https://github.com/julesricheux/archibald/) :sailboat:✏️
+
+- 🐍 Archibald is a performance prediction package for sailboats and ships in the preliminary design stage. It is written in Python 3.
+- 🎓 It is aimed in particular at naval architecture students. It is still under development, but its modules are now ready to be used independently.
+- ✏️ In particular, [Rhino](https://www.rhino3d.com) and [AutoCAD](https://www.autodesk.com/products/autocad/overview) models and drawings can be directly imported for computation, giving an easy workflow to quickly assess the impact of design choices on performance, and play with it.
+
+# ⚓ Main features
+- Holtrop and Delft hull resistance method
+- Built-in mesh-based hydrostatics
+- Inviscid fluid-boundary layer coupling
+
+# 🧪 Experimental features
+- Sails computation with vertical wind gradient
+- Planing hull resistance computation
+- Post-stall aerodynamics model
+
+# 📌 Portfolio
+Archibald 1.0.0 was widely used in the following student projects:
+<table>
+    <tr>
+        <td width="33%" valign="top">
+            <p align="center">
+                MOLENEZ II - Sailing general cargo ship for Ponant Islands feeding
+            </p>
+            <img src="https://github.com/user-attachments/assets/ceba01a2-922a-421d-bd6c-c827573c1b30" alt="Molenez II Render">
+            <img src="https://github.com/user-attachments/assets/db25fa33-8740-48de-9531-691ed062cc27" alt="Molenez II Sail plan">
+            <img src="https://github.com/user-attachments/assets/e0e79c12-b445-46c4-895b-0544a536c75d" alt="Molenez II Stability">
+        </td>
+        <td width="33%" valign="top">
+            <p align="center">
+                NEREUS - Fast humanitarian aid vessel (tested in Centrale Nantes' towing tank)
+            </p>
+            <img src="https://github.com/user-attachments/assets/d63d57ea-cb07-4af6-bede-40f578e1951e" alt="Nereus render">
+            <img src="https://github.com/user-attachments/assets/9f410fe0-0764-407c-9208-8b29de3075d3" alt="Nereus towing tank">
+            <img src="https://github.com/user-attachments/assets/ea89a466-430e-4abe-b30e-adcf57495677" alt="Nereus Stability">
+        </td>
+        <td width="33%" valign="top">
+            <p align="center">
+                PAKI'AKA - Radical and high-performance bamboo 18ft skiff
+            </p>
+            <img src="https://github.com/user-attachments/assets/1d9cca6a-bce4-4243-a564-03f7da629c61" alt="Paki'aka render 1">
+            <img src="https://github.com/user-attachments/assets/cd04bdaa-1c12-40e7-ba01-869ccf1edff9" alt="Paki'aka render 1">
+        </td>
+    </tr>
+</table>
+
+# 💡 Examples
+
+Different examples of basic use can be found in /examples/:
+- Hydrostatics and stability curve computation
+- Hull resistance computation
+- Appendage hydrodynamics computation
+- Sails aerodynamics computation
+
+# 📜 References
+Papers used to write this code can be found in /refs/
+
+# 🔗 Dependencies
+## ⚓ For general use:
+NumPy
+SciPy
+Trimesh
+ezdxf
+Shapely
+csv
+tqdm
+Matplotlib
+
+## 🧪 For experimental features:
+AeroSandbox
+OpenPlaning
+
+# ⚖️ License
+Licensed under [MIT License, terms here](https://opensource.org/license/mit)

archibald_design-1.0.0/archibald/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+from pathlib import Path
+
+_archibald_root = Path(__file__).parent
+
+__version__ = "0.1.0"

archibald_design-1.0.0/archibald/boat.py

@@ -0,0 +1,388 @@
+# -*- coding: utf-8 -*-
+"""
+ENTIRE SHIP DESCRIPTION AND PERFORMANCE COMPUTATION
+NB: NOT YET READY FOR GENERAL USE
+
+Created: 01/07/2023
+Last update: 03/01/2024
+
+@author: Jules Richeux
+@university: ENSA Nantes, FRANCE
+@contributors: -
+
+
+Further development plans:
+    
+    - Automate the settings of response surfaces bounds for each parameter.
+      Measurement points distribution should also be made adaptive to reduce 
+      computation time
+    
+    - Stabilise the equilibrium computation from response surfaces. In particular,
+      errors occur when a parameter goes outside the bounds of response surface.
+      The interpolation method has already been changed to an RBF interpolator
+      to increase tolerance and allow for extrapolation. User should though be
+      warned when etrapolation is used
+      
+    - Test the results on different designs to assess their errors
+"""
+
+
+#%% DEPENDENCIES
+
+import os
+
+from tqdm import tqdm
+import numpy as np
+import pickle
+
+import scipy.interpolate as itrp
+import scipy.optimize as opt
+
+from archibald.hull import Hull
+from archibald.rig import Rig
+from archibald.environment import _Environment, OffshoreEnvironment, InshoreEnvironment
+
+from archibald.tools.geom_utils import *
+from archibald.tools.math_utils import *
+
+
+#%% CLASSES
+
+class _Boat():
+    def __init__(self, 
+                 name: str = 'boat',
+                 env: _Environment = _Environment()):
+        self.name = name
+        self.hull = None
+        self.hull_method = str()
+        
+        self.rig = None
+        
+        self.environment = env
+        
+        self.RS = dict()
+        
+        
+    def add_hull(self,
+                 name: str = 'hull',
+                 displacement: float = 0.0,
+                 cog: np.array = np.zeros(3),
+                 mesh: str = None):
+    
+        self.hull = Hull(self.name+'_'+name, displacement, cog, mesh, self.environment)
+        
+        
+    def add_rig(self,
+                name: str = 'rig'):
+        
+        self.rig = Rig(self.name+'_'+name, self.environment)
+        
+        
+    def build_RS(self, dim, paramRanges, paramN, function, fArgs, dataNames, msg):
+        
+        # Create the corresponding meshgrid
+        XX = np.meshgrid(*paramRanges)
+        # Combine XX and YY into a (N, p) array
+        X = np.column_stack([xx.ravel() for xx in XX])
+        
+        values = [np.zeros(len(X)) for j in range(len(dataNames))]
+        it = np.nditer(values, flags=['multi_index'])
+        
+        iterable = tqdm(range(len(X)), desc=msg, position=0, leave=True)
+        
+        idx = []
+        for x in it:
+            idx.append(it.multi_index)
+        
+        for i in iterable:
+            param = [X[i, k] for k in range(dim)]
+            
+            data = function(*param, *fArgs)
+            
+            for j in range(len(dataNames)):
+                values[j][i] = data[j]
+        
+        # RS = [itrp.RegularGridInterpolator(paramRanges, values[j], method='cubic') for j in range(len(dataNames))]
+        RS = [itrp.RBFInterpolator(X, values[j], kernel='linear') for j in range(len(dataNames))]
+        
+        for i, data in enumerate(dataNames):
+            self.RS[data] = RS[i]
+        
+        # aws range ?
+        # awa range from 0 to 180
+        # speed range from Fn 0 to Fn 0.74 (dsyhs)
+        # speed range from Fn 0 to Fn 0.53 (holtrop)
+        # delta range from 0 to 45
+        # heel range from 0 to 90
+        
+        
+    def build_hull_RS(self, n=10, trim=0):
+        
+        def function(V, heel, delta, trim, method):
+            self.hull.free_immersion(heel, trim)
+            Rt = self.hull.compute_hull_resistance(V, heel=heel, trim=trim, delta=delta, method=method)
+            
+            return Rt, self.hull.hydrostaticData['GZt']
+        
+        dataNames = ['FxHull', 'GZ']
+        
+        dim = 3
+        
+        # paramN = np.array([4,3,2])
+        paramN = np.ones(dim, dtype='int') * n
+        
+        vmax = 0.55 * np.sqrt(self.environment.g * self.hull.Loa)
+        
+        paramExtrema = np.array([[0,vmax],
+                                [0,80],
+                                [0,10]])
+        paramPowers = np.array([1, 2, 3])
+        paramRanges = [np.linspace(0,1,paramN[i])**paramPowers[i] *\
+                      (paramExtrema[i][1] - paramExtrema[i][0]) + paramExtrema[i][0]
+                      for i in range(dim)]
+        
+        fArgs = (trim, self.method)
+        
+        msg = "Building hull response surfaces"
+        
+        self.build_RS(dim, paramRanges, paramN, function, fArgs, dataNames, msg)
+
+        
+    def build_rig_RS(self, n=10, beta=None):
+        
+        def function(aws, awa, beta):
+            
+            self.rig.compute_aerodynamics(awa, aws, beta)
+            
+            rho = self.environment.air.rho
+            FxSail = 1/2 * rho * self.rig.area * aws**2 * self.rig.get_CX(awa)
+            FySail = 1/2 * rho * self.rig.area * aws**2 * self.rig.get_CY(awa)
+            
+            return FxSail, FySail, *self.rig.centroid
+        
+        dataNames = ['FxRig', 'FyRig', 'xCE', 'yCE', 'zCE']
+        
+        dim = 2
+        
+        paramN = np.ones(dim, dtype='int') * n
+        
+        paramExtrema = np.array([[0,20],
+                                 [0,120]])
+        paramPowers = np.array([1, 1])
+        paramRanges = [np.linspace(0,1,paramN[i])**paramPowers[i] *\
+                      (paramExtrema[i][1] - paramExtrema[i][0]) + paramExtrema[i][0]
+                      for i in range(dim)]
+        
+        fArgs = (None,)
+        
+        msg = "Building rig response surfaces"
+        
+        self.build_RS(dim, paramRanges, paramN, function, fArgs, dataNames, msg)
+        
+        
+    def build_appendage_RS(self, n=10):
+        
+        def function(V, drift, neutralRudder=True, verbose=False):
+            if neutralRudder:
+                self.hull.set_rudder_angle(-0.88 * drift)
+            else:
+                self.hull.set_rudder_angle(0.0)
+                
+            self.hull.compute_appendage_hydrodynamics(drift, V, disp=verbose)
+            
+            rho = self.environment.water.rho
+            FxApp = 1/2 * rho * self.hull.area * V**2 * self.hull.get_CD
+            FyApp = 1/2 * rho * self.hull.area * V**2 * self.hull.get_CL
+            
+            return FxApp, FyApp, *self.hull.centroid
+        
+        dataNames = ['FxApp', 'FyApp', 'xCLR', 'yCLR', 'zCLR']
+        
+        dim = 2
+        
+        paramN = np.ones(dim, dtype='int') * n
+        
+        vmax = 0.55 * np.sqrt(self.environment.g * self.hull.Loa) * 2
+        
+        paramExtrema = np.array([[0,vmax],
+                                [0,10]])
+        paramPowers = np.array([1, 3])
+        paramRanges = [np.linspace(0,1,paramN[i])**paramPowers[i] *\
+                      (paramExtrema[i][1] - paramExtrema[i][0]) + paramExtrema[i][0]
+                      for i in range(dim)]
+        
+        fArgs = (True, False)
+        
+        msg = "Building appendages response surfaces"
+        
+        self.build_RS(dim, paramRanges, paramN, function, fArgs, dataNames, msg)
+        
+        
+    def save_RS(self, directory='./archibald_saves/', filename=None):
+        # Create the directory if it doesn't exist        
+        os.makedirs(directory, exist_ok=True)
+        
+        # Define the file path
+        if filename == None:
+            filename = self.name+'.pkl'
+        filepath = os.path.join(directory, filename)
+        
+        # Save the variable to the file
+        with open(filepath, 'wb') as f:
+            pickle.dump(self.RS, f)
+            
+            
+    def load_RS(self, directory='./archibald_saves/', filename=None):
+        # Define the file path
+        if filename == None:
+            filename = self.name+'.pkl'
+        filepath = os.path.join(directory, filename)
+        
+        if os.path.exists(filepath):
+            # Open the file and retrieve the variable
+            with open(filepath, 'rb') as f:
+                self.RS = pickle.load(f)
+        else:
+            print('No such saved file or directory: '+filepath)
+    
+    
+    def free_speed(self, tws, twa, heel, drift):
+        
+        def f(X, tws, twa, heel, drift):
+            # initialize parameters
+            V = X[0]
+            aws, awa = compute_AW(tws, twa, V)
+            
+            Fx = self.RS['FxRig'](np.array([[aws, awa]]))[0]
+            Rx = self.RS['FxHull'](np.array([[V, heel, drift]]))[0] + self.RS['FxApp'](np.array([[V, drift]]))[0]
+            
+            return Fx - Rx
+    
+        X0 = np.ones(1)
+        fArgs = (tws, twa, heel, drift)
+        # xBounds = [(1e-3,4)]
+        
+        Xopt = opt.root(f, X0, args=fArgs)
+        
+        return Xopt.x[0]
+    
+    def free_speed_heel(self, tws, twa, drift):
+        g = self.environment.g
+        
+        def f(X, tws, twa, drift):
+            # initialize parameters
+            V, drift = X
+            aws, awa = compute_AW(tws, twa, V)
+            
+            # CHECK IF INPUTS ARE INSIDE BOUNDS
+            
+            Fx = self.RS['FxRig'](np.array([[aws, awa]]))[0]
+            Rx = self.RS['FxHull'](np.array([[V, heel, drift]]))[0] + self.RS['FxApp'](np.array([[V, drift]]))[0]
+            
+            HA = self.RS['zCE'](np.array([[V, drift]]))[0] - self.RS['zCLR'](np.array([[V, drift]]))[0]
+            GZ = self.RS['GZ'](np.array([[V, heel, drift]]))[0]
+            
+            Fy = self.RS['FyRig'](np.array([[aws, awa]]))[0]
+            
+            D = self.hull.displacement
+            
+            eq = np.array([Fx - Rx,
+                           Fy*HA - D*g*GZ])
+            
+            return eq
+        
+        X0 = np.ones(2)
+        fArgs = (tws, twa, drift)
+        
+        Xopt = opt.root(f, X0, args=fArgs)
+        
+        return Xopt.x
+    
+    
+    def free_speed_drift(self, tws, twa, heel):
+        
+        def f(X, tws, twa, heel):
+            # initialize parameters
+            V, drift = X
+            aws, awa = compute_AW(tws, twa, V)
+            
+            Fx = self.RS['FxRig'](np.array([[aws, awa]]))[0]
+            Rx = self.RS['FxHull'](np.array([[V, heel, drift]]))[0] + self.RS['FxApp'](np.array([[V, drift]]))[0]
+            
+            Fy = self.RS['FyRig'](np.array([[aws, awa]]))[0]
+            Ry = self.RS['FyApp'](np.array([[V, drift]]))[0]
+            
+            eq = np.array([Fx - Rx,
+                           Fy - Ry])
+            
+            return eq
+        
+        X0 = np.ones(2)
+        fArgs = (tws, twa, heel)
+        
+        Xopt = opt.root(f, X0, args=fArgs)
+        
+        return Xopt.x
+    
+    def free_speed_heel_drift(self, tws, twa):
+        g = self.environment.g
+        
+        def f(X, tws, twa):
+            # initialize parameters
+            V, heel, drift = X
+            aws, awa = compute_AW(tws, twa, V)
+            
+            # print('V', V)
+            # print('heel', heel)
+            # print('drift', drift)
+            # print('tws', tws)
+            # print('twa', twa)
+            # print('awa', awa)
+            # print('aws', aws)
+            
+            # print(aws, awa)
+            
+            Fx = self.RS['FxRig'](np.array([[aws, awa]]))[0]
+            Rx = self.RS['FxHull'](np.array([[V, heel, drift]]))[0] + self.RS['FxApp'](np.array([[V, drift]]))[0]
+            
+            HA = self.RS['zCE'](np.array([[V, drift]]))[0] - self.RS['zCLR'](np.array([[V, drift]]))[0]
+            GZ = self.RS['GZ'](np.array([[V, heel, drift]]))[0]
+            
+            Fy = self.RS['FyRig'](np.array([[aws, awa]]))[0]
+            Ry = self.RS['FyApp'](np.array([[V, drift]]))[0]
+            
+            D = self.hull.displacement
+            
+            eq = np.array([Fx - Rx,
+                           Fy - Ry,
+                           Fy*HA - D*g*GZ])
+            
+            return eq
+        
+        X0 = np.ones(3)
+        fArgs = (tws, twa)
+        # xBounds = [(1e-3,4), (1e-3,50), (1e-3,10)]
+        
+        Xopt = opt.root(f, X0, args=fArgs)
+        
+        return Xopt.x
+        
+        
+class Sailboat(_Boat):
+    def __init__(self, 
+                 name: str = 'sailboat',
+                 env: OffshoreEnvironment = OffshoreEnvironment()):
+        super().__init__(name, env)
+        self.method = 'dsyhs'
+
+
+class CargoShip(_Boat):
+    def __init__(self, 
+                 name: str = 'cargoship',
+                 env: OffshoreEnvironment = OffshoreEnvironment()):
+        super().__init__(name, env)
+        self.method = 'holtrop'
+        
+        
+# need to differentiate mono and multihulls AND sail and motorboats
+# Is there a general method to treat both ?

archibald_design-1.0.0/archibald/data/airfoils/thick_sections/2032c.dat

@@ -0,0 +1,36 @@
+20-32C AIRFOIL
+1.000000 0.001600
+0.950000 0.012400
+0.900000 0.022900
+0.800000 0.042800
+0.700000 0.061000
+0.600000 0.077100
+0.500000 0.090500
+0.400000 0.100200
+0.300000 0.104800
+0.250000 0.104400
+0.200000 0.101300
+0.150000 0.093400
+0.100000 0.078000
+0.075000 0.066400
+0.050000 0.051300
+0.025000 0.031700
+0.012500 0.019300
+0.000000 0.000000
+0.012500 -0.005000
+0.025000 -0.004200
+0.050000 -0.001000
+0.075000 0.002800
+0.100000 0.006800
+0.150000 0.014500
+0.200000 0.021700
+0.250000 0.028200
+0.300000 0.033300
+0.400000 0.038500
+0.500000 0.038600
+0.600000 0.035000
+0.700000 0.028600
+0.800000 0.020200
+0.900000 0.010000
+0.950000 0.004400
+1.000000 -0.001600

archibald_design-1.0.0/archibald/data/airfoils/thick_sections/a18.dat

@@ -0,0 +1,42 @@
+A18 (original)
+   1.00000   0.00614
+   0.95000   0.01817
+   0.90000   0.02858
+   0.80000   0.04624
+   0.70000   0.06056
+   0.60000   0.07197
+   0.55000   0.07612
+   0.50000   0.07975
+   0.45000   0.08293
+   0.40000   0.08376
+   0.35000   0.08466
+   0.30000   0.08383
+   0.25000   0.08065
+   0.20000   0.07601
+   0.15000   0.07026
+   0.10000   0.06234
+   0.07500   0.05660
+   0.05000   0.04923
+   0.02500   0.03947
+   0.01250   0.03239
+   0.00000   0.01865
+   0.01250   0.00781
+   0.02500   0.00357
+   0.05000   0.00075
+   0.07500   0.00000
+   0.10000   0.00006
+   0.15000   0.00200
+   0.20000   0.00475
+   0.25000   0.00806
+   0.30000   0.01038
+   0.35000   0.01353
+   0.40000   0.01657
+   0.45000   0.01780
+   0.50000   0.01884
+   0.55000   0.01980
+   0.60000   0.01998
+   0.70000   0.01924
+   0.80000   0.01452
+   0.90000   0.00813
+   0.95000   0.00434
+   1.00000   0.00000