NumOpt 0.0.3__tar.gz → 0.0.5__tar.gz

{numopt-0.0.3 → numopt-0.0.5}/NumOpt/__init__.py

@@ -1,4 +1,4 @@
 from NumOpt.opti import *
 from NumOpt.cprint import *
 
-__version__ = "0.0.3"
+__version__ = "0.0.5"

numopt-0.0.5/NumOpt/airfoil/bezier.py

@@ -0,0 +1,198 @@
+from ..opti import asb, anp, cas, np
+from scipy.special import comb
+from ..cprint import cprint_green
+
+
+class Bezier:
+    def __init__(self, control_points):
+        self.control_points = control_points
+        self.setup()
+
+    def setup(self):
+        self.order = self.control_points.shape[0] - 1
+        self.ndim = self.control_points.shape[1]
+        self._K = comb(self.order, np.arange(self.order + 1))
+        self._C = np.tile(self._K, (self.ndim, 1)).T * self.control_points
+
+    def __call__(self, t):
+        t = anp.reshape(t, (1, -1))
+        ti = []
+        t_ni = []
+        t_ = 1 - t
+        for i in range(self.order + 1):
+            ti.append(t**i)
+            t_ni.append(t_ ** (self.order - i))
+        ti = anp.concatenate(ti, axis=0)
+        t_ni = anp.concatenate(t_ni, axis=0)
+        t_mat = (ti * t_ni).T
+        pts = t_mat @ self._C
+        return pts
+
+
+class BezierAirfoil:
+    def __init__(self, ctu, ctl):
+        self.ctu = ctu
+        self.ctl = ctl
+
+        self.bezier_upper = Bezier(self.ctu)
+        self.bezier_lower = Bezier(self.ctl)
+
+        self.__thickness = self.ctu[-1, 1] - self.ctl[-1, 1]
+        self.__symmetry = False
+
+    def upper_coordinates(self, t):
+        pts = self.bezier_upper(t)[::-1, :]
+        return pts
+
+    def lower_coordinates(self, t):
+        pts = self.bezier_lower(t)
+        return pts
+
+    def coordinates(self, t):
+        pts_u = self.upper_coordinates(t)
+        pts_l = self.lower_coordinates(t)
+
+        pts = anp.concatenate([pts_u[:-1, :], pts_l])
+        return pts
+
+    @property
+    def thickness(self):
+        return self.__thickness
+
+    @property
+    def symmetry(self):
+        return self.__symmetry
+
+    def set_thickness(self, thickness):
+        thickness = thickness
+        old_thickness = self.thickness
+        delta_thickness = thickness - old_thickness
+
+        t = anp.cosspace(0, 1, 100)
+
+        upper_coords = self.upper_coordinates(t)
+        upper_coords[:, 1] += upper_coords[:, 0] * delta_thickness / 2.0
+        lower_coords = self.lower_coordinates(t)
+        lower_coords[:, 1] -= lower_coords[:, 0] * delta_thickness / 2.0
+
+        new_af = self.fit(upper_coords, lower_coords, nctu=self.ctu.shape[0], nctl=self.ctl.shape[0], symmetry=self.symmetry)
+        return new_af
+
+    @staticmethod
+    def fit(upper_coordinates, lower_coordinates, nctu=7, nctl=7, symmetry=False):
+        default_options = {
+            "ipopt.sb": "yes",
+            "ipopt.max_iter": 1000,
+            "ipopt.max_cpu_time": 1e20,
+            "ipopt.mu_strategy": "adaptive",
+            "ipopt.fast_step_computation": "yes",
+            "detect_simple_bounds": False,
+            "expand": True,
+            # =======================
+            # if verbose
+            # "ipopt.print_level": 5,
+            # =======================
+            # =============================
+            # if no verbose
+            "print_time": False,
+            "ipopt.print_level": 0,
+            # =============================.
+            # ============================
+            # This is a heuristic that tends to result in more robust convergence on highly nonconvex problems.
+            # On convex problems and larger problems, the default setting ("adaptive") tends to result in faster convergence.
+            # ===========================
+            # "ipopt.mu_strategy": "monotone",
+            # ===============================
+            # This is another heuristic that tells the optimizer to focus on finding the feasible space initially.
+            # This can be good when you know your initial guess is very far from satisfying all constraints.
+            # "ipopt.start_with_resto": "yes",
+            # ===============================
+        }
+
+        # ------------------------ upper -------------------------------
+        opti = cas.Opti()
+        ctu = opti.variable(nctu, 2)
+        ctl = opti.parameter(nctl, 2)
+
+        af = BezierAirfoil(ctu=ctu, ctl=ctl)
+        # t = anp.cosspace(0, 1, upper_coordinates.shape[0])
+        t = opti.variable(upper_coordinates.shape[0])
+        coords = af.upper_coordinates(t)
+
+        # residual = cas.sum((coords[:, 1] - upper_coordinates[:, 1]) ** 2)
+        dist = coords - upper_coordinates
+        residual = cas.sum(cas.dot(dist, dist))
+
+        opti.subject_to(
+            [
+                # coords[:, 0] == upper_coordinates[:, 0],
+                ctu[0, 0] == 0.0,
+                ctu[0, 1] == 0.0,
+                ctu[1, 0] == 0.0,
+                ctu[-1, 0] == 1.0,
+                ctu[-1, 1] == upper_coordinates[0, 1],
+                opti.bounded(0.0, t, 1.0),
+                opti.bounded(0.0, ctu[:, 0], 1.0),
+                cas.diff(t) >= 0.0,
+                cas.diff(ctu[:, 0]) >= 0.0,
+            ]
+        )
+
+        opti.minimize(residual)
+        opti.solver("ipopt", default_options)
+        opti.set_initial(ctu[:, 0], np.linspace(0, 1, nctu))
+        opti.set_initial(ctu[:, 1], 0.05)
+        opti.set_initial(t, np.linspace(0, 1, upper_coordinates.shape[0]))
+
+        # cprint_green("fit upper...")
+        sol = opti.solve()
+
+        ctu_sol = sol.value(ctu)
+
+        # --------------------------- lower ------------------------------------------
+        if symmetry:
+            ctl_sol = np.array(ctu_sol)
+            ctl_sol[:, 1] = -ctl_sol[:, 1]
+        else:
+            opti = cas.Opti()
+            ctu = opti.parameter(nctu, 2)
+            ctl = opti.variable(nctl, 2)
+
+            af = BezierAirfoil(ctu=ctu, ctl=ctl)
+            # t = anp.cosspace(0, 1, upper_coordinates.shape[0])
+            t = opti.variable(lower_coordinates.shape[0])
+            coords = af.lower_coordinates(t)
+
+            dist = coords - lower_coordinates
+            # residual = cas.sum((coords[:, 1] - lower_coordinates[:, 1]) ** 2)
+            residual = cas.sum(cas.dot(dist, dist))
+
+            opti.subject_to(
+                [
+                    # coords[:, 0] == lower_coordinates[:, 0],
+                    ctl[0, 0] == 0.0,
+                    ctl[0, 1] == 0.0,
+                    ctl[1, 0] == 0.0,
+                    ctl[-1, 0] == 1.0,
+                    ctl[-1, 1] == lower_coordinates[-1, 1],
+                    opti.bounded(0.0, t, 1.0),
+                    opti.bounded(0.0, ctl[:, 0], 1.0),
+                    cas.diff(t) >= 0.0,
+                    cas.diff(ctl[:, 0]) >= 0.0,
+                ]
+            )
+
+            opti.minimize(residual)
+            opti.solver("ipopt", default_options)
+            opti.set_initial(ctl[:, 0], np.linspace(0, 1, nctl))
+            opti.set_initial(ctl[:, 1], -0.1)
+            opti.set_initial(t, np.linspace(0, 1, lower_coordinates.shape[0]))
+
+            # cprint_green("fit lower...")
+            sol = opti.solve()
+
+            ctl_sol = sol.value(ctl)
+
+        af = BezierAirfoil(ctu=ctu_sol, ctl=ctl_sol)
+        af.__symmetry = symmetry
+        return af

numopt-0.0.5/NumOpt/airfoil/bspline.py

@@ -0,0 +1,201 @@
+from ..opti import asb, anp, cas, np
+
+
+class Bspline:
+    def __init__(self, ctrlpts, degree=3):
+        self.ctrlpts = ctrlpts
+        self.n = self.ctrlpts.shape[0] - 1
+        self.degree = degree
+        self.order = self.degree + 1
+        self.segments = self.n - self.degree + 1
+        self.knots = self.quasi_uniform_knots()
+
+    def quasi_uniform_knots(self):
+        middle = np.linspace(0, 1, self.segments + 1)
+        start = np.zeros(self.degree, dtype="f8")
+        end = np.ones(self.degree, dtype="f8")
+        knots = np.hstack([start, middle, end])
+        return knots
+
+    @staticmethod
+    def __deBoor(t, i, k, knots):
+        if k == 1:
+            return cas.if_else(cas.logic_and(t >= knots[i], t < knots[i + 1]), 1.0, 0.0)
+        else:
+            term1 = term2 = 0.0
+            delta_t1 = knots[i + k - 1] - knots[i]
+            delta_t2 = knots[i + k] - knots[i + 1]
+
+            if delta_t1 != 0.0:
+                term1 = (t - knots[i]) / (delta_t1) * Bspline.__deBoor(t, i, k - 1, knots)
+
+            if delta_t2 != 0.0:
+                term2 = (knots[i + k] - t) / (delta_t2) * Bspline.__deBoor(t, i + 1, k - 1, knots)
+
+            return term1 + term2
+
+    def N_coef(self, t, i):
+        return Bspline.__deBoor(t, i, self.order, self.knots)
+
+    def __call__(self, t):
+        def func():
+            tmp = 0.0
+            for j in range(self.n + 1):
+                N_coef = self.N_coef(u, j)
+                tmp = tmp + N_coef * self.ctrlpts[j : j + 1, :]
+            return tmp
+
+        nts = t.shape[0]
+        pts = [0.0] * nts
+
+        for i in range(nts):
+            u = t[i]
+            pts[i] = cas.if_else(u == 1.0, self.ctrlpts[-1:, :], func())
+            # if u == 1.0:
+            #     pts[i] = self.ctrlpts[-1:, :]
+            # else:
+            #     for j in range(self.n + 1):
+            #         N_coef = self.N_coef(u, j)
+            #         pts[i] = pts[i] + N_coef * self.ctrlpts[j : j + 1, :]
+        pts = cas.vcat(pts)
+        return pts
+
+
+class BsplineAirfoil:
+    def __init__(self, ctu=None, ctl=None, degree=3):
+        self.ctu = ctu
+        self.ctl = ctl
+
+        self.bspline_upper = Bspline(ctrlpts=self.ctu, degree=degree)
+        self.bspline_lower = Bspline(ctrlpts=self.ctl, degree=degree)
+
+        self.__te = self.ctu[-1, 1] - self.ctl[-1, 1]
+        self.__symmetry = False
+
+    def upper_coordinates(self, t):
+        pts = self.bspline_upper(t)[::-1, :]
+        return pts
+
+    def lower_coordinates(self, t):
+        pts = self.bspline_lower(t)
+        return pts
+
+    def coordinates(self, t):
+        pts_upper = self.upper_coordinates(t)
+        pts_lower = self.lower_coordinates(t)
+
+        pts = cas.vcat([pts_upper[:-1, :], pts_lower])
+        return pts
+
+    @property
+    def te(self):
+        return self.__te
+
+    @property
+    def symmetry(self):
+        return self.__symmetry
+
+    @staticmethod
+    def fit(upper_coordinates, lower_coordinates, nctu=9, nctl=9, symmetry=False):
+        default_options = {
+            "ipopt.sb": "yes",
+            "ipopt.max_iter": 1000,
+            "ipopt.max_cpu_time": 1e20,
+            "ipopt.mu_strategy": "adaptive",
+            "ipopt.fast_step_computation": "yes",
+            "detect_simple_bounds": False,
+            "expand": True,
+            "print_time": False,
+            "ipopt.print_level": 0,
+        }
+
+        # ============================ upper ==========================
+        opti = cas.Opti()
+
+        ctu = opti.variable(nctu, 2)
+        ctu_init = np.zeros(ctu.shape)
+        ctu_init[1:, 0] = np.linspace(0, 1, nctu - 1)
+        ctu_init[1:-1, 1] = 0.5
+        ctu_init[-1, 1] = upper_coordinates[0, 1]
+
+        ctl = opti.variable(nctl, 2)
+
+        t = opti.variable(upper_coordinates.shape[0])
+        t_init = np.linspace(0, 1, upper_coordinates.shape[0], dtype="f8")
+
+        af = BsplineAirfoil(ctu=ctu, ctl=ctl)
+        coords = af.upper_coordinates(t)
+
+        dist = coords - upper_coordinates
+        residual = cas.sum(cas.dot(dist, dist))
+
+        opti.subject_to(
+            [
+                opti.bounded(0.0, t, 1.0),
+                opti.bounded(0.0, ctu[:, 0], 1.0),
+                cas.diff(t) > 0.0,
+                ctu[:, 0] == ctu_init[:, 0],
+                ctu[0, 1] == ctu_init[0, 1],
+                ctu[-1, 1] == ctu_init[-1, 1],
+                t[0] == 0.0,
+                t[-1] == 1.0,
+            ]
+        )
+
+        opti.minimize(residual)
+        opti.solver("ipopt", default_options)
+        opti.set_initial(ctu, ctu_init)
+        opti.set_initial(t, t_init)
+
+        sol = opti.solve()
+
+        ctu_sol = sol.value(ctu)
+
+        # ============================ lower ==========================
+        if symmetry:
+            ctl_sol = np.array(ctu_sol)
+            ctl_sol[:, 1] = -ctu_sol[:, 1]
+        else:
+            opti = cas.Opti()
+
+            ctu = opti.variable(nctu, 2)
+
+            ctl = opti.variable(nctl, 2)
+            ctl_init = np.zeros(ctl.shape)
+            ctl_init[1:, 0] = np.linspace(0, 1, nctl - 1)
+            ctl_init[1:-1, 1] = -0.5
+            ctl_init[-1, 1] = lower_coordinates[-1, 1]
+
+            t = opti.variable(lower_coordinates.shape[0])
+            t_init = np.linspace(0, 1, lower_coordinates.shape[0], dtype="f8")
+
+            af = BsplineAirfoil(ctu=ctu, ctl=ctl)
+            coords = af.lower_coordinates(t)
+
+            dist = coords - lower_coordinates
+            residual = cas.sum(cas.dot(dist, dist))
+
+            opti.subject_to(
+                [
+                    opti.bounded(0.0, t, 1.0),
+                    opti.bounded(0.0, ctl[:, 0], 1.0),
+                    cas.diff(t) > 0.0,
+                    ctl[:, 0] == ctl_init[:, 0],
+                    ctl[0, 1] == ctl_init[0, 1],
+                    ctl[-1, 1] == ctl_init[-1, 1],
+                    t[0] == 0.0,
+                    t[-1] == 1.0,
+                ]
+            )
+
+            opti.minimize(residual)
+            opti.solver("ipopt", default_options)
+            opti.set_initial(ctl, ctl_init)
+            opti.set_initial(t, t_init)
+
+            sol = opti.solve()
+
+            ctl_sol = sol.value(ctl)
+
+        af_fit = BsplineAirfoil(ctu=ctu_sol, ctl=ctl_sol)
+        return af_fit

numopt-0.0.5/NumOpt/airfoil/export_cst2nx.py

@@ -0,0 +1,92 @@
+import sympy as sp
+from sympy.printing.str import StrPrinter
+import aerosandbox as asb
+from scipy.special import comb 
+import aerosandbox.numpy as anp
+
+
+class CustomerPrinter(StrPrinter):
+    def _print_Pow(self, expr):
+        return f"{expr.base}^{expr.exp}"
+
+
+# def comb(N, i):
+#     return (sp.factorial(N)) / (sp.factorial(i) * sp.factorial(N - i))
+
+
+def C_func(t, N1, N2):
+    return t**N1 * (1 - t) ** N2
+
+
+def S_func(t, A):
+    N = len(A) - 1
+    S = 0.0
+    for i, ai in enumerate(A):
+        b = comb(N, i)
+        si = b * t**i * (1 - t) ** (N - i)
+        S += si * ai
+    return S
+
+
+def write_exp(file, N1, N2, Au, Al, Thickness,Le, yu, yl,prefix):
+    with open(file, "w") as fout:
+        fout.write(f"{prefix}N1={N1}\n")
+        fout.write(f"{prefix}N2={N2}\n")
+        for idx, a in enumerate(Au):
+            fout.write(f"{prefix}Au{idx}={a:.6f}\n")
+        for idx, a in enumerate(Al):
+            fout.write(f"{prefix}Al{idx}={a:.6f}\n")
+        fout.write(f"{prefix}Te={Thickness:.6f}\n")
+        fout.write(f"{prefix}Le={Le:.6f}\n")
+        fout.write(f"t=1.0\n")
+        fout.write(f"{prefix}scaler=1000.0\n")
+        fout.write(f"[MilliMeter]{prefix}x={prefix}scaler*t\n")
+        fout.write(f"[MilliMeter]{prefix}yu={prefix}scaler*({yu})\n")
+        fout.write(f"[MilliMeter]{prefix}yl={prefix}scaler*({yl})\n")
+
+
+def cst2nx():
+    order = 8
+    prefix="af0_"
+    Au = sp.symbols(f"{prefix}Au:{order}")
+    Al = sp.symbols(f"{prefix}Al:{order}")
+    N1 = sp.symbols(f"{prefix}N1")
+    N2 = sp.symbols(f"{prefix}N2")
+    Te = sp.symbols(f"{prefix}Te")
+    Le = sp.symbols(f"{prefix}Le")
+    # expr=x**2
+
+    t = sp.symbols("t")
+
+    C = C_func(t,N1,N2)
+
+    Su = S_func(t, Au)+Le*t**0.5*(1-t)**(order-0.5)
+    yu = C * Su + t * Te / 2.0
+
+    Sl = S_func(t, Al)+Le*t**0.5*(1-t)**(order-0.5)
+    yl = C * Sl - t * Te / 2.0
+
+    # print(yu.subs(t,1))
+
+    # print(yu)
+    yu_expr = str(yu).replace("**","^")
+    yl_expr = str(yl).replace("**","^")
+
+    print(yu_expr)
+    print(yl_expr)
+
+    af = asb.Airfoil("n63415").normalize().set_TE_thickness(0.0).to_kulfan_airfoil(n_weights_per_side=order)
+    # af.leading_edge_weight=1.0
+    # print(af.lower_coordinates(anp.cosspace(0,1,100)))
+    write_exp(
+        "C:/Users/Zcaic/Desktop/cst.exp",
+        N1=af.N1,
+        N2=af.N2,
+        Au=af.upper_weights,
+        Al=af.lower_weights,
+        Thickness=af.TE_thickness,
+        Le=af.leading_edge_weight,
+        yu=yu_expr,
+        yl=yl_expr,
+        prefix=prefix
+    )

numopt-0.0.5/NumOpt/airfoil/kulfan.py

@@ -0,0 +1,163 @@
+import aerosandbox as asb
+import aerosandbox.numpy as anp
+from ..opti import cas
+import numpy as np
+from scipy.special import comb
+
+
+class KulfanAirfoil:
+    def __init__(self, Au, Al, N1=0.5, N2=1.0, Le=0.0, Te=0.0):
+        self.Au = Au
+        self.Al = Al
+        self.N1 = N1
+        self.N2 = N2
+        self.Le = Le
+        self.Te = Te
+
+    def upper_coordinates(self, x):
+        C = KulfanAirfoil.class_function(x, self.N1, self.N2)
+        S = KulfanAirfoil.shape_function(x, self.Au)
+        y = C * (S + self.Le * x**0.5 * (1 - x) ** (self.Au.shape[0] - 1.5)) + x * self.Te / 2.0
+
+        coords = cas.hcat([x, y])
+        return coords[::-1, :]
+
+    def lower_coordinates(self, x):
+        C = KulfanAirfoil.class_function(x, self.N1, self.N2)
+        S = KulfanAirfoil.shape_function(x, self.Al)
+        y = C * (S + self.Le * x**0.5 * (1 - x) ** (self.Al.shape[0] - 1.5)) - x * self.Te / 2.0
+
+        coords = cas.hcat([x, y])
+        return coords
+
+    def coordinates(self, x):
+        coordinates_upper = self.upper_coordinates(x)
+        coordinates_lower = self.lower_coordinates(x)
+
+        coordinates = cas.vcat([coordinates_upper[:-1, :], coordinates_lower])
+        return coordinates
+
+    @staticmethod
+    def class_function(x, N1, N2):
+        C = (x) ** N1 * (1 - x) ** N2
+        return C
+
+    @staticmethod
+    def shape_function(x, w):
+        N = w.shape[0] - 1  # Order of Bernstein polynomials
+
+        K = comb(N, np.arange(N + 1))  # Bernstein polynomial coefficients
+
+        B = []
+        for i in range(w.shape[0]):
+            tmp = K[i] * (x) ** i * (1 - x) ** (N - i)
+            B.append(tmp)
+        B = cas.hcat(B)
+        S = cas.mtimes(B, w)
+
+        return S
+
+    @staticmethod
+    def fit(upper_coordinates, lower_coordinates, nAu=8, nAl=8, N1=0.5, N2=1.0, symmetry=False):
+        if not symmetry:
+            opti = cas.Opti()
+            Al = opti.variable(nAl)
+            Au = opti.variable(nAu)
+            leading_edge_weight = opti.variable(1)
+            # N1 = opti.variable(1)
+            # N2 = opti.variable(1)
+            N1 = N1
+            N2 = N2
+            te = upper_coordinates[-1, 1] - lower_coordinates[-1, 1]
+
+            xu = upper_coordinates[::-1, 0]
+            yu = upper_coordinates[:, 1]
+            xl = lower_coordinates[:, 0]
+            yl = lower_coordinates[:, 1]
+
+            af = KulfanAirfoil(Au=Au, Al=Al, N1=N1, N2=N2, Le=leading_edge_weight, Te=te)
+            yu_ = af.upper_coordinates(xu)
+            yl_ = af.lower_coordinates(xl)
+
+            residual = cas.sum((yu_ - yu) ** 2) + cas.sum((yl_ - yl) ** 2)
+
+            default_options = {
+                "ipopt.sb": "yes",
+                "ipopt.max_iter": 1000,
+                "ipopt.max_cpu_time": 1e20,
+                "ipopt.mu_strategy": "adaptive",
+                "ipopt.fast_step_computation": "yes",
+                "detect_simple_bounds": False,
+                "expand": True,
+                "print_time": False,
+                "ipopt.print_level": 0,
+            }
+
+            opti.minimize(residual)
+            opti.subject_to(
+                [
+                    opti.bounded(-1.0, leading_edge_weight, 1.0),
+                ]
+            )
+
+            opti.solver("ipopt", default_options)
+            opti.set_initial(Au, 0.05)
+            opti.set_initial(Al, -0.05)
+            opti.set_initial(leading_edge_weight, 0.0)
+            # opti.set_value(N1,0.5)
+            # opti.set_value(N2,1.0)
+            # opti.set_initial(N1, 0.5)
+            # opti.set_initial(N2, 1.0)
+            sol = opti.solve()
+
+            Au_sol = sol.value(Au)
+            Al_sol = sol.value(Al)
+            le_sol = sol.value(leading_edge_weight)
+
+        else:
+            opti = cas.Opti()
+            Al = opti.variable(nAl)
+            Au = opti.variable(nAu)
+            leading_edge_weight = 0.0
+            # N1 = opti.variable(1)
+            # N2 = opti.variable(1)
+            N1 = N1
+            N2 = N2
+            te = upper_coordinates[-1, 1] - lower_coordinates[-1, 1]
+
+            xu = upper_coordinates[::-1, 0]
+            yu = upper_coordinates[:, 1]
+            xl = lower_coordinates[:, 0]
+            yl = lower_coordinates[:, 1]
+
+            af = KulfanAirfoil(Au=Au, Al=Al, N1=N1, N2=N2, Le=leading_edge_weight, Te=te)
+            yu_ = af.upper_coordinates(xu)
+            yl_ = af.lower_coordinates(xl)
+
+            residual = cas.sum((yu_ - yu) ** 2)
+
+            default_options = {
+                "ipopt.sb": "yes",
+                "ipopt.max_iter": 1000,
+                "ipopt.max_cpu_time": 1e20,
+                "ipopt.mu_strategy": "adaptive",
+                "ipopt.fast_step_computation": "yes",
+                "detect_simple_bounds": False,
+                "expand": True,
+                "print_time": False,
+                "ipopt.print_level": 0,
+            }
+
+            opti.minimize(residual)
+
+            opti.solver("ipopt", default_options)
+            opti.set_initial(Au, 0.05)
+            opti.set_initial(Al, -0.05)
+
+            sol = opti.solve()
+
+            Au_sol = sol.value(Au)
+            Al_sol = -Au_sol
+            le_sol = leading_edge_weight
+
+        return KulfanAirfoil(Au=Au_sol, Al=Al_sol, N1=N1, N2=N2, Le=le_sol, Te=te)