From d6db67860edfb45e54414511c1bf48de0dd17f7a Mon Sep 17 00:00:00 2001 From: Rafael Date: Thu, 30 May 2024 12:03:04 -0300 Subject: [PATCH 1/7] enh: created optimize utils and code improvements --- composipy/optimize/_maximize_buckling.py | 60 ++++---------------- composipy/optimize/_minimize_panel_weight.py | 56 +++--------------- composipy/optimize/utils.py | 47 +++++++++++++++ 3 files changed, 67 insertions(+), 96 deletions(-) create mode 100644 composipy/optimize/utils.py diff --git a/composipy/optimize/_maximize_buckling.py b/composipy/optimize/_maximize_buckling.py index 38c6e72..b47e074 100644 --- a/composipy/optimize/_maximize_buckling.py +++ b/composipy/optimize/_maximize_buckling.py @@ -2,53 +2,13 @@ import numpy as np import matplotlib.pyplot as plt - -from composipy import OrthotropicMaterial, LaminateProperty, PlateStructure from scipy.optimize import NonlinearConstraint, Bounds, minimize, LinearConstraint from scipy.sparse.linalg import ArpackError +from .utils import Ncr_from_lp, normalize_critical_load, penalty_g1, penalty_g2 -__all__ = ['maximize_buckling_load'] - - -def _Ncr(a, b, T, m, n, xi1, xi3, E1, E2, v12, G12, Nxx, Nyy, Nxy, constraints): - ''' - Calculates critical buckling load based in lamination parameters - ''' - - stacking = { - 'xiD': [xi1, 0.0, xi3, 0.0], - 'T': T} - - mat1 = OrthotropicMaterial(E1, E2, v12, G12, thickness=0.1) - laminate1 = LaminateProperty(stacking, mat1) - plate1 = PlateStructure(dproperty=laminate1, a=a, b=b, constraints=constraints, Nxx=Nxx, Nyy=Nyy, Nxy=Nxy, m=m, n=n) - - return plate1.buckling_analysis()[0][0] - -def _penalty_g1(y0): - xi1, xi3 = y0 - g1 = xi3 + 2*xi1 + 1 - return g1 - - -def _penalty_g2(y0): - xi1, xi3 = y0 - g2 = xi3 - 2*xi1 + 1 - return g2 - - -def _define_critical_load(Nxx, Nyy, Nxy): - max_abs_load = [abs(Nxx), abs(Nyy), abs(Nxy)] - max_abs_load.sort() - max_abs_load = max_abs_load[-1] - - Nxx_norm = Nxx / max_abs_load - Nyy_norm = Nyy / max_abs_load - Nxy_norm = Nxy / max_abs_load - - return Nxx_norm, Nyy_norm, Nxy_norm, max_abs_load +__all__ = ['maximize_buckling_load'] def maximize_buckling_load(a, b, T, @@ -59,7 +19,8 @@ def maximize_buckling_load(a, b, T, options=None, tol=None, plot=False, - points_to_plot=30 + points_to_plot=30, + penalty=True ): ''' Parameters @@ -109,20 +70,21 @@ def maximize_buckling_load(a, b, T, warnings.warn(f'Loads will be normalized, prefer to use loads between -1 and 1 (Nxx = {Nxx}, Nyy = {Nyy}, Nxy = {Nxy})') # Normalizing loads - Nxx_norm, Nyy_norm, Nxy_norm, max_load = _define_critical_load(Nxx, Nyy, Nxy) + Nxx_norm, Nyy_norm, Nxy_norm, max_load = normalize_critical_load(Nxx, Nyy, Nxy) # Critical load error handling def critical_load(y0): xi1, xi3 = y0 try: - eig = _Ncr(a, b, T, m, n, xi1, xi3, E1, E2, v12, G12, Nxx_norm, Nyy_norm, Nxy_norm, constraints=panel_constraint) + eig = Ncr_from_lp(a, b, T, m, n, xi1, xi3, E1, E2, v12, G12, Nxx_norm, Nyy_norm, Nxy_norm, constraints=panel_constraint) except ArpackError: #cause if xi1 and xi3 chosen by optimizer is out of the bounds, it may crash eig = -1 return (-1) * eig #negative so the solver can maximize instead of minimize - # Constraints and boundaries - c2 = NonlinearConstraint(_penalty_g1, -0.0001, 10000) - c3 = NonlinearConstraint(_penalty_g2, -0.0001, 10000) + # Constraints and boundaries + if penalty: + c2 = NonlinearConstraint(penalty_g1, -0.0001, 10000) + c3 = NonlinearConstraint(penalty_g2, -0.0001, 10000) b1 = ([-1.0, 1.0], [-1.0, 1.0]) x0 = [0.0, 0.0] @@ -158,7 +120,7 @@ def constraint(xi1, xi3, silent=True): for xi3_ in x: g_curr = constraint(xi1_, xi3_, silent=True) if g_curr: - critc_N = _Ncr(a, b, T, m, n, xi1_, xi3_, E1, E2, v12, G12, Nxx, Nyy, Nxy, panel_constraint) + critc_N = Ncr_from_lp(a, b, T, m, n, xi1_, xi3_, E1, E2, v12, G12, Nxx, Nyy, Nxy, panel_constraint) Nx_arr.append(critc_N) xi1_arr.append(xi1_) xi3_arr.append(xi3_) diff --git a/composipy/optimize/_minimize_panel_weight.py b/composipy/optimize/_minimize_panel_weight.py index 83ce785..eb3668c 100644 --- a/composipy/optimize/_minimize_panel_weight.py +++ b/composipy/optimize/_minimize_panel_weight.py @@ -7,55 +7,16 @@ from scipy.optimize import NonlinearConstraint, Bounds, minimize, LinearConstraint from scipy.sparse.linalg import ArpackError +from .utils import Ncr_from_lp, normalize_critical_load, penalty_g1, penalty_g2 __all__ = ['minimize_panel_weight'] -def _obj(y0): - T, xi1, xi3 = y0 +def _objective_function(y0): + T, *_ = y0 #(T, xi1, xi3) return T**3 -def _Ncr(a, b, T, m, n, xi1, xi3, E1, E2, v12, G12, Nxx, Nyy, Nxy, constraints): - ''' - Calculates critical buckling load based in lamination parameters - ''' - - stacking = { - 'xiD': [xi1, 0.0, xi3, 0.0], - 'T': T} - - mat1 = OrthotropicMaterial(E1, E2, v12, G12, thickness=0.1) - laminate1 = LaminateProperty(stacking, mat1) - plate1 = PlateStructure(dproperty=laminate1, a=a, b=b, constraints=constraints, Nxx=Nxx, Nyy=Nyy, Nxy=Nxy, m=m, n=n) - - return plate1.buckling_analysis()[0][0] - - -def _penalty_g1(y0): - T, xi1, xi3 = y0 - g1 = xi3 + 2*xi1 + 1 - return g1 - - -def _penalty_g2(y0): - T, xi1, xi3 = y0 - g2 = xi3 - 2*xi1 + 1 - return g2 - - -def _define_critical_load(Nxx, Nyy, Nxy): - max_abs_load = [abs(Nxx), abs(Nyy), abs(Nxy)] - max_abs_load.sort() - max_abs_load = max_abs_load[-1] - - Nxx_norm = Nxx / max_abs_load - Nyy_norm = Nyy / max_abs_load - Nxy_norm = Nxy / max_abs_load - - return Nxx_norm, Nyy_norm, Nxy_norm, max_abs_load - - def minimize_panel_weight(a, b, E1, E2, v12, G12, Nxx=0, Nyy=0, Nxy=0, @@ -113,24 +74,25 @@ def minimize_panel_weight(a, b, warnings.warn(f'Buckling analysis is supposed to take at least a negative normal load or shear. (Nxx = {Nxx}, Nyy = {Nyy}, Nxy = {Nxy})') # Normalizing loads - Nxx_norm, Nyy_norm, Nxy_norm, max_load = _define_critical_load(Nxx, Nyy, Nxy) + Nxx_norm, Nyy_norm, Nxy_norm, max_load = normalize_critical_load(Nxx, Nyy, Nxy) # Critical load error handling def critical_load(y0): T, xi1, xi3 = y0 try: - eig = _Ncr(a, b, T, m, n, xi1, xi3, E1, E2, v12, G12, Nxx_norm, Nyy_norm, Nxy_norm, constraints=panel_constraint) + eig = Ncr_from_lp(a, b, T, m, n, xi1, xi3, E1, E2, v12, G12, Nxx_norm, Nyy_norm, Nxy_norm, constraints=panel_constraint) except ArpackError: #cause if xi1 and xi3 chosen by optimizer is out of the bounds, it may crash eig = -1 return eig # Constraints and boundaries c1 = NonlinearConstraint(critical_load, max_load, np.inf) - c2 = NonlinearConstraint(_penalty_g1, -0.0001, 10000) - c3 = NonlinearConstraint(_penalty_g2, -0.0001, 10000) + c2 = NonlinearConstraint(penalty_g1, -0.0001, 10000) + c3 = NonlinearConstraint(penalty_g2, -0.0001, 10000) b1 = ([0.001, 1000000], [-1.0, 1.0], [-1.0, 1.0]) - res = minimize(_obj, x0, method='SLSQP', constraints=[c1, c2, c3], bounds=b1, options=options, tol=tol) + res = minimize(_objective_function, x0, method='SLSQP', + constraints=[c1, c2, c3], bounds=b1, options=options, tol=tol) if plot: print('generating plot...') diff --git a/composipy/optimize/utils.py b/composipy/optimize/utils.py new file mode 100644 index 0000000..9f097a8 --- /dev/null +++ b/composipy/optimize/utils.py @@ -0,0 +1,47 @@ +'''Utilities functions to be used in optimization''' + +from composipy import OrthotropicMaterial, LaminateProperty, PlateStructure + + + +def Ncr_from_lp(a, b, T, m, n, xi1, xi3, E1, E2, v12, G12, Nxx, Nyy, Nxy, constraints): + ''' + Calculates critical buckling load based in lamination parameters, geometry and constraints + ''' + + stacking = { + 'xiD': [xi1, 0.0, xi3, 0.0], + 'T': T} + + mat1 = OrthotropicMaterial(E1, E2, v12, G12, thickness=0.1) + laminate1 = LaminateProperty(stacking, mat1) + plate1 = PlateStructure(dproperty=laminate1, a=a, b=b, constraints=constraints, Nxx=Nxx, Nyy=Nyy, Nxy=Nxy, m=m, n=n) + + return plate1.buckling_analysis()[0][0] + + +def normalize_critical_load(Nxx, Nyy, Nxy): + '''Normalizes the critical load to be used in optimization functions''' + max_abs_load = [abs(Nxx), abs(Nyy), abs(Nxy)] + max_abs_load.sort() + max_abs_load = max_abs_load[-1] + + Nxx_norm = Nxx / max_abs_load + Nyy_norm = Nyy / max_abs_load + Nxy_norm = Nxy / max_abs_load + + return Nxx_norm, Nyy_norm, Nxy_norm, max_abs_load + + +def penalty_g1(y0): + '''Defines the boundary conditions g1 that delimits the triangle.''' + xi1, xi3 = y0 + g1 = xi3 + 2*xi1 + 1 + return g1 + + +def penalty_g2(y0): + '''Defines the boundary conditions g2 that delimits the triangle.''' + xi1, xi3 = y0 + g2 = xi3 - 2*xi1 + 1 + return g2 From adeb2dba0a48023baccdeaa7fe5647d41a728f6c Mon Sep 17 00:00:00 2001 From: Rafael Date: Thu, 30 May 2024 12:40:36 -0300 Subject: [PATCH 2/7] enh: code enhancements --- composipy/optimize/_maximize_buckling.py | 11 ++------ composipy/optimize/_minimize_panel_weight.py | 7 ++--- composipy/optimize/utils.py | 28 +++++++++++++++++--- 3 files changed, 29 insertions(+), 17 deletions(-) diff --git a/composipy/optimize/_maximize_buckling.py b/composipy/optimize/_maximize_buckling.py index b47e074..4fd05d6 100644 --- a/composipy/optimize/_maximize_buckling.py +++ b/composipy/optimize/_maximize_buckling.py @@ -1,11 +1,10 @@ -import warnings import numpy as np import matplotlib.pyplot as plt from scipy.optimize import NonlinearConstraint, Bounds, minimize, LinearConstraint from scipy.sparse.linalg import ArpackError -from .utils import Ncr_from_lp, normalize_critical_load, penalty_g1, penalty_g2 +from .utils import Ncr_from_lp, normalize_critical_load, penalty_g1, penalty_g2, check_loads __all__ = ['maximize_buckling_load'] @@ -61,13 +60,7 @@ def maximize_buckling_load(a, b, T, res : scipy minimize result ''' - # Positive loads warning - if Nxx >= 0 and Nyy >= 0 and Nxy == 0: - warnings.warn(f'Buckling analysis is supposed to take at least a negative normal load or shear. (Nxx = {Nxx}, Nyy = {Nyy}, Nxy = {Nxy})') - - #Non normalized loads warning - if abs(Nxx) > 1 or abs(Nyy) > 1 or abs(Nxy) > 1: - warnings.warn(f'Loads will be normalized, prefer to use loads between -1 and 1 (Nxx = {Nxx}, Nyy = {Nyy}, Nxy = {Nxy})') + check_loads(Nxx, Nyy, Nxy) # Normalizing loads Nxx_norm, Nyy_norm, Nxy_norm, max_load = normalize_critical_load(Nxx, Nyy, Nxy) diff --git a/composipy/optimize/_minimize_panel_weight.py b/composipy/optimize/_minimize_panel_weight.py index eb3668c..3e17ac3 100644 --- a/composipy/optimize/_minimize_panel_weight.py +++ b/composipy/optimize/_minimize_panel_weight.py @@ -1,4 +1,3 @@ -import warnings import numpy as np import matplotlib.pyplot as plt @@ -7,7 +6,7 @@ from scipy.optimize import NonlinearConstraint, Bounds, minimize, LinearConstraint from scipy.sparse.linalg import ArpackError -from .utils import Ncr_from_lp, normalize_critical_load, penalty_g1, penalty_g2 +from .utils import Ncr_from_lp, normalize_critical_load, penalty_g1, penalty_g2, check_loads __all__ = ['minimize_panel_weight'] @@ -69,9 +68,7 @@ def minimize_panel_weight(a, b, res : scipy minimize result ''' - # Positive loads warning - if Nxx >= 0 and Nyy >= 0 and Nxy == 0: - warnings.warn(f'Buckling analysis is supposed to take at least a negative normal load or shear. (Nxx = {Nxx}, Nyy = {Nyy}, Nxy = {Nxy})') + check_loads(Nxx, Nyy, Nxy) # Normalizing loads Nxx_norm, Nyy_norm, Nxy_norm, max_load = normalize_critical_load(Nxx, Nyy, Nxy) diff --git a/composipy/optimize/utils.py b/composipy/optimize/utils.py index 9f097a8..b682c85 100644 --- a/composipy/optimize/utils.py +++ b/composipy/optimize/utils.py @@ -1,7 +1,8 @@ '''Utilities functions to be used in optimization''' -from composipy import OrthotropicMaterial, LaminateProperty, PlateStructure +import warnings +from composipy import OrthotropicMaterial, LaminateProperty, PlateStructure def Ncr_from_lp(a, b, T, m, n, xi1, xi3, E1, E2, v12, G12, Nxx, Nyy, Nxy, constraints): @@ -35,13 +36,34 @@ def normalize_critical_load(Nxx, Nyy, Nxy): def penalty_g1(y0): '''Defines the boundary conditions g1 that delimits the triangle.''' - xi1, xi3 = y0 + + if len(y0) == 2: #unpacking for maximize_buckling + xi1, xi3 = y0 + elif len(y0) == 3: #unpacking for minimize_panel_weight + T, xi1, xi3 = y0 + g1 = xi3 + 2*xi1 + 1 return g1 def penalty_g2(y0): '''Defines the boundary conditions g2 that delimits the triangle.''' - xi1, xi3 = y0 + if len(y0) == 2: #unpacking for maximize_buckling + xi1, xi3 = y0 + elif len(y0) == 3: #unpacking for minimize_panel_weight + T, xi1, xi3 = y0 + g2 = xi3 - 2*xi1 + 1 return g2 + + +def check_loads(Nxx, Nyy, Nxy): + '''Given the load inputs, check if the function may present a problem''' + + # Positive loads warning + if Nxx >= 0 and Nyy >= 0 and Nxy == 0: + warnings.warn(f'Buckling analysis is supposed to take at least a negative normal load or shear. (Nxx = {Nxx}, Nyy = {Nyy}, Nxy = {Nxy})') + + #Non normalized loads warning + if abs(Nxx) > 1 or abs(Nyy) > 1 or abs(Nxy) > 1: + warnings.warn(f'Loads will be normalized, prefer to use loads between -1 and 1 (Nxx = {Nxx}, Nyy = {Nyy}, Nxy = {Nxy})') From 9612f563ef23bb0a46cbf562ba829ed3e32bcaaf Mon Sep 17 00:00:00 2001 From: Rafael Date: Thu, 30 May 2024 12:42:01 -0300 Subject: [PATCH 3/7] enh: plot function removed from minimize weight --- composipy/optimize/_minimize_panel_weight.py | 80 -------------------- 1 file changed, 80 deletions(-) diff --git a/composipy/optimize/_minimize_panel_weight.py b/composipy/optimize/_minimize_panel_weight.py index 3e17ac3..8dd8b3b 100644 --- a/composipy/optimize/_minimize_panel_weight.py +++ b/composipy/optimize/_minimize_panel_weight.py @@ -24,8 +24,6 @@ def minimize_panel_weight(a, b, panel_constraint='PINNED', options=None, tol=None, - plot=False, - points_to_plot=30 ): ''' Parameters @@ -91,82 +89,4 @@ def critical_load(y0): res = minimize(_objective_function, x0, method='SLSQP', constraints=[c1, c2, c3], bounds=b1, options=options, tol=tol) - if plot: - print('generating plot...') - x = np.linspace(-1., 1., points_to_plot) - init_args = [0, 0, -1] - Nx_arr = [] - xi1_arr, xi3_arr = [], [] - - def constraint(xi1, xi3, silent=True): - #g = xi3 - 2*xi1**2 + 1 - g1 = xi3 + 2*xi1 + 1 - g2 = xi3 - 2*xi1 + 1 - - if xi1 < 0: - g = g1 - else: - g = g2 - - if g < 0: - if not silent: - print(xi1, xi3) - return False - else: - return True - - - for xi1_ in x: - for xi3_ in x: - g_curr = constraint(xi1_, xi3_, silent=True) - if g_curr: - critc_N = critical_load([res['x'][0], xi1_, xi3_]) - Nx_arr.append(critc_N) - xi1_arr.append(xi1_) - xi3_arr.append(xi3_) - - if critc_N > init_args[2]: - init_args = [xi1_, xi3_, critc_N] - else: - pass - Nx_arr.append(np.nan) - xi1_arr.append(xi1_) - xi3_arr.append(xi3_) - - g1_xi1 = np.linspace(-1, 0, points_to_plot) - g1_xi3 = -2*g1_xi1 - 1 - - g2_xi1 = np.linspace(0, 1, points_to_plot) - g2_xi3 = 2*g2_xi1 - 1 - - n_valid_points = int(np.sqrt(len(Nx_arr))) - Nx_arr = np.array(Nx_arr) - xi1_arr = np.array(xi1_arr) - xi3_arr = np.array(xi3_arr) - Nx_arr = Nx_arr.reshape(n_valid_points, n_valid_points) - xi1_arr = xi1_arr.reshape(n_valid_points, n_valid_points) - xi3_arr = xi3_arr.reshape(n_valid_points, n_valid_points) - - #plots - plt.figure() - - # Nxcrit - cs1 = plt.contour(xi1_arr, xi3_arr, Nx_arr, 20) - plt.clabel(cs1) - - #g1 and g2 - plt.plot(g1_xi1, g1_xi3, 'k') - plt.plot(g2_xi1, g2_xi3, 'k') - - # - plt.plot(res['x'][1], res['x'][2], 'ro', label='optimum') - - - plt.xlabel('xi1') - plt.ylabel('xi3') - plt.xlim([-1, 1]) - plt.ylim([-1, 1]) - plt.legend() - plt.show() - return res From 924ec5c74f3cbdc98b15cb21135d1fe0e3e1eefa Mon Sep 17 00:00:00 2001 From: Rafael Date: Thu, 30 May 2024 13:13:41 -0300 Subject: [PATCH 4/7] enh: plot and penalty adjusted --- composipy/optimize/_maximize_buckling.py | 96 +++---------------- composipy/optimize/_minimize_panel_weight.py | 3 +- composipy/optimize/utils.py | 99 ++++++++++++++++++++ 3 files changed, 114 insertions(+), 84 deletions(-) diff --git a/composipy/optimize/_maximize_buckling.py b/composipy/optimize/_maximize_buckling.py index 4fd05d6..c45e516 100644 --- a/composipy/optimize/_maximize_buckling.py +++ b/composipy/optimize/_maximize_buckling.py @@ -4,7 +4,7 @@ from scipy.optimize import NonlinearConstraint, Bounds, minimize, LinearConstraint from scipy.sparse.linalg import ArpackError -from .utils import Ncr_from_lp, normalize_critical_load, penalty_g1, penalty_g2, check_loads +from .utils import Ncr_from_lp, normalize_critical_load, penalty_g1, penalty_g2, check_loads, natural_constraint_g, plot_optimization __all__ = ['maximize_buckling_load'] @@ -54,6 +54,10 @@ def maximize_buckling_load(a, b, T, Plot optimization function points_to_plot : float, default 30 Number of points to plot + penalty : bool, default True + Applies boundary conditions into the feasible region. + If penalty is True, the boundary condition is the triangle the delimits 0, 45, 90° + If penalty is False, the boundary conditions is the parabola that defines the natural constraints. Returns ------- @@ -75,91 +79,19 @@ def critical_load(y0): return (-1) * eig #negative so the solver can maximize instead of minimize # Constraints and boundaries + b1 = ([-1.0, 1.0], [-1.0, 1.0]) + x0 = [0.0, 0.0] if penalty: c2 = NonlinearConstraint(penalty_g1, -0.0001, 10000) c3 = NonlinearConstraint(penalty_g2, -0.0001, 10000) - b1 = ([-1.0, 1.0], [-1.0, 1.0]) - - x0 = [0.0, 0.0] - - res = minimize(critical_load, x0, method='SLSQP', constraints=[c2, c3], bounds=b1, options=options, tol=tol) + res = minimize(critical_load, x0, method='SLSQP', constraints=[c2, c3], bounds=b1, options=options, tol=tol) + elif not penalty: + c = NonlinearConstraint(natural_constraint_g, -0.0001, 10000) + res = minimize(critical_load, x0, method='SLSQP', constraints=[c], bounds=b1, options=options, tol=tol) + if plot: - print('generating plot...') - x = np.linspace(-1., 1., points_to_plot) - init_args = [0, 0, -1] - Nx_arr = [] - xi1_arr, xi3_arr = [], [] - - def constraint(xi1, xi3, silent=True): - #g = xi3 - 2*xi1**2 + 1 - g1 = xi3 + 2*xi1 + 1 - g2 = xi3 - 2*xi1 + 1 - - if xi1 < 0: - g = g1 - else: - g = g2 - - if g < 0: - if not silent: - print(xi1, xi3) - return False - else: - return True - - - for xi1_ in x: - for xi3_ in x: - g_curr = constraint(xi1_, xi3_, silent=True) - if g_curr: - critc_N = Ncr_from_lp(a, b, T, m, n, xi1_, xi3_, E1, E2, v12, G12, Nxx, Nyy, Nxy, panel_constraint) - Nx_arr.append(critc_N) - xi1_arr.append(xi1_) - xi3_arr.append(xi3_) - - if critc_N > init_args[2]: - init_args = [xi1_, xi3_, critc_N] - else: - pass - Nx_arr.append(np.nan) - xi1_arr.append(xi1_) - xi3_arr.append(xi3_) - - g1_xi1 = np.linspace(-1, 0, points_to_plot) - g1_xi3 = -2*g1_xi1 - 1 - - g2_xi1 = np.linspace(0, 1, points_to_plot) - g2_xi3 = 2*g2_xi1 - 1 - - n_valid_points = int(np.sqrt(len(Nx_arr))) - Nx_arr = np.array(Nx_arr) - xi1_arr = np.array(xi1_arr) - xi3_arr = np.array(xi3_arr) - Nx_arr = Nx_arr.reshape(n_valid_points, n_valid_points) - xi1_arr = xi1_arr.reshape(n_valid_points, n_valid_points) - xi3_arr = xi3_arr.reshape(n_valid_points, n_valid_points) - - #plots - plt.figure() - - # Nxcrit - cs1 = plt.contour(xi1_arr, xi3_arr, Nx_arr, 20) - plt.clabel(cs1) - - #g1 and g2 - plt.plot(g1_xi1, g1_xi3, 'k') - plt.plot(g2_xi1, g2_xi3, 'k') - - # - plt.plot(*res['x'], 'ro', label='optimum') - - - plt.xlabel('xi1') - plt.ylabel('xi3') - plt.legend() - plt.xlim([-1, 1]) - plt.ylim([-1, 1]) - plt.show() + plot_optimization(a, b, T, m, n, E1, E2, v12, + G12, Nxx, Nyy, Nxy, panel_constraint, points_to_plot, res, penalty) return res diff --git a/composipy/optimize/_minimize_panel_weight.py b/composipy/optimize/_minimize_panel_weight.py index 8dd8b3b..c85dbe5 100644 --- a/composipy/optimize/_minimize_panel_weight.py +++ b/composipy/optimize/_minimize_panel_weight.py @@ -1,6 +1,4 @@ import numpy as np -import matplotlib.pyplot as plt - from composipy import OrthotropicMaterial, LaminateProperty, PlateStructure from scipy.optimize import NonlinearConstraint, Bounds, minimize, LinearConstraint @@ -8,6 +6,7 @@ from .utils import Ncr_from_lp, normalize_critical_load, penalty_g1, penalty_g2, check_loads + __all__ = ['minimize_panel_weight'] diff --git a/composipy/optimize/utils.py b/composipy/optimize/utils.py index b682c85..83e09d9 100644 --- a/composipy/optimize/utils.py +++ b/composipy/optimize/utils.py @@ -2,6 +2,9 @@ import warnings +import numpy as np +import matplotlib.pyplot as plt + from composipy import OrthotropicMaterial, LaminateProperty, PlateStructure @@ -57,6 +60,18 @@ def penalty_g2(y0): return g2 +def natural_constraint_g(y0): + '''Defines the boundary conditions g1 that delimits the parabola.''' + + if len(y0) == 2: #unpacking for maximize_buckling + xi1, xi3 = y0 + elif len(y0) == 3: #unpacking for minimize_panel_weight + T, xi1, xi3 = y0 + + g = xi3 - 2*xi1**2 + 1 + return g + + def check_loads(Nxx, Nyy, Nxy): '''Given the load inputs, check if the function may present a problem''' @@ -67,3 +82,87 @@ def check_loads(Nxx, Nyy, Nxy): #Non normalized loads warning if abs(Nxx) > 1 or abs(Nyy) > 1 or abs(Nxy) > 1: warnings.warn(f'Loads will be normalized, prefer to use loads between -1 and 1 (Nxx = {Nxx}, Nyy = {Nyy}, Nxy = {Nxy})') + + +def _constraint(xi1, xi3, silent=True, penalty=True): + g_natural = xi3 - 2*xi1**2 + 1 + g1 = xi3 + 2*xi1 + 1 + g2 = xi3 - 2*xi1 + 1 + + if not penalty: + g = g_natural + elif xi1 < 0: + g = g1 + else: + g = g2 + + if g < 0: + if not silent: + print(xi1, xi3) + return False + else: + return True + + + +def plot_optimization(a, b, T, m, n, E1, E2, v12, + G12, Nxx, Nyy, Nxy, panel_constraint, points_to_plot, res, penalty): + + print('generating plot...') + x = np.linspace(-1., 1., points_to_plot) + init_args = [0, 0, -1] + Nx_arr = [] + xi1_arr, xi3_arr = [], [] + + for xi1_ in x: + for xi3_ in x: + g_curr = _constraint(xi1_, xi3_, silent=True, penalty=penalty) + if g_curr: + critc_N = Ncr_from_lp(a, b, T, m, n, xi1_, xi3_, E1, E2, v12, G12, Nxx, Nyy, Nxy, panel_constraint) + Nx_arr.append(critc_N) + xi1_arr.append(xi1_) + xi3_arr.append(xi3_) + + if critc_N > init_args[2]: + init_args = [xi1_, xi3_, critc_N] + else: + pass + Nx_arr.append(np.nan) + xi1_arr.append(xi1_) + xi3_arr.append(xi3_) + + g1_xi1 = np.linspace(-1, 0, points_to_plot) + g1_xi3 = -2*g1_xi1 - 1 + + g2_xi1 = np.linspace(0, 1, points_to_plot) + g2_xi3 = 2*g2_xi1 - 1 + + n_valid_points = int(np.sqrt(len(Nx_arr))) + Nx_arr = np.array(Nx_arr) + xi1_arr = np.array(xi1_arr) + xi3_arr = np.array(xi3_arr) + Nx_arr = Nx_arr.reshape(n_valid_points, n_valid_points) + xi1_arr = xi1_arr.reshape(n_valid_points, n_valid_points) + xi3_arr = xi3_arr.reshape(n_valid_points, n_valid_points) + + #plots + plt.figure() + + # Nxcrit + cs1 = plt.contour(xi1_arr, xi3_arr, Nx_arr, 20) + plt.clabel(cs1) + + #g1 and g2 + plt.plot(g1_xi1, g1_xi3, 'k') + plt.plot(g2_xi1, g2_xi3, 'k') + + # + plt.plot(*res['x'], 'ro', label='optimum') + + + plt.xlabel('xi1') + plt.ylabel('xi3') + plt.legend() + plt.xlim([-1, 1]) + plt.ylim([-1, 1]) + plt.show() \ No newline at end of file From d71c0cf0f4116f6ed56ab70eb48065ade919b6c9 Mon Sep 17 00:00:00 2001 From: Rafael Date: Thu, 30 May 2024 13:21:05 -0300 Subject: [PATCH 5/7] VERSION: version update and plot removed from function --- composipy/version.py | 2 +- tests/optimization_test/test_minimize_panel_weight.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/composipy/version.py b/composipy/version.py index 1be3a87..eae1c3a 100644 --- a/composipy/version.py +++ b/composipy/version.py @@ -1 +1 @@ -__version__ = '1.2.3' \ No newline at end of file +__version__ = '1.3' \ No newline at end of file diff --git a/tests/optimization_test/test_minimize_panel_weight.py b/tests/optimization_test/test_minimize_panel_weight.py index e37f4a9..572cbcb 100644 --- a/tests/optimization_test/test_minimize_panel_weight.py +++ b/tests/optimization_test/test_minimize_panel_weight.py @@ -27,7 +27,7 @@ def panel_definition(): 'm': 7, 'n': 7, 'panel_constraint' : 'PINNED', - 'plot': False + #'plot': False # removed from this function } return panel From bca177878aea7253b8bd67a9ad20aa7804978534 Mon Sep 17 00:00:00 2001 From: Rafael Date: Thu, 30 May 2024 13:34:39 -0300 Subject: [PATCH 6/7] not penalty plot corrected --- composipy/optimize/utils.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/composipy/optimize/utils.py b/composipy/optimize/utils.py index 83e09d9..f5bac9e 100644 --- a/composipy/optimize/utils.py +++ b/composipy/optimize/utils.py @@ -132,10 +132,15 @@ def plot_optimization(a, b, T, m, n, E1, E2, v12, xi3_arr.append(xi3_) g1_xi1 = np.linspace(-1, 0, points_to_plot) - g1_xi3 = -2*g1_xi1 - 1 - g2_xi1 = np.linspace(0, 1, points_to_plot) - g2_xi3 = 2*g2_xi1 - 1 + + if penalty: + g1_xi3 = -2*g1_xi1 - 1 + g2_xi3 = 2*g2_xi1 - 1 + else: + g1_xi3 = -2*g1_xi1**2 - 1 + g2_xi3 = 2*g2_xi1**2 - 1 + n_valid_points = int(np.sqrt(len(Nx_arr))) Nx_arr = np.array(Nx_arr) From e15ab84b68c85e39932dbd774efa2ba771e3a9f1 Mon Sep 17 00:00:00 2001 From: Rafael Date: Thu, 30 May 2024 14:20:26 -0300 Subject: [PATCH 7/7] enh: penalty True implemented --- composipy/optimize/utils.py | 3 +- doc/notebooks/Code_snipets.ipynb | 63 ++++++++++++++++++++++++++++++-- 2 files changed, 61 insertions(+), 5 deletions(-) diff --git a/composipy/optimize/utils.py b/composipy/optimize/utils.py index f5bac9e..854f32a 100644 --- a/composipy/optimize/utils.py +++ b/composipy/optimize/utils.py @@ -138,7 +138,8 @@ def plot_optimization(a, b, T, m, n, E1, E2, v12, g1_xi3 = -2*g1_xi1 - 1 g2_xi3 = 2*g2_xi1 - 1 else: - g1_xi3 = -2*g1_xi1**2 - 1 + print('penalty False') + g1_xi3 = 2*g1_xi1**2 - 1 g2_xi3 = 2*g2_xi1**2 - 1 diff --git a/doc/notebooks/Code_snipets.ipynb b/doc/notebooks/Code_snipets.ipynb index 83bd53f..55aec7b 100644 --- a/doc/notebooks/Code_snipets.ipynb +++ b/doc/notebooks/Code_snipets.ipynb @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -29,7 +29,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -104,9 +104,16 @@ "For practical reasons, only Lamination Parameters $W_1$ and $W_3$ are used as project variables, while $W_2$ and $W_4$ are considered equal zero, therefore a symmetric and balanced laminated is considered. For more details on how to interpret them and convert them into a feasible stacking sequence, check the references [1], [2] and [3].\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Objective function with boundary g1 and g2" + ] + }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -141,7 +148,55 @@ "res = maximize_buckling_load(a=a, b=b, T=total_thickness, E1=E1, E2=E2,\n", " v12=v12, G12=G12, Nxx=Nxx, Nyy=Nyy,\n", " Nxy=Nxy, m=m, n=n, panel_constraint=constraints,\n", - " plot=True) #remove plot=True to gain performance\n", + " plot=True, penalty=True) #remove plot=True to gain performance\n", + "\n", + "print(f'W1={res.x[0]: .3f} and W3={res.x[1]: .3f}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Objective function without boundary g1 and g2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "generating plot...\n", + "penalty False\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "W1= 0.677 and W3=-0.083\n" + ] + } + ], + "source": [ + "total_thickness = 20*0.21 #4.2 mm\n", + "res = maximize_buckling_load(a=a, b=b, T=total_thickness, E1=E1, E2=E2,\n", + " v12=v12, G12=G12, Nxx=Nxx, Nyy=Nyy,\n", + " Nxy=Nxy, m=m, n=n, panel_constraint=constraints,\n", + " plot=True, penalty=False) #remove plot=True to gain performance\n", "\n", "print(f'W1={res.x[0]: .3f} and W3={res.x[1]: .3f}')" ]