NumOpt 0.0.3__tar.gz → 0.0.4__tar.gz

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

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

numopt-0.0.4/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.3 → numopt-0.0.4}/NumOpt/opti.py

@@ -1,5 +1,6 @@
 import aerosandbox.numpy as anp
 import aerosandbox as asb 
+import numpy as np 
 import casadi as cas
 from typing import Callable, Any, Dict
 from .cprint import cprint_yellow

numopt-0.0.4/NumOpt/optimize/hxy_optimization.py

@@ -0,0 +1,39 @@
+import numpy as np
+from scipy.spatial import Delaunay as DelaunayND
+
+from ..cprint import cprint_green,cprint_magenta
+
+class Delaunay1D(object):
+    def __init__(self,points):
+        self.points=np.reshape(points,(-1,1))
+        self.dim=len(self.points)
+    @property
+    def vertex_neighbor_vertices(self):
+        sord_idx=np.argsort(self.points.flatten())
+        idxptr=[0]
+        idx=[]
+        sort_points=np.arange(self.dim)[sord_idx]
+        ranks=np.argsort(sord_idx)
+        for _,vi in enumerate(ranks):
+            len_idx=len(idx)
+            if vi==0:
+                right=vi+1
+                right=sort_points[right]
+                idxptr.append(len_idx+1)
+                idx.append(right)
+            elif vi==self.dim-1:
+                left=vi-1 
+                left=sort_points[left]
+                idxptr.append(len_idx+1)
+                idx.append(left)
+            else:
+                left=vi-1 
+                left=sort_points[left]
+                right=vi+1
+                right=sort_points[right]
+                idxptr.append(len_idx+2)
+                idx.extend([left,right])      
+
+        idxptr=np.array(idxptr)
+        idx=np.array(idx)
+        return idxptr,idx

numopt-0.0.4/NumOpt/preprocess/scaler.py

@@ -0,0 +1,31 @@
+import numpy as np
+from ..cprint import cprint_green, cprint_red
+
+class NormalScaler:
+    def __init__(self):
+        self._mean = None
+        self._std = None
+
+    def fit(self, dataset):
+        if dataset.ndim != 2:
+            cprint_red("The dataset ndim must = 2.\n")
+            exit(-1)
+        self._mean = np.mean(dataset, axis=0)
+        self._std = np.std(dataset, axis=0, ddof=1)
+        return self
+
+    def transform(self, dataset, target_mean, target_std):
+        new_dataset = (dataset - self._mean) / self._std
+        new_dataset = new_dataset * target_std + target_mean
+        return new_dataset
+
+
+if __name__ == "__main__":
+    x = np.random.normal(0.0, 0.1, (1000, 1))
+
+    scaler = NormalScaler().fit(x)
+    print(scaler._mean, scaler._std)
+
+    new_x = scaler.transform(dataset=x, target_mean=2.0, target_std=10)
+    new_scaler=NormalScaler().fit(new_x)
+    print(new_scaler._mean,new_scaler._std)

{numopt-0.0.3 → numopt-0.0.4}/NumOpt.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NumOpt
-Version: 0.0.3
+Version: 0.0.4
 Summary: pti is a Python package that helps you design and optimize engineered systems.
 Home-page: https://github.com/Zcaic/NumOpt.git
 Author: Zcaic

{numopt-0.0.3 → numopt-0.0.4}/NumOpt.egg-info/SOURCES.txt

@@ -12,5 +12,10 @@ NumOpt.egg-info/requires.txt
 NumOpt.egg-info/top_level.txt
 NumOpt/FSI/__init__.py
 NumOpt/FSI/tools.py
+NumOpt/airfoil/bezier.py
 NumOpt/nx/__init__.py
-NumOpt/nx/tools.py
+NumOpt/nx/tools.py
+NumOpt/optimize/__init__.py
+NumOpt/optimize/hxy_optimization.py
+NumOpt/preprocess/scaler.py
+test/test01.py

{numopt-0.0.3 → numopt-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NumOpt
-Version: 0.0.3
+Version: 0.0.4
 Summary: pti is a Python package that helps you design and optimize engineered systems.
 Home-page: https://github.com/Zcaic/NumOpt.git
 Author: Zcaic

numopt-0.0.4/test/test01.py

@@ -0,0 +1,146 @@
+from NumOpt.airfoil.bezier import Bezier, BezierAirfoil
+from NumOpt.opti import cas,Opti
+import numpy as np
+import aerosandbox as asb
+
+
+def test1():
+    opti=Opti()
+    T=opti.variable(init_guess=2.8e3*9.8)
+
+    A=np.pi*3.5**2
+    vi=(T/(2*1.225*A))**0.5
+
+    Pin=743e3
+
+    eta=T*vi/Pin 
+
+    opti.subject_to([
+        eta==0.80
+    ])
+
+    opti.solver()
+    sol=opti.solve()
+    print(sol(T))
+
+def test2():
+    af=asb.Airfoil("naca0012")
+    af_new=BezierAirfoil.fit(upper_coordinates=af.upper_coordinates(),lower_coordinates=af.lower_coordinates(),symmetry=True)
+    af_new=af_new.set_thickness(5e-3)
+    print(af_new.thickness)
+    coords = af_new.coordinates(np.linspace(0, 1, 100))
+
+    import matplotlib.pyplot as plt
+
+    fig = plt.figure()
+    ax = fig.add_subplot()
+    ax.plot(coords[:, 0], coords[:, 1],label="fit")
+    ax.plot(af.coordinates[:,0],af.coordinates[:,1],label="ori")
+    ax.plot(af_new.ctu[:,0],af_new.ctu[:,1],"o--",label="ctu")
+    ax.plot(af_new.ctl[:,0],af_new.ctl[:,1],"o--",label="ctl")
+    ax.legend()
+    plt.show()
+
+
+
+def test3():
+    nx = 5
+
+    # inputs
+    # x = cas.GenMX.sym("x", nx, 1)
+
+    # max_x = anp.max(x)
+
+    # max_x_index = cas.find(max_x == x)
+
+    # ret = anp.concatenate([max_x_index, max_x], axis=1)
+
+    # func = cas.Function("func", [x], [ret])
+
+    # print(func(anp.array([1, 3, 3, 3, 5])))
+
+
+def test4():
+    opti = cas.Opti()
+
+    # 声明变量K并设置为整数类型
+    K = opti.variable()
+    opti.set_domain(K, "integer")
+
+    # 定义数组并转换为MX类型
+    A = [3, 2, 1, 2, 3]
+    A = cas.MX(A)
+
+    # 构建目标函数：最小化A[K]
+    opti.minimize(A[K])
+
+    # 添加约束：确保K在数组有效范围内
+    opti.subject_to(0 <= (K <= 4))
+
+    # 设置求解器并求解
+    opti.solver("bonmin")
+    sol = opti.solve()
+
+    # 输出结果
+    print(sol.value(K))
+
+
+def test5():
+    import sympy as sp
+
+    p = sp.symbols("p", complex=True)
+    v = sp.symbols("v")
+    m = sp.symbols("m")
+    r = sp.symbols("r")
+    b = sp.symbols("b")
+    K_h = sp.symbols("K_h")
+    K_alpha = sp.symbols("K_alpha")
+    S_alpha = sp.symbols("S_alpha")
+    I_alpha = sp.symbols("I_alpha")
+    a = sp.symbols("a")
+    pi = np.pi
+
+    A = sp.Matrix(
+        [
+            [
+                m * p**2 + 2 * pi * r * v * b * p + K_h,
+                S_alpha * p**2 + (1 - 2 * a) * pi * r * v * b**2 * p + 2 * pi * r * v**2 * b,
+            ],
+            [
+                S_alpha * p**2 - (2 * a + 1) * pi * r * v * b**2 * p,
+                I_alpha * p**2 + (2 * a *a) * pi * r * v * b**3 * p + K_alpha - (2 * a + 1) * pi * r * v**2 * b**2,
+            ],
+        ]
+    )
+
+    detA=A.det()
+
+    p_expr=sp.solve(detA,p)
+
+    # p_expr=sp.lambdify([v,m,r,b,K_h,K_alpha,S_alpha,I_alpha,a],p_expr)
+    return p_expr
+
+
+
+def test6():
+    ctu = np.array([[0.0, 0.0], [0.0, 26.8], [122.7, 52.9], [392.0, 110.2], [710.4, 41.6], [850.5, 12.9], [1000.0, 0.0]])
+    ctl = np.array([[0.0, 0.0], [0.0, -26.6], [160.1, -36.0], [421.5, -71.3], [716.2, -20.8], [850.8, 8.5], [1000.0, 0.0]])
+
+    af = BezierAirfoil(ctu=ctu, ctl=ctl)
+    coords = af.coordinates(np.linspace(0, 1, 100))
+
+    import matplotlib.pyplot as plt
+
+    fig = plt.figure()
+    ax = fig.add_subplot()
+    ax.plot(coords[:, 0], coords[:, 1])
+    plt.show()
+
+
+if __name__ == "__main__":
+    # test1()
+    test2()
+    # test3()
+    # test4()
+    # test5()
+    # test6()