NumOpt 0.0.4__tar.gz → 0.0.6__tar.gz

{numopt-0.0.4 → numopt-0.0.6}/NumOpt/__init__.py

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

numopt-0.0.6/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.6/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.6/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)

numopt-0.0.6/NumOpt/casadi_callback/surrogate.py

@@ -0,0 +1,181 @@
+import casadi as ca
+import aerosandbox.numpy as anp
+from typing import Literal
+from smt.surrogate_models.krg import KRG
+
+
+class Surrogate:
+    def __init__(self, sm: KRG):
+        self.sm = sm
+
+    @property
+    def nx(self):
+        return self.sm.nx
+
+    def predict(self, x):
+        return self.sm.predict_values(x)
+
+    def predict_derivate(self, x):
+        gradient = anp.array([self.sm.predict_derivatives(x, kx) for kx in range(self.nx)])
+        return gradient
+
+    def predict_variances(self, x):
+        return self.sm.predict_variances(x)
+
+    def predict_variance_derivatives(self, x):
+        gradient = anp.array([self.sm.predict_variance_derivatives(x, kx) for kx in range(self.nx)])
+        return gradient
+
+
+class Surrogate2Callback(ca.Callback):
+    def __init__(self, name, surrogate: Surrogate,nsamples=1, output_kind: Literal["predict", "predict_variances"] = "predict", opts={}):
+        ca.Callback.__init__(self)
+        self.surrogate = surrogate
+        self.nsamples=nsamples
+        if output_kind == "predict":
+            self.output = self.surrogate.predict
+            self.output_der = self.surrogate.predict_derivate
+        else:
+            self.output = self.surrogate.predict_variances
+            self.output_der = self.surrogate.predict_variance_derivatives
+        self.construct(name, opts)
+        self.jac_callback = self._jac(name)
+
+    def get_n_in(self):
+        return 1
+
+    def get_sparsity_in(self, i):
+        # return ca.Sparsity.dense(self.surrogate.nx, 1)
+        return ca.Sparsity.dense(self.nsamples,self.surrogate.nx)
+
+    def get_n_out(self):
+        return 1
+
+    def get_sparsity_out(self, i):
+        # return ca.Sparsity.dense(1, 1)
+        return ca.Sparsity.dense(self.nsamples, 1)
+
+    def eval(self, args):
+        x = args[0]
+        x = x.toarray()
+        y = self.output(x)
+        return [y]
+
+    def has_jacobian(self):
+        return True
+    
+    def _jac(self,name):
+        class JacFun(ca.Callback):
+            def __init__(self_jac, opts={"enable_fd": False}):
+                ca.Callback.__init__(self_jac)
+                self_jac.construct(f"jac_{name}", opts)
+
+            def get_n_in(self_jac):
+                return 2
+
+            def get_n_out(self_jac):
+                return 1
+
+            def get_sparsity_in(self_jac, i):
+                if i == 0:
+                    return ca.Sparsity.dense(self.surrogate.nx, 1)
+                elif i == 1:
+                    return ca.Sparsity.dense(1, 1)
+
+            def get_sparsity_out(self_jac, i):
+                return ca.Sparsity.dense(1, self.surrogate.nx)
+
+            def eval(self_jac, args):
+                x = args[0]
+                x = x.toarray()
+                y_jac = self.output_der(x)
+                return [y_jac]
+        return JacFun()
+
+    def get_jacobian(self, name, inames, onames, opts):
+        # class JacFun(ca.Callback):
+        #     def __init__(self_jac, opts={"enable_fd": False}):
+        #         ca.Callback.__init__(self_jac)
+        #         self_jac.construct(name, opts)
+
+        #     def get_n_in(self_jac):
+        #         return 2
+
+        #     def get_n_out(self_jac):
+        #         return 1
+
+        #     def get_sparsity_in(self_jac, i):
+        #         if i == 0:
+        #             return ca.Sparsity.dense(self.surrogate.nx, 1)
+        #         elif i == 1:
+        #             return ca.Sparsity.dense(1, 1)
+
+        #     def get_sparsity_out(self_jac, i):
+        #         return ca.Sparsity.dense(1, self.surrogate.nx)
+
+        #     def eval(self_jac, args):
+        #         x = args[0]
+        #         x = x.toarray()
+        #         y_jac = self.output_der(x)
+        #         return [y_jac]
+
+        # self.jac_callback = JacFun()
+        return self.jac_callback
+
+
+if __name__ == "__main__":
+    import plotly.graph_objects as go
+    from plotly.subplots import make_subplots
+    import aerosandbox as asb 
+    import time
+
+    xt = anp.array([0.0, 1.0, 2.0, 3.0, 4.0])
+    yt = anp.array([0.0, 1.0, 1.5, 0.9, 1.0])
+
+    sm = KRG(theta0=[1e-2], print_global=False)
+    sm.set_training_values(xt, yt)
+    sm.train()
+
+    N=10000
+
+    sm = Surrogate(sm)
+    sm_predict = Surrogate2Callback("sm", surrogate=sm,nsamples=1)
+    # dumpy=ca.GenSX_sym("dumpy",1,1)
+    # sm_predict_mpi=ca.Function("mpi",[dumpy],[sm_predict(dumpy)]).map(N,"thread")
+    # print(sm.predict_derivate(0.0))
+
+
+    # X=anp.linspace(0,4,N).reshape((-1,1))
+    # time_s=time.time()
+    # y=sm.predict(X)
+    # print(time.time()-time_s,"s")
+    # # print(y)
+
+    # time_s=time.time()
+    # y=sm_predict_mpi(X.T)
+    # print(time.time()-time_s,"s")
+
+    # time_s=time.time()
+    # y=sm_predict(X)
+    # print(time.time()-time_s,"s")
+
+    opti = asb.Opti()
+    x = opti.variable(init_guess=1.0, lower_bound=0.0, upper_bound=4.0)
+    obj = sm_predict(x)
+    opti.maximize(obj)
+    sol = opti.solve(options={"ipopt.hessian_approximation": "limited-memory"})
+    xopt = sol(x)
+    yopt = sol(obj)
+    print(sol(x), sol(obj))
+
+    # num = 100
+    # x = anp.linspace(0.0, 4.0, num)
+    # y=sm_predict(x).toarray()
+    # print(y)
+
+    # fig=make_subplots(1,1)
+    # fig.add_scatter(x=x,y=y[:,0],mode="lines+markers",row=1,col=1,line={"shape":"spline","width":2})
+    # fig.add_scatter(x=[xopt],y=[yopt],mode="markers",row=1,col=1,marker={"symbol":"star","size":20})
+    # fig.update_layout()
+    # fig.show(config={"scrollZoom":True})
+    # fig.write_html("./fig.html",config={"scrollZoom":True},auto_open=True)