{ "cells": [ { "cell_type": "raw", "metadata": {}, "source": [ "Code provided under BSD 3-Clause license, all other content under a Creative Commons Attribution license, CC-BY 4.0. (c) 2023 Francesco Mario Antonio Mitrotta." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# One-variable Optimization of the CRM-like Box Beam\n", "\n", "In our [last notebook](18_Development_and_Nonlinear_Structural_Stability_Analysis_of_a_CRM-like_Box_Beam_Model.ipynb) we developed a straight box beam approximation of the CRM wingbox, which we called CRM-like box beam, and we studied its nonlinear structural response under a concentrated tip load. In this notebook we are going to use the OpenMDAO framework to attempt a proof-of-conpcept optimization of such box beam model including a nonlinear structural stability constraint. In this proof-of-concept optimization we are going to minimize the mass of the structure using a single design variable, that is to say the wall thickness, which will be the same for all structural elements. After recalling the CRM-like box beam geometry from our last notebook, we will define the optimization problem in a way that the initial structure is optimal in linear buckling terms, to allow an easy comparison. Then we'll implement the optimization problem with the OpenMDAO library, set up the numerical model and carry the optimization taking a look at how some nonlinear analysis parameters affect the results.\n", "\n", "* [Definition of the CRM-like box beam model](#model-definition)\n", "* [Formulation of the optimization problem](#optimization-problem)\n", "* [OpenMDAO implementation](#openmdao-implementation)\n", "* [Setup of the numerical model](#numerical-model-setup)\n", "* [Optimization](#optimization)\n", "* [Conclusion](#conclusion)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt # package for making plots\n", "import tol_colors as tc # package for colorblind-friendly colors\n", "import os # package for file and directory manipulation\n", "from matplotlib.lines import Line2D # class defining the characters for the marker styles\n", "\n", "# Set up matplotlib for interactive plotting and set default plot settings\n", "%matplotlib widget\n", "plt.rc('axes', prop_cycle=plt.cycler('color', list(tc.tol_cset('bright')))) # set default color cycle to TOL bright\n", "plt.rcParams[\"figure.dpi\"] = 120 # set default dpi of figures\n", "\n", "# Set the path to the directory containing the analysis files\n", "ANALYSIS_DIRECTORY_PATH = os.path.join(os.getcwd(),\n", " \"analyses\",\n", " \"19_One-variable_Optimization_of_the_CRM-like_Box_Beam\")\n", "\n", "# Define constant variables related to plotting\n", "Z_COMPONENT_INDEX = 2 # index of z-component in load and displacement array\n", "MARKERS = list(Line2D.markers.keys())[2:] # list of marker characters\n", "COLORS = plt.rcParams['axes.prop_cycle'].by_key()['color'] # list with default color cycle\n", "UNSTABLE_COLOR = COLORS[1] # color for unstable segments\n", "GLASS_CEILING_COLOR = COLORS[2] # green is used for glass ceiling\n", "del COLORS[1:3] # delete red from list of colors\n", "\n", "# Set the environment variable for the directory containing the report files\n", "report_directory_path = os.path.relpath(ANALYSIS_DIRECTORY_PATH, os.getcwd())\n", "os.environ['OPENMDAO_REPORTS_DIR'] = report_directory_path" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Definition of the CRM-like box beam model \n", "\n", "***\n", "\n", "We recall the geometrical parameters that we derived in our [last notebook](18_Development_and_Nonlinear_Structural_Stability_Analysis_of_a_CRM-like_Box_Beam_Model.ipynb)." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Number of stiffeners: 2\n", "Number of ribs: 19\n" ] } ], "source": [ "import numpy as np # import numpy library\n", "\n", "L = 29.38e3 # [mm] box beam length\n", "W = 3.41e3 # [mm] box beam width\n", "h = 0.77e3 # [mm] box beam height\n", "t0 = h/100 # [mm] initial box beam thickness\n", "stiffeners_height = h/10 # [mm] stiffeners height\n", "no_stiffeners = 2 # number of stiffeners\n", "stiffeners_x_locations = np.linspace(0, W, no_stiffeners + 2)[1:-1] # [mm] stiffeners x-coordinates\n", "stiffeners_spacing = W/(no_stiffeners + 1) # [mm] stiffeners spacing\n", "ribs_spacing = stiffeners_spacing*1.4 # [mm] ribs spacing\n", "no_ribs = round(L/ribs_spacing) + 1 # number of ribs\n", "ribs_y_locations = np.linspace(0, L, no_ribs) # [mm] ribs y-coordinates\n", "print(f\"\"\"\n", "Number of stiffeners: {no_stiffeners:d}\n", "Number of ribs: {no_ribs:d}\"\"\") # print number of stiffeners and ribs" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We also recall the target element length that we obtained from the [mesh convergence study](18_Development_and_Nonlinear_Structural_Stability_Analysis_of_a_CRM-like_Box_Beam_Model.ipynb#mesh-convergence)." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "element_length = 169.6 # [mm]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Then we recall the material properties. This time we also consider the yield strength to enforce material strength constraint during the optimization. All material properties are taken from the paper by [Brooks et al. (2018)](https://arc.aiaa.org/doi/10.2514/1.J056603)." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "rho = 2780e-12 # density [tons/mm^3]\n", "E = 73.1e3 # Young's modulus [MPa]\n", "nu = 0.3 # Poisson's ratio\n", "SIGMA_Y = 420. # yield strength [MPa]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Formulation of the optimization problem \n", "\n", "***\n", "\n", "In this notebook we want to attempt a proof-of-concept optimization with a nonlinear structural stability constraint. Given the proof-of-concept nature of our attempt, we consider only one design variable, the wall thickness $t$, which we consider to be the same for all the structural elements. We define our optimization objective as the minimization of structural mass, and we bound the wall thickness between a minimum and a maximum value.\n", "\n", "What load magnitude should we apply to our box beam? The idea is that we should be able to compare the structure optimized with the nonlinear structural stability constraint with a baseline design that is optimal in linear buckling terms.\n", "\n", "With the wall thickness being our only design variable, we can immediately notice that there is a bijective relationship between the wall thickness and the linear buckling load of the box beam, which means that for each value of the wall thickness there is a corresponding value of the linear buckling load. If we choose the design load to be equal to the linear buckling load of the initial structure with wall thickness $t_0$, we can state that the initial structure is already optimal in linear buckling terms. In fact, if we were to decrease the wall thickness, the linear buckling load would become lower than the design load, making the structure unfeasible.\n", "\n", "As a consequence, by setting up our optimization problem with only one design variable and by applying a design load equal to the linear buckling load of the initial structure, we can assess the efficacy of our nonlinear structural stability constraint by simply comparing the optimized structure to the initial design.\n", "\n", "Let's recall the linear buckling load of the CRM-like box beam that we found in our [last notebook](18_Development_and_Nonlinear_Structural_Stability_Analysis_of_a_CRM-like_Box_Beam_Model.ipynb#mesh-convergence)." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "DESIGN_LOAD = 12517. # [N]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we need to define the constraints of our optimization. We are going to consider the following constraints:\n", "\n", "- the structure must be stable at every equilibrium point along the equilibrium path;\n", "- all deformations must be elastic, i.e. the material must not yield.\n", "\n", "The first constraint corresponds to our nonlinear structural stability constraint, and we are going to enforce it by constraining the $N_\\lambda$ smallest-magnitude eigenvalues of the tangent stiffness matrix to be positive for every converged increment of the analysis. The second constraint corresponds to a more traditional material strength constraint, and we are going to enforce it by constraining the von Mises stress of all elements to remain below the yield strength.\n", "\n", "Our optimization problem can be stated as it follows:\n", "$$\n", " \\begin{aligned}\n", " \\text{minimize} & & & m\\\\\n", " \\text{by varying} & & & t_\\mathrm{min} \\leq t \\leq t_\\mathrm{max}\\\\\n", " \\text{subject to} & & & g_{\\lambda,\\,ij}=-\\lambda_{ij}<0 & & i=1, \\dots, N_i,\\; j=1, \\dots, N_\\lambda\\\\\n", " & & & g_{\\sigma,\\,k}=\\sigma_k-\\sigma_\\mathrm{max}<0 & & k=1, \\dots, N_e,\n", " \\end{aligned}\n", "$$\n", "\n", "where $t_{min}$ and $t_{max}$ are the thickness bounds, $\\lambda_{ij}$ is the $j$-th tangent stiffness matrix eigenvalue of the $i$-th increment, $\\sigma_k$ is the von Mises stress of the $k$-th element, and $\\sigma_{max}$ is the yield strength of the material.\n", "\n", "Instead of imposing the constraints on each eigenvalue and on each element, we are going to aggregate them using Kreisselmeier–Steinhauser (KS) functions ([Martins & Ning, 2021](https://www.cambridge.org/highereducation/books/engineering-design-optimization/B1B23D00AF79E45502C4649A0E43135B#contents)), so that we have one single value for each constraint function:\n", "\n", "$$KS_\\lambda=\\max_{i,j}\\left(g_{\\lambda,\\,ij}\\right)+\\frac{1}{\\rho}\\ln\\left(\\sum_{i=1}^{N_i}\\sum_{j=1}^{N_\\lambda}\\exp\\left(\\rho\\left(g_{\\lambda,\\,ij}-\\max_{i,j}\\left(g_{\\lambda,\\,ij}\\right)\\right)\\right)\\right),$$\n", "$$KS_\\sigma=\\max_k\\left(g_{\\sigma,\\,k}\\right)+\\frac{1}{\\rho}\\ln\\left(\\sum_{k=1}^{N_e}\\exp\\left(\\rho\\left(g_{\\sigma,\\,k}-\\max_k\\left(g_{\\sigma,\\,k}\\right)\\right)\\right)\\right).$$\n", "\n", "Furthermore, we need to include an additional constraint for the applied load at the end of the nonlinear analysis. In fact, even if the nonlinear analysis fails to converge to the prescribed applied load, Nastran will still produce valid output files that will be fed to the optimizer. When the applied load at the end of the nonlinear analysis $P_\\text{end}$ is lower than the prescribed design load $P_\\text{design}$, the output file will provide misleading values for the constraint functions. As a consequence, the following constraint is defined:\n", "\n", "$$g_P=\\frac{P_\\text{end}}{P_\\text{design}}\\geq 0.99,$$\n", "\n", "which means that the applied load at the end of the nonlinear analysis must be at least 99% of the prescribed design load." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## OpenMDAO implementation \n", "\n", "***\n", "\n", "To implement our optimization, we are going to use the [OpenMDAO](https://openmdao.org/) libary, which is an open-source high-performance computing architecture for multidisciplinary analsyis and optimization. The smallest unit of computational work within OpenMDAO is the so-called _Component_, where the actual numerical calculations happen. Each component has input and output variables that can be connected to chain together multiple computations. In our case, we only have one kind of computation happening, that is to say the nonlinear analysis under the design load. This computation has to take as input the wall thickness of our box beam, which is our only design variable, and calculate our objective and constraints.\n", "\n", "Let's go ahead and define this component, that we are going to call `NastranSolver`. We define the component such that it takes the following variables as input options:\n", "- the `BDF` object, representing the Nastran model;\n", "- the input name of the Nastran run;\n", "- the flag to run the Nastran analysis.\n", "\n", "These options represent \"static inputs\" of the component, defining quantities or objects that do not change during the optimization. The real input of the component, or in other words the quantity that does change during the optimization, is the wall thickness of the box beam, and we define it accordingly.\n", "\n", "Finally, we define the following component outputs:\n", "- the mass of the box beam;\n", "- the value of the nonlinear structural stability constraint;\n", "- the value of the material strength constraint;\n", "- the value of the applied load constraint.\n", "\n", "Then we define the `compute` method of the component such that it changes the wall thickness of the box beam in the `BDF` object, calculates the mass of the box beam, runs the nonlinear analysis, and calculates the constraints values." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "import openmdao.api as om # make available the most common OpenMDAO classes and functions\n", "from pyNastran.bdf.bdf import BDF # pyNastran BDF class\n", "from resources import pynastran_utils # utility functions to work with pyNastran objects\n", "from pyNastran.bdf.mesh_utils.mass_properties import mass_properties # pyNastran function to calculate mass properties\n", "from pyNastran.op2.op2 import read_op2 # pyNastran OP2 reader function\n", "\n", "\n", "FIRST_SUBCASE_ID = 1 # id of first subcase for SOL 106\n", " \n", "\n", "class NastranSolver(om.ExplicitComponent):\n", " \"\"\"\n", " An OpenMDAO component that performs a finite element analysis by running Nastran.\n", "\n", " Attributes\n", " ----------\n", " options : dict\n", " A dictionary of options for configuring the Nastran analysis.\n", " \n", " Methods\n", " -------\n", " initialize()\n", " Declare options for the component.\n", " setup()\n", " Define the component's inputs and outputs.\n", " setup_partials()\n", " Declare partial derivatives for the component.\n", " compute(inputs, outputs, discrete_inputs, discrete_outputs)\n", " Executes the Nastran analysis with the provided inputs and populates the outputs based on the analysis results.\n", " \"\"\"\n", "\n", " def initialize(self):\n", " \"\"\"\n", " Declare options for the component.\n", "\n", " Options\n", " -------\n", " bdf_object : BDF\n", " The BDF object representing the model.\n", " input_name : str\n", " Name of the input file for the analysis.\n", " run_flag : bool\n", " Flag to indicate if the analysis should be run.\n", " \"\"\"\n", " self.options.declare('bdf_object', types=BDF, desc='BDF object representing the Nastran model.')\n", " self.options.declare('input_name', types=str, desc='Name for the analysis input file.')\n", " self.options.declare('run_flag', types=bool, default=True, desc='Flag to control whether the analysis should be executed.')\n", "\n", " def setup(self):\n", " \"\"\"\n", " Define the inputs and outputs for the Nastran analysis component. This includes defining the shape and type of analysis results\n", " to be expected.\n", " \"\"\"\n", " # Define inputs\n", " self.add_input('t', desc='Thickness values for the elements in the model.')\n", " # Define outputs\n", " self.add_output('mass', desc='Total mass of the structure.')\n", " self.add_output('ks_stress', desc='Kreisselmeier-Steinhauser aggregated stress value.')\n", " self.add_discrete_output('op2', val=None, desc='OP2 object containing the analysis results.')\n", " self.add_output('ks_stability', desc='KS aggregated stability metric.')\n", " self.add_output('applied_load', desc='Magnitude of the applied load in the final state of the analysis.')\n", "\n", " def setup_partials(self):\n", " \"\"\"\n", " Declare partial derivatives for the component using finite difference method.\n", " \"\"\"\n", " # Finite difference all partials\n", " self.declare_partials('*', '*', method='fd', step=1e-6)\n", "\n", " def compute(self, inputs, outputs, discrete_inputs, discrete_outputs):\n", " \"\"\"\n", " Conducts the Nastran analysis based on the inputs and updates the outputs with the results. This includes running the analysis,\n", " reading results, and aggregating outcomes.\n", "\n", " Parameters\n", " ----------\n", " inputs : dict\n", " Dictionary containing the input values.\n", " outputs : dict\n", " Dictionary containing the output values.\n", " discrete_inputs : dict\n", " Dictionary containing the discrete input values.\n", " discrete_outputs : dict\n", " Dictionary containing the discrete output values.\n", " \"\"\"\n", "\n", " # Extract options for convenience\n", " bdf_object = self.options['bdf_object']\n", " input_name = self.options['input_name']\n", " run_flag = self.options['run_flag']\n", "\n", " # Assign thickness to PSHELL card\n", " pid = 1 # property id\n", " t = inputs['t'][0]\n", " bdf_object.properties[pid].t = t\n", " bdf_object.properties[pid].z1 = -t/2\n", " bdf_object.properties[pid].z2 = t/2\n", "\n", " # Calculate mass\n", " outputs['mass'] = mass_properties(bdf_object)[0]\n", "\n", " # Run analysis\n", " pynastran_utils.run_analysis(directory_path=ANALYSIS_DIRECTORY_PATH, bdf_object=bdf_object, filename=input_name, run_flag=run_flag)\n", "\n", " # Read op2 file and assign to discrete output\n", " op2_filepath = os.path.join(ANALYSIS_DIRECTORY_PATH, input_name + '.op2')\n", " op2_object = read_op2(op2_filepath, load_geometry=True, debug=None)\n", " discrete_outputs['op2'] = op2_object\n", "\n", " # Find von mises stresses and aggregate with KS function\n", " stresses = op2_object.nonlinear_cquad4_stress[FIRST_SUBCASE_ID].data[-1, :, 5]\n", " outputs['ks_stress'] = self.compute_ks_function(stresses, upper=SIGMA_Y) # von Mises stress must be less than yield stress for the material not to yield\n", " \n", " # Read eigenvalues of tangent stiffness matrix and aggregate with KS function\n", " f06_filepath = os.path.splitext(op2_filepath)[0] + '.f06' # path to .f06 file\n", " eigenvalues = pynastran_utils.read_kllrh_lowest_eigenvalues_from_f06(f06_filepath) # read eigenvalues from f06 files\n", " outputs['ks_stability'] = self.compute_ks_function(eigenvalues[~np.isnan(eigenvalues)].flatten()*1e3, lower_flag=True) # nan values are discarded and eigenvalues are converted from N/mm to N/m\n", " \n", " # Calculate final applied load magnitude\n", " _, applied_loads, _ = pynastran_utils.read_load_displacement_history_from_op2(op2_object=op2_object)\n", " outputs['applied_load'] = np.linalg.norm(applied_loads[FIRST_SUBCASE_ID][-1, :]) # calculate magnitude of applied load at last converged increment of the analysis\n", " \n", " @staticmethod\n", " def compute_ks_function(g, rho=100, upper=0, lower_flag=False):\n", " \"\"\"\n", " Compute the value of the KS function for the given array of constraints.\n", "\n", " Parameters\n", " ----------\n", " g : ndarray\n", " Array of constraint values. By default negative means satisfied and positive means violated. Behavior is modified with upper\n", " and lower_flag.\n", " rho : float, optional\n", " Constraint aggregation factor. Default is 100.\n", " upper : float, optional\n", " Upper bound for the constraints. If lower_flag is True, then this is the lower bound. Default is 0.\n", " lower_flag : bool, optional\n", " Flag to indicate if the constraints are lower-bounded. Default is False.\n", "\n", " Returns\n", " -------\n", " float\n", " Value of KS function.\n", " \"\"\"\n", " con_val = g - upper # subtract upper bound\n", " if lower_flag:\n", " con_val = -con_val # negate if constraint is lower-bounded\n", " g_max = np.max(np.atleast_2d(con_val), axis=-1)[:, np.newaxis] # find maximum constraint value\n", " g_diff = con_val - g_max # subtract maximum constraint value\n", " exponents = np.exp(rho * g_diff) # exponentiate\n", " summation = np.sum(exponents, axis=-1)[:, np.newaxis] # sum exponentiated values\n", " KS = g_max + 1.0 / rho * np.log(summation) # compute KS function\n", " return KS" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Every OpenMDAO model is constructed using instances of the _Group_ superclass, forming a hierarchy that arranges the components. In our case the hierarchy is very simple, as we only need a single group holding our `NastranSolver`. We then define the `NastranSolverGroup`, which takes the same options of the `NastranSolver` component." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "class NastranSolverGroup(om.Group):\n", " \"\"\"\n", " An OpenMDAO Group that encapsulates the NastranSolver component.\n", "\n", " Attributes\n", " ----------\n", " options : dict\n", " Configuration options for the Nastran analysis, passed to the NastranSolver component.\n", "\n", " Methods\n", " -------\n", " initialize()\n", " Declares options for the group, including all necessary settings for running a Nastran analysis.\n", " setup()\n", " Configures the group, adding the NastranSolver component and setting up connections between inputs and outputs.\n", " \"\"\"\n", " def initialize(self):\n", " \"\"\"\n", " Initialize options for the Nastran analysis group. This includes specifying the BDF object, material properties, and other\n", " analysis configurations.\n", " \"\"\"\n", " self.options.declare('bdf_object', types=BDF, desc='BDF object representing the Nastran model.')\n", " self.options.declare('input_name', types=str, desc='Name for the analysis input file.')\n", " self.options.declare('run_flag', types=bool, default=True, desc='Flag to control whether the analysis should be executed.')\n", "\n", " def setup(self):\n", " \"\"\"\n", " Setup the Nastran analysis group by adding the NastranSolver subsystem and configuring its options based on the group's settings.\n", " \"\"\"\n", " self.add_subsystem('nastran_solver',\n", " NastranSolver(bdf_object=self.options['bdf_object'],\n", " input_name=self.options['input_name'],\n", " run_flag=self.options['run_flag']))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "With the `NastranSolver` and the `NastranSolverGroup` classes we have defined the computational core of our optimization problem. We can now move on to the setup of the numerical model. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setup of the numerical model \n", "\n", "***\n", "\n", "To define an instance of `NastranSolverGroup` and set up the actual optimization problem, we first need to define the input `BDF` object. We do this by generating a mesh with the function `mesh_box_beam_reinforced_with_ribs_and_stiffeners` and then passing it to the function `create_base_bdf_input`, both belonging to the `box_beam_utils` module." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "subcase=0 already exists...skipping\n" ] } ], "source": [ "from resources import box_beam_utils\n", "\n", "box_beam_mesh = box_beam_utils.mesh_box_beam_reinforced_with_ribs_and_stiffeners(\n", " width=W, height=h, ribs_y_coordinates=ribs_y_locations, stiffeners_x_coordinates=stiffeners_x_locations,\n", " stiffeners_height=stiffeners_height, element_length=element_length) # generate mesh as a PolyData object\n", "nodes_xyz_array = box_beam_mesh.points # Nx3 array with the xyz coordinates of the nodes\n", "nodes_connectivity_matrix = box_beam_mesh.faces.reshape(-1, 5)[:, 1:] # Nx4 array with the indices of the nodes defining each element in each row\n", "box_beam_bdf = box_beam_utils.create_base_bdf_input(young_modulus=E, poisson_ratio=nu, density=rho, shell_thickness=t0,\n", " nodes_xyz_array=nodes_xyz_array, nodes_connectivity_matrix=nodes_connectivity_matrix) # create base bdf input" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This gives us a base `BDF` object including material properties, nodes, elements, boundary conditions and output files defaults. We proceed with adding the command to request the output of the nonlinear stresses." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "box_beam_bdf.case_control_deck.subcases[0].add_result_type('NLSTRESS', 'ALL', ['PLOT']) # store nonlinear stress results of all elements in the op2 file" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Analogously to our [last notebook](18_Development_and_Nonlinear_Structural_Stability_Analysis_of_a_CRM-like_Box_Beam_Model.ipynb#numerical-model), we apply a vertical force at the tip of the CRM-like box beam, setting the magnitude of the force equal to the value of the design load. Successively, we create the corresponding static subcase." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# Define master node of tip section and connect it to the nodes on the edge of the tip section with a RBE3 element\n", "TIP_MASTER_NODE_ID = len(box_beam_bdf.nodes) + 1\n", "box_beam_bdf.add_grid(TIP_MASTER_NODE_ID, [W/2, L, 0.])\n", "tolerance = element_length/100 # we define a geometric tolerance equal to 1/100 of the cquad4 elements length to find the nodes on the edge of the tip section \n", "tip_edge_nodes_ids = [nid for nid in box_beam_bdf.nodes if (np.abs(box_beam_bdf.nodes[nid].xyz[1] - L) < tolerance) &\n", " (np.abs((box_beam_bdf.nodes[nid].xyz[0]) < tolerance) | (np.abs(box_beam_bdf.nodes[nid].xyz[0] - W) < tolerance) |\n", " (np.abs(box_beam_bdf.nodes[nid].xyz[2] - h/2) < tolerance) | (np.abs(box_beam_bdf.nodes[nid].xyz[2] + h/2) < tolerance))] # ids of the nodes on the edge of the tip section\n", "rbe3_eid = len(box_beam_bdf.elements) + 1\n", "box_beam_bdf.add_rbe3(eid=rbe3_eid, refgrid=TIP_MASTER_NODE_ID, refc='123456', weights=[1.],\n", " comps=['123456'], Gijs=[tip_edge_nodes_ids])\n", "\n", "# Add vertical force\n", "force_set_id = 11\n", "force_direction = [0., 0., 1.]\n", "box_beam_bdf.add_force(sid=force_set_id, node=TIP_MASTER_NODE_ID, mag=DESIGN_LOAD, xyz=force_direction)\n", "\n", "# Add subcase for static analysis\n", "pynastran_utils.create_static_load_subcase(bdf_object=box_beam_bdf, subcase_id=FIRST_SUBCASE_ID, load_set_id=force_set_id)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we need to setup the nonlinear analysis with the arc-length method. What parameters should we use? The key requirements are to trace the equilibrium path of the structure in a robust way, or in other words avoiding to jump away from it, and to do so in a computationally efficient manner. As a consequence, we cannot choose to employ very fine arc-length increments from the start to the end of the analysis, as this would result in exessively long computational times.\n", "\n", "In our [last notebook](18_Development_and_Nonlinear_Structural_Stability_Analysis_of_a_CRM-like_Box_Beam_Model.ipynb#error-function), we observed that by using load and displacement error functions, $\\mathrm{MAXITER}=5$ and remaining default parameters, all the equilibrium points found by the nonlinear analysis lied on the natural equilibrium path. This analysis took only about 200 seconds, so only a fraction of the 3.2 hours taken by the analysis with very fine arc-length increments. As a consequence, we might be tempted to use the mentioned parameters for the nonlinear analyses of our optimization problem.\n", "\n", "However, the analysis with load and displacement error functions, $\\mathrm{MAXITER}=5$ and remaining default parameters was not able to capture the unstable part of the equilibrium path and thus the snap-through behavior of the structure. Capturing the unstable part of the equilibrium path is an essential requirement for the nonlinear analyses of our optimization problem, in order to enforce the nonlinear structural stability constraint. As a consequence, we need to refine this set of parameters with the aim of capturing the snap-through behavior of the structure.\n", "\n", "To start, we read the op2 file of the analysis employing the mentioned parameters and of that employing very fine arc-length increments. We then plot the 3D equilibrium diagram showing the $z$-displacement at the root of the CRM-like box beam, the $z$-displacement at the tip and the applied load. We do this by using the function `plot_3d_load_displacements_stability` from the `plot_utils` module to highlight the stability along the equilibrium paths." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "14e05be7612b48abbbc42b72e7780493", "version_major": 2, "version_minor": 0 }, "image/png": "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", "text/html": [ "\n", "