{ "cells": [ { "attachments": {}, "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." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "# On the Correct Application of the Nonlinear Buckling Method\n", "\n", "***\n", "\n", "In this notebook we are going to explain a mistake that we have been committing so far when using the nonlinear buckling method of SOL 106, and we are going to show its correct application on the different configurations of the box beam.\n", "\n", "* [Introduction](#introduction)\n", "* [Unreinforced box beam](#unreinforced)\n", "* [Box beam reinforced with ribs](#reinforced-ribs)\n", "* [Box beam reinforced with ribs and stiffeners](#reinforced-ribs-stiffeners)\n", "* [Conclusions](#conclusions)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "## Introduction \n", "\n", "***\n", "\n", "As explained in our [first notebook](01_Buckling_Analysis_of_Euler_Column.ipynb), SOL 106's nonlinear buckling method finds the critical buckling factor $\\alpha$ representing the multiplicative factor of the last load increment vector $\\boldsymbol{\\Delta P}$, that summed to the vector of applied loads of the last iteration $\\boldsymbol{P}_n$ gives the critical buckling load $\\boldsymbol{P}_{cr}$:\n", "\n", "$$\\boldsymbol{P}_{cr}=\\boldsymbol{P}_n+\\alpha\\boldsymbol{\\Delta P}.$$\n", "\n", "So far we have always asked Nastran to perofrm the eigenvalue calculation needed to calculate $\\alpha$ using the `EIGRL` card and setting a value of 0 for the field V1, which defines the lower bound of the eigenvalue range of interest. This means that we have constrained Nastran to calculate only positive eigenvalues. However, there is no reason for $\\alpha$ not to be negative. In fact, if $\\boldsymbol{P}_n$ is beyond $\\boldsymbol{P}_{cr}$, the nonlinear buckling method should return a negative $\\alpha$, meaning that the critical buckling load is obtained by subtracting a portion of $\\boldsymbol{\\Delta P}$ from $\\boldsymbol{P}_n$.\n", "\n", "As a consequence, for a correct application of the nonlinear buckling method we need to leave the field V1 of the `EIGRL` card blank, which allows both positive and negative eigenvalues to be calculated.\n", "\n", "Now we are going to perform once again a verification study of the nonlinear buckling method for the three configurations of the box beam that we have considered so far: unreinforced, reinforced with ribs and reinforced with ribs and stiffeners. We remind that the verification of the nonlinear buckling method consists in verifying whether the nonlinear buckling method is able to predict the same critical load predicted by SOL 105 for the linear range of the structural response, that is to say below $P/P_\\text{SOL 105}=1$." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Unreinforced box beam \n", "\n", "***\n", "\n", "We consider the same unreinforced box beam analyzed in our [sixth notebook](06_Verification_of_SOL_106_Nonlinear_Buckling_Method.ipynb)." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": true }, "outputs": [ { "data": { "image/svg+xml": [ "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "" ], "text/plain": [ "" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.display import SVG # class to embed an SVG into the display\n", "import os # module with miscellaneous operating system interfaces\n", "\n", "SVG(filename=os.path.join('resources', '04_BoxBeamConcentratedLoad.svg'))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ " We define the geometry and the material properties, generate the mesh, create the base `BDF` object and apply the concetrated load at the tip constraining the section with a RBE2 element." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Box beam dimensions:\n", "- width: 1.0 m\n", "- length: 4.5 m\n", "- height: 0.2 m\n", "- wall thickness: 4.0 mm\n", "\n", "---BDF Statistics---\n", "SOL None\n", "\n", "bdf.spcs[1]: 1\n", " SPC1: 1\n", "\n", "bdf.params: 0\n", " PARAM : 1\n", "\n", "bdf.nodes: 0\n", " GRID : 3388\n", "\n", "bdf.elements: 0\n", " CQUAD4 : 3344\n", "\n", "bdf.properties: 0\n", " PSHELL : 1\n", "\n", "bdf.materials: 0\n", " MAT1 : 1\n", "\n", "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "subcase=0 already exists...skipping\n" ] } ], "source": [ "from resources import box_beam_utils\n", "import numpy as np\n", "from resources import pynastran_utils\n", "\n", "# Define geometry\n", "AR = 9. # aspect ratio - 2*b/w (the length of the box beam corresponds to half the span of the CRM wing)\n", "w = 1e3 # width [mm]\n", "l = AR*w/2 # length [mm]\n", "non_dimensional_height = 0.2 # h/w\n", "h = w*non_dimensional_height # box height [mm]\n", "non_dimensional_thickness = 1/50 # t/h\n", "t = h*non_dimensional_thickness # shell thickness [mm]\n", "print(f\"\"\"\n", "Box beam dimensions:\n", "- width: {w/1e3:.1f} m\n", "- length: {l/1e3:.1f} m\n", "- height: {h/1e3:.1f} m\n", "- wall thickness: {t:.1f} mm\\n\"\"\")\n", "\n", "# Define material properties\n", "rho = 2780e-12 # density [ton/mm^3]\n", "E = 73.1e3 # Young's modulus [MPa]\n", "nu = 0.3 # Poisson's ratio\n", "\n", "# Generate mesh\n", "shell_element_length = 59.9 # from previous mesh convergence study [mm]\n", "unreinforced_box_beam_mesh = box_beam_utils.mesh_box_with_pyvista(width=w, length=l, height=h,\n", " element_length=shell_element_length)\n", "nodes_coordinates_array = unreinforced_box_beam_mesh.points\n", "nodes_connectivity_matrix = unreinforced_box_beam_mesh.faces.reshape(-1, 5)[:, 1:]\n", "\n", "# Creta base BDF object\n", "unreinforced_box_beam_bdf = box_beam_utils.create_base_bdf_input(young_modulus=E, poisson_ratio=nu, density=rho,\n", " shell_thickness=t,\n", " nodes_xyz_array=nodes_coordinates_array,\n", " nodes_connectivity_matrix=nodes_connectivity_matrix)\n", "print(unreinforced_box_beam_bdf.get_bdf_stats()) # print cards of BDF object\n", "\n", "# Apply concetrated load at the tip\n", "nodes_ids = np.arange(1, np.size(nodes_coordinates_array, 0) + 1)\n", "tolerance = shell_element_length/100\n", "tip_nodes_ids = nodes_ids[np.abs(nodes_coordinates_array[:,1] - l) < tolerance] # find id of tip section nodes\n", "tip_master_node_id = np.amax(nodes_ids) + 1\n", "unreinforced_box_beam_bdf.add_grid(tip_master_node_id, [w/2, l, 0.]) # add master node of tip section\n", "rbe2_eid = len(unreinforced_box_beam_bdf.elements) + 1\n", "unreinforced_box_beam_bdf.add_rbe2(eid=rbe2_eid, gn=tip_master_node_id, cm='123456', Gmi=tip_nodes_ids) # add RBE2 to connect master node with outer nodes of tip rib\n", "FORCE_SET_ID = 11\n", "force_direction = [0., 0., 1.]\n", "pynastran_utils.add_unitary_force(bdf_object=unreinforced_box_beam_bdf, nodes_ids=[tip_master_node_id],\n", " set_id=FORCE_SET_ID, direction_vector=force_direction) # add concentrated force" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } }, "source": [ "Then we recall the buckling load predicted by SOL 105 and we define 11 load magnitudes equally spaced between 0 and twice the linear buckling load. We discard the load case with null magnitude and we keep the other 10 load cases." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Applied loads [N]: [ 331. 662. 992. 1323. 1654. 1985. 2316. 2646. 2977. 3308.]\n" ] } ], "source": [ "sol_105_buckling_load = 1654. # [N]\n", "applied_load_magnitudes = np.linspace(0, 2*sol_105_buckling_load, 11)[1:]\n", "np.set_printoptions(precision=0, suppress=True)\n", "print(f'Applied loads [N]: {applied_load_magnitudes}')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "To set up and run our nonlinear analysis, we define the function `run_nonlinear_buckling_method_sweep`. This function sets up the arc-length method for the nonlinear analysis by calling the function `set_up_arc_length_method` from the `pynastran_utils` module, creates one subcase for each applied load in the input array and calls the function `run_nonlinear_buckling_method` from the `pynastran_utils` module. The latter in turn sets up the eigenvalue calculation with the `EIGRL` card leaving the field V1 blank, so that both positive and negative eigenvalues can be calculated, and then it runs the analysis, reads the op2 file and returns the `OP2` object. The same object is also returned by the main function `run_nonlinear_buckling_method_sweep`.\n", "\n", "We set the argument `calculate_tangent_stiffness_matrix_eigenvalues=True` of the function `run_nonlinear_buckling_method` to calculate the smallest magnitude eigenvalue of the tangent stiffness matrix for each converged iteration contextually to the nonlinear buckling method. Since the parameters of the `EIGRL` card are used to compute both the eigenvalues of the nonlinear buckling method and the eigenvalues of the tangent stiffness matrix, we also want to verify that the structural stability results obtained in the previous notebooks were not affected by the mistake in setting up the `EIGRL` card." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Define name of analysis directory\n", "analysis_directory_name = \"13_On_the_Correct_Application_of_the_Nonlinear_Buckling_Method\"\n", "ANALYSIS_DIRECTORY_PATH = os.path.join(os.getcwd(), 'analyses', analysis_directory_name)\n", "\n", "# Function to set up the nonlinear analysis with the nonlinear buckling methods for increasing applied loads\n", "def run_nonlinear_buckling_method_sweep(bdf_input, load_magnitudes, input_filename, run_flag=True):\n", " # Set up nonlinear analysis with arc-length method\n", " pynastran_utils.set_up_arc_length_method(bdf_object=bdf_input, ninc=100, max_iter=25, conv='PUV', eps_p=1e-3,\n", " eps_u=1e-3, max_bisect=10, minalr=.01, maxalr=1.0001, desiter=5,\n", " maxinc=1000)\n", " # Create the LOAD cards corresponding to the input load magnitudes and the associated subcases\n", " for i, scale_factor in enumerate(load_magnitudes):\n", " load_set_id = 21 + i\n", " bdf_input.add_load(sid=load_set_id, scale=1., scale_factors=[scale_factor], load_ids=[FORCE_SET_ID])\n", " pynastran_utils.create_static_load_subcase(bdf_object=bdf_input, subcase_id=i+1, load_set_id=load_set_id)\n", " # Run analysis with nonlinear buckling method and return OP2 object\n", " op2 = pynastran_utils.run_nonlinear_buckling_method(bdf_object=bdf_input, method_set_id=FORCE_SET_ID + 1,\n", " analysis_directory_path=ANALYSIS_DIRECTORY_PATH,\n", " calculate_tangent_stiffness_matrix_eigenvalues=True,\n", " input_name=input_filename, run_flag=run_flag)\n", " # Return op2 object\n", " return op2" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "Let's call the function `run_nonlinear_buckling_method_sweep` for the unreinforced box beam using the applied loads defined earlier." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Nastran job unreinforced_box_beam.bdf completed\n", "Wall time: 1763.0 s\n" ] }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "input_name = 'unreinforced_box_beam'\n", "sol_106_op2 = run_nonlinear_buckling_method_sweep(unreinforced_box_beam_bdf, applied_load_magnitudes, input_name,\n", " run_flag=False)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } }, "source": [ "Now we want to plot the buckling loads predicted by SOL 106, $P_\\text{SOL 106}$ and the critical buckling factors, $\\alpha$, against the applied load $P$. In order to do this, we define the function `plot_buckling_loads`, which takes as input the path to the f06 file, the `OP2` object, the array of the applied loads and the buckling load predicted by SOL 105. The function reads $P_\\text{SOL 106}$ and $\\alpha$ from the f06 file and then it plots them against the applied loads. All loads are nondimensionalized with the buckling load predicted by SOL 105." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", "# Function to plot SOL 106 buckling loads and critical buckling factors against applied loads\n", "def plot_buckling_loads(f06_path, op2_output, applied_loads, linear_buckling_load):\n", " # Read nonlinear buckling loads and critical buckling factors from f06 file\n", " nonlinear_buckling_load_vectors, critical_buckling_factors = pynastran_utils.read_nonlinear_buckling_load_from_f06(\n", " f06_filepath=f06_path, op2_object=op2_output)\n", " nonlinear_buckling_loads = np.linalg.norm(np.sum(nonlinear_buckling_load_vectors[:, :, 0:3], axis=1), axis=1) # calculate the norm of the nonlinear buckling load vector for each subcase\n", " # Plot nonlinear buckling loads and critical buckling factors vs applied loads\n", " _, axs = plt.subplots(nrows=2, ncols=1, sharex='all') # figure with 2 subplots\n", " axs[0].plot(applied_loads/linear_buckling_load, nonlinear_buckling_loads/linear_buckling_load, 'o') # buckling loads vs applied loads\n", " axs[1].plot(applied_loads/linear_buckling_load, critical_buckling_factors, 'o') # critical buckling factors vs applied loads\n", " # Set plot appearance\n", " axs[0].set_ylabel('$P_\\mathrm{SOL\\,106}/P_\\mathrm{SOL\\,105}$')\n", " axs[0].grid(visible=True)\n", " axs[1].set_ylabel('$\\\\alpha$')\n", " axs[1].grid(visible=True)\n", " axs[1].set_xlabel('$P/P_\\mathrm{SOL\\,105}$')\n", " plt.show()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Let's call `plot_buckling_loads` and plot the results of our analysis on the unreinforced box beam." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAroAAAIHCAYAAABwqf+yAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAABJ0AAASdAHeZh94AABleElEQVR4nO3deXhU9f3+/3sSQhIyhhCSqChNNATDjgYiaV3CWlApEYutVaiAVgiyWFrkIwhEAaHFrRYQ6hIoaisoWHErCJG2xIZF+gNlSzBsiiQhLBPJQnJ+f/DNyJAEzmSZmZw8H9eVC+e83+fM67wchjtnzpxjMwzDEAAAAGAxft4uAAAAAGgIBF0AAABYEkEXAAAAlkTQBQAAgCURdAEAAGBJBF0AAABYEkEXAAAAlkTQBQAAgCURdAEAAGBJzbxdQFNx8uRJffbZZ2rbtq0CAwO9XQ4AAECjUlJSosOHD+v2229XWFiYqXUIuh7y2WefKSUlxdtlAAAANGpr1qzRkCFDTM0l6HpI27ZtJZ3/n9OuXTsvV1Mzh8OhrKwsJSYmym63e7scn0av3EO/zKNX5tEr8+iVefTKPE/2Kjs7WykpKc5MZQZB10MqT1do166dOnXq5OVqanb69GkdO3ZMHTp0UGhoqLfL8Wn0yj30yzx6ZR69Mo9emUevzPNGr9w5BZQvowEAAMCSCLoAAABwW1l5hbYcPKn/Fdi05eBJlZVXeLukKjh1AQAAAKaVlVdocUaOlmfmKt9RKslfr+3bqUj7Pg1PitbY5FgF+PvGsVSCLgAAAEwpK6/Qb5Zv1ca9ebJdNJbvKNFz6/Zpx+GTWjI8wSfCrvcrAAAAQKOwOCNHG/fmSZKMi8YqH2/Yc1wvZ+R4tK6aEHQBAABwWWXlFVqemVvlSO7FbJKWZx70iXN2CboAAAC4rK25hcp3lFY5knsxQ1Keo0Rbcws9UdYlEXQBAABwWafOljbo/IZA0AUAAMBltQxu3qDzGwJBFwAAAJfVI6aVIuzNTZ2jG2kPVI+YVp4o65IIugAAALisAH8/jUiKMXWO7oikaC4vBgAAgMZjbHKs+sRHSVKVI7uVj/vER2lMcqxH66oJQRcAAACmBPj7acnwBE3u314R9kCXsQh7oCb3b+8zN4uQuDMaAAAA3BDg76fxfeM0JjlWm746ov9s2aGf9Oyu2zpe6zMBtxJBFwAAAG4L8PdTz+gwOQ4Y6hkd5nMhV+LUBQAAAFgUQRcAAACWRNAFAACAJRF0AQAAYEkEXQAAAFgSQRcAAACWRNAFAACAJVk66J45c0ZTpkzRgAEDFBkZKZvNplmzZplef+PGjerfv7+ioqJkt9vVtWtX/elPf1J5eXnDFQ0AAIB6YemgW1BQoKVLl6qkpEQpKSlurbt+/Xr169dP586d01/+8hetWbNGycnJmjhxon772982TMEAAACoN5a+M1p0dLQKCwtls9mUn5+vV155xfS66enpCggI0Nq1axUSEiJJ6tevn/bu3av09HS9+OKLDVU2AAAA6oGlg67NZqv1ugEBAWrevLmCg4NdloeFhSkoKKiupQEAAKCBWTro1sWYMWP01ltvacKECXriiSfUokULvf/++1q9erWeeeaZS657/Phx5eXluSzLzs6WJDkcDp0+fbrB6q6roqIilz9RM3rlHvplHr0yj16ZR6/Mo1fmebJXDofD7XUIujW4+eabtWHDBg0bNkwLFy6UJPn7++uZZ57R5MmTL7nuokWLlJaWVu1YVlaWjh07Vu/11resrCxvl9Bo0Cv30C/z6JV59Mo8emUevTLPE706dOiQ2+sQdGuwbds23X333br55pu1ZMkShYSEaMOGDZo+fbqKi4v15JNP1rhuamqqhg0b5rIsOztbKSkpSkxMVIcOHRq6/ForKipSVlaWEhMTnecmo3r0yj30yzx6ZR69Mo9emUevzPNkr3bv3u32OgTdGowbN05XXnmlVq9eLX9/f0lS79695efnp1mzZun+++/X9ddfX+26UVFRioqKqnbMbrcrNDS0wequLyEhIY2iTl9Ar9xDv8yjV+bRK/PolXn0yjxP9Mput7u9jqUvL1YXO3bsUEJCgjPkVurZs6cqKipq9VsFAAAAPIegW4M2bdpo69atVW4OkZmZKUm69tprvVEWAAAATLL8qQsfffSRioqKdObMGUnSV199pVWrVkmS7rjjDrVo0UKjR4/WsmXLlJOTo+joaEnSY489pgkTJmjw4MF65JFH1KJFC3366ad69tln1a9fP3Xr1s1r+wQAAIDLs3zQHTt2rA4ePOh8vHLlSq1cuVKS9PXXXysmJkbl5eUqLy+XYRjOeePHj9c111yj559/Xg899JDOnj2rmJgYzZw5U4899pjH9wMAAADusXzQzc3Nveyc9PR0paenV1k+dOhQDR06tP6LAgAAQIPjHF0AAABYEkEXAAAAlkTQBQAAgCURdAEAAGBJBF0AAABYkk9edeH06dPavHmzJCkpKUktW7b0ckUAAABobHwi6Pbr10/r16+XJH3xxRcaNGiQIiMj5efnp++++04fffSRbrzxRi9XCQAAULOy8gptzS3UqbOlahncXD1iWinAnw/Pvckngm5WVpbzv3//+9/r8ccfd96U4U9/+pN+97vf6dNPP/VWeQAAADUqK6/Q4owcLc/MVb6j1Lk80h6o4UnRGpscS+D1Ep/r+s6dO5Wamup8PHbsWP3vf//zYkUAAADVKyuv0G+Wb9Vz6/ap4IKQK0n5jhI9t26fHvnrNpWVV3ipwqbNJ47olpWV6a233lJFxfkXQXl5uXPMMAyVlpbWtCoAAIDXLM7I0ca9eZIk46Kxyscb9hzXyxk5Gt83zqO1wUeO6N58881aunSpXnnlFXXs2FFfffWVc2zTpk264YYbvFgdAABAVWXlFVqemSvbZebZJC3PPMhRXS/wiSO6GRkZNY717NlTH330keeKAQAAMGFrbqHLObk1MSTlOUq0NbdQSbGtG74wOPlE0L0ULi0GAAB80amz7p1a6e581J3PBN3CwkK99957+vLLL+VwOGS329WpUyf97Gc/U3h4uLfLAwAAcNEyuHmDzkfd+cQ5uuvXr1dsbKyWL1+ukpIStW7dWiUlJVq+fLni4uK4tBgAAPA5PWJaKcLe3NQ5upH2QPWIaeWJsnABnzii++ijj2rZsmUaPHhwlbG1a9cqNTVVe/fu9UJlAAAA1Qvw99OIpBg9t27fJecZkkYkRXMtXS/wiY4fOXJEAwYMqHasX79+OnLkiIcrAgAAuLyxybHqEx8lSVWO7FY+7hMfpTHJsR6tC+f5RNBNTk7Wo48+qm+//dZl+TfffKMJEyYoOTnZO4UBAABcQoC/n5YMT9Dk/u0VYQ90GYuwB2py//ZaMjyBo7le4hOnLqSnpys1NVUxMTG64oorFBoaqtOnT8vhcGjIkCFatmyZt0sEAACoVoC/n8b3jdOY5FhtzS3UqbOlahncXD1iWhFwvcwngm5ERITefvttFRUVaf/+/c6rLsTFxSkkJMTb5QEAAFxWgL8f18n1MT4RdCuFhISoe/fuLssqKiq0YsUKjRgxwjtFAQAAoFHy+ePpZWVlGjlypLfLAAAAQCPjE0d0n3rqqRrHysrKPFgJAAAArMIngu7s2bN19913KzQ0tMpYeXm5FyoCAABAY+cTQbdz584aMWKE7rzzzipjxcXFSk9P93xRAAAAaNR84hzd0aNH69y5c9WOBQQEaObMmbXa7pkzZzRlyhQNGDBAkZGRstlsmjVrllvbeO+993T77bcrNDRUISEh6tSpk5YuXVqregAAAOA5PhF0x40bpyFDhlQ75u/vX+ugW1BQoKVLl6qkpEQpKSlurz9v3jwNHTpUnTt31ttvv61//OMfSk1NVWlpaa3qAQAAgOf4xKkLDSU6OlqFhYWy2WzKz8/XK6+8Ynrdbdu2adq0aXrmmWc0ZcoU5/K+ffs2RKkAAACoZz5xRPdSKioqtHz58lqta7PZZLNdfOdpc/785z8rMDBQ48ePr9X6AAAA8C6fD7reuo7upk2b1KFDB73zzju64YYb5O/vr2uvvVZTp07l1AUAAIBGoFGcumAYhsef8+jRo8rLy9OECRP09NNPq2PHjvr00081b948HT58WG+88UaN6x4/flx5eXkuy7KzsyVJDodDp0+fbtDa66KoqMjlT9SMXrmHfplHr8yjV+bRK/PolXme7JXD4XB7nUYRdGt7+kFdVFRU6MyZM3rrrbf0y1/+UpLUu3dvFRUV6YUXXlBaWpratWtX7bqLFi1SWlpatWNZWVk6duxYg9VdX7KysrxdQqNBr9xDv8yjV+bRK/PolXn0yjxP9OrQoUNur+MTQXfz5s01jpWUlHiwkh+0bt1ax44d009/+lOX5YMGDdILL7yg7du31xh0U1NTNWzYMJdl2dnZSklJUWJiojp06NBgdddVUVGRsrKylJiYqJCQEG+X49PolXvol3n0yjx6ZR69Mo9emefJXu3evdvtdXwi6N5///2XHP/Rj37koUp+0LVr12qPvFaeRuHnV/PpzVFRUYqKiqp2zG63V3sHOF8TEhLSKOr0BfTKPfTLPHplHr0yj16ZR6/M80Sv7Ha72+v4RND9+uuvvV1CFffcc4/++c9/6qOPPtKvfvUr5/IPP/xQfn5+6tmzpxerAwAAwOX4RNBtSB999JGKiop05swZSdJXX32lVatWSZLuuOMOtWjRQqNHj9ayZcuUk5Oj6OhoSdLIkSO1ZMkSpaamKj8/Xx07dtT69eu1cOFCpaamOucBAADAN/lU0N2/f78yMjKUn5+viIgIJScnKy4urk7bHDt2rA4ePOh8vHLlSq1cuVLS+SPJMTExKi8vV3l5ucvVHQICArRu3To98cQTmjt3rk6cOKHrrrtO8+bN029/+9s61QQAAICG5xNBt6KiQmPGjNGrr76q6OhoXXnllfruu+80duxYjR49WosXL77kObGXkpube9k56enpSk9Pr7I8PDxcL7/8sl5++eVaPTcAAAC8xyduGPH0008rMzNT27dv14EDB5SZmakDBw5o69at2rx5s+bMmePtEgEAANDI+ETQXbZsmd58801169bNZXn37t31xhtv6LXXXvNSZQAAAGisfCLofvfdd+rUqVO1Y506ddJ3333n4YoAAADQ2PlE0G3btq0yMzOrHdu8ebPatm3r4YoAAADQ2PlE0B0/frzuu+8+ffDBB84rHxiGobVr1+r+++/XxIkTvVwhAAAAGhufuOrCuHHjVFhYqHvvvVfnzp1TRESE8vPz1axZMz3xxBNKTU31dokAAABoZHwi6ErS9OnTNX78eGVmZqqgoECtW7dWUlKSWrZs6e3SAAAA0Aj5xKkLBw8e1JEjR9SyZUsNHDhQQ4YM0aZNmzR8+HDNmTNH586d83aJAAAAaGR8IuiOHj1a27Ztcz5OTU3V3//+d91www3661//qv/7v//zYnUAAABojHzi1IX//e9/6t+/vyTpzJkzevvtt5WZmakbb7xRDz/8sAYMGKA//vGPXq4SAAC4o6y8QltzC3XqbKlaBjdXj5hWCvD3iWNsaCJ8IuiWlZWpRYsWks5fTiw8PFw33nijJKl9+/YqKCjwZnkAAMANZeUVWpyRo+WZucp3lDqXR9oDNTwpWmOTYwm88AifeJV16NBB7733niRp1apVzqO7kvTtt9/qiiuu8FZpAADADWXlFfrN8q16bt0+FVwQciUp31Gi59bt0yN/3aay8govVYimxCeO6M6fP18pKSkKCgpSaWmpNm3a5Bz7+9//rltuucWL1QEAALMWZ+Ro4948SZJx0Vjl4w17juvljByN7xvn0drQ9PhE0L3tttuUm5urffv2qX379goNDXWODRo0SPfee68XqwMAAGaUlVdoeWaubKoaci9kk7Q886DGcAoDGpjHX11nzpzRqFGjFBkZqRYtWig5OVmbNm1SaGioevTo4RJyJemGG25QmzZtPF0mAABw09bcQuU7Si8ZcqXzITjPUaKtuYWeKAtNmMeD7hNPPKH09HRFRUWpW7du2rZtm/r376/PPvvM06UAAIB6dOps6eUn1WE+4C6PB933339f48aN05dffqnMzEwdOHBAPXr00OOPP+7pUgAAQD1qGdy8QecD7vJ40D1y5IiGDRvmfBwZGannnntOW7ZsUWEhH2EAANBY9YhppQh7c9kuM8+m85ca6xHTyhNloQnzeNCtqKhQUFCQy7IuXbrIMAwdPXrU0+UAAIB6EuDvpxFJMabO0R2RFM0X0dDgvPIK+/bbb10eBwYGSpJKSzlXBwCAxmxscqz6xEdJUpUju5WP+8RHaUxyrEfrQtPklcuLDR06VC1atFCXLl3UvXt3derUSTbb5T7oAAAAvi7A309Lhifo5YwcLc88qDxHiXMswh6oEUnRXFYMHuPxoPvBBx9o+/bt2r59u7Zt26bPP//cOXbrrbeqa9euSkhIUEJCgm666SZ169bN0yUCAIA6CPD30/i+cRqTHKutuYU6dbZULYObq0dMKwIuPMrjQXfQoEEaNGiQ8/GJEyecobcyAC9evFiGYchms6m8vNzTJQIAgHoQ4O+npNjW3i4DTZjX74wWHh6ufv36qV+/fs5lp0+f1rZt2/TFF194sTIAAAA0Zh7//ODFF1/UkSNHLjknNDRUvXv31m9/+1sPVQUAAACr8XjQnTt3rqKjo3XzzTfrj3/8o3JycjxdAgAAAJoAjwfdb7/9VuvXr1fPnj31wgsvqH379urevbtmz56tr776ql6f68yZM5oyZYoGDBigyMhI2Ww2zZo1q1bbmj59umw2mzp37lyvNQIAAKBheDzo+vn5qXfv3vrzn/+so0ePatOmTerdu7deeeUVdenSRR06dND06dPr5fzcgoICLV26VCUlJUpJSan1dnbs2KEFCxboyiuvrHNNAAAA8AyvX+PjJz/5iZ5//nnl5uYqMzNTP/vZz/T3v/9dPXr00PXXX68pU6bUetvR0dEqLCzUZ599pmeeeaZW2zh37pxGjhypRx55RPHx8bWuBQAAAJ7l9aB7ocTERM2fP1/79+/Xtm3bdP/99+uDDz6o9fZsNludb0Qxb948nThxQnPmzKnTdgAAAOBZXr+8WE26d++u7t276+mnn/ZaDV999ZVmz56td999V3a73Wt1AAAAwH0+EXS//vprhYeHq2XLlpKkN954Qx9++KEk6a677tJ9993n8ZoqKio0atQoDR06VHfccYdb6x4/flx5eXkuy7KzsyVJDodDp0+frrc661tRUZHLn6gZvXIP/TKPXplHr8yjV+bRK/M82SuHw+H2Oj4RdO+66y69//77atmypWbPnq0VK1bokUcekWEYeuqpp3TgwAFNmzbNozU999xz2r9/v/7xj3+4ve6iRYuUlpZW7VhWVpaOHTtW1/IaXFZWlrdLaDTolXvol3n0yjx6ZR69Mo9emeeJXh06dMjtdXwi6B46dEjXX3+9JOn111/Xhg0bFB0dLUm699579eMf/9ijQffQoUOaMWOG5s2bp+bNm+vkyZOSzn8xraKiQidPnlRgYKCCg4OrXT81NVXDhg1zWZadna2UlBQlJiaqQ4cODb0LtVZUVKSsrCwlJiYqJCTE2+X4NHrlHvplHr0yj16ZR6/Mo1fmebJXu3fvdnsdnwi6V111lfbu3asbbrhBZWVlCg8Pd46FhYV5/KP+AwcO6OzZs5o4caImTpxYZbxVq1aaOHGiXnjhhWrXj4qKUlRUVLVjdrtdoaGh9VlugwgJCWkUdfoCeuUe+mUevTKPXplHr8yjV+Z5ole1+b6UTwTd//u//9MvfvELPf/88/rd736nX/3qV5o6daoMw9Af/vAH3XvvvR6tp3v37tq4cWOV5ZMmTdKpU6f0+uuv69prr/VoTQAAAHCPTwTdUaNGKTIyUlOnTtUXX3yhc+fO6YMPPtA111yjX//615o5c2att/3RRx+pqKhIZ86ckXT+SgqrVq2SJN1xxx1q0aKFRo8erWXLliknJ0fR0dEKCwtTcnJylW2FhYXp3Llz1Y4BAADAt/hE0JWkwYMHa/DgwaqoqNB3332n4OBghYWF1Xm7Y8eO1cGDB52PV65cqZUrV0o6f7WHmJgYlZeXq7y8XIZh1Pn5AAAA4Bt8JugWFhbqvffe05dffimHwyG73a7OnTtr8ODBLufsuis3N/eyc9LT05Wenn7ZeRkZGbWuAwAAAJ7lE3dGW79+vWJjY7Vs2TKVlJSodevWKikp0bJlyxQXF6dPP/3U2yUCAACgkfGJI7qPPvqoli1bpsGDB1cZW7t2rVJTU7V3714vVAYAAIDGyieO6B45ckQDBgyodqxfv346cuSIhysCAABAY+cTQTc5OVmPPvqovv32W5fl33zzjSZMmMBVDgAAAOA2nwi66enpOnXqlGJiYhQREaHrr7/e+eepU6e0bNkyb5cIAACARsYnztGNiIjQ22+/raKiIu3fv9951YW4uDhuvQcAAIBa8YmgWykkJETdu3d3WVZRUaEVK1ZoxIgR3ikKAAAAjZJPnLpwKWVlZRo5cqS3ywAAAEAj4xNHdJ966qkax8rKyjxYCQAAAKzCJ4Lu7Nmzdffddys0NLTKWHl5uRcqAgCg/pWVV2hrbqFOnS1Vy+Dm6hHTSgH+Pv/hKtBo+UTQ7dy5s0aMGKE777yzylhxcbGp2/MCAOCrysortDgjR8szc5XvKHUuj7QHanhStMYmxxJ4gQbgE0F39OjROnfuXLVjAQEBmjlzpocrAgCgfpSVV+g3y7dq49482S4ay3eU6Ll1+7Tj8EktGZ5A2AXqmU8E3XHjxtU45u/vT9AFADRaizNytHFvniTJuGis8vGGPcf1ckaOxveN82htgNXxqyMAAA2krLxCyzNzqxzJvZhN0vLMgyorr/BEWUCTQdAFAKCBbM0tVL6jtMqR3IsZkvIcJdqaW+iJsoAmw+eDbkVFhZYvX+7tMgAAcNups6WXn1SH+QAuzeeDLjeMAAA0Vi2DmzfofACX5vNBV5IM43If+gAA4Ht6xLRShL25qXN0I+2B6hHTyhNlAU1Gowi6Ntvl3iIAAPA9Af5+GpEUY+oc3RFJ0VxeDKhnPnF5sc2bN9c4VlJS4sFKAACoX2OTY7Xj8Elt2HNcNrleYqzycZ/4KI1JjvVOgYCF+UTQvf/++y85/qMf/chDlQAAUL8C/P20ZHiCXs7I0fLMg8pz/HAAJ8IeqBFJ0RrDndGABuETQffrr7/2dgkAADSYAH8/je8bpzHJsdqaW6hTZ0vVMri5esS0IuACDcgngm6l/fv3KyMjQ/n5+YqMjFRycrLatWvn7bIAAKgXAf5+Sopt7e0ygCbDJ4JuRUWFxowZo1dffVXR0dG68sor9d1332nMmDEaPXq0Fi9eLD8/fuMFAACAeT6RHp9++mllZmZq+/btOnDggDIzM3XgwAFt3bpVmzdv1pw5c7xdIgAAABoZnwi6y5Yt05tvvqlu3bq5LO/evbveeOMNvfbaa16qDAAAAI2VTwTd7777Tp06dap2rFOnTvruu+9qtd0zZ85oypQpGjBggCIjI2Wz2TRr1ixT67777ru677771K5dOwUHBysmJkb333+/9u/fX6taAAAA4Fk+EXTbtm2rzMzMasc2b96stm3b1mq7BQUFWrp0qUpKSpSSkuLWuvPnz9f333+vadOm6eOPP9bs2bP1xRdf6KabbtKXX35Zq3oAAADgOT7xZbTx48frvvvu0+LFi3XHHXfIZrPJMAx98MEHSk1N1dSpU2u13ejoaBUWFspmsyk/P1+vvPKK6XXff/99RUVFuSzr06ePYmJi9Pzzz7u1LQAAAHieTwTdcePGqbCwUPfee6/OnTuniIgI5efnq1mzZnriiSeUmppaq+3W5dbBF4dcSWrTpo2uvfZaHT58uNbbBQAAgGf4RNCVpOnTp2v8+PHKzMxUQUGBWrduraSkJLVs2dLbpTkdOHBABw8evOxpEMePH1deXp7LsuzsbEmSw+HQ6dOnG6rEOisqKnL5EzWjV+6hX+bRK/PolXn0yjx6ZZ4ne+VwONxex2YYhnH5aQ3r4MGD8vf317XXXivp/I7MnTtXu3bt0s0336zHH39czZrVLZNX3oRi5syZpr+QdqFz586pf//+2r59u3bt2nXJ84ZnzZqltLS0asf+9Kc/cUtjAAAANx06dEgTJkzQrl27aryIwcV84oju6NGjNX78eGfQTU1N1X/+8x8NHTpUf/3rX3Xy5En98Y9/9Fp9hmFo9OjR+te//qV33nnnsl+OS01N1bBhw1yWZWdnKyUlRYmJierQoUNDllsnRUVFysrKUmJiokJCQrxdjk+jV+6hX+bRK/PolXn0yjx6ZZ4ne7V792631/GJoPu///1P/fv3l3T+kmBvv/22MjMzdeONN+rhhx/WgAEDvBZ0DcPQQw89pBUrVmjZsmUaMmTIZdeJioqq9hxfSbLb7QoNDa3vMutdSEhIo6jTF9Ar99Av8+iVefTKPHplHr0yzxO9stvtbq/jE0G3rKxMLVq0kHT+cmLh4eG68cYbJUnt27dXQUGBV+qqDLmvv/66Xn31VT3wwANeqQMAAADu84nr6Hbo0EHvvfeeJGnVqlXOo7uS9O233+qKK67weE2GYejhhx/W66+/riVLlmjkyJEerwEAAAC15xNHdOfPn6+UlBQFBQWptLRUmzZtco79/e9/1y233FLrbX/00UcqKirSmTNnJElfffWVVq1aJUm644471KJFC40ePVrLli1TTk6OoqOjJUkTJkzQq6++qlGjRqlLly76/PPPndsMDAx0HnEGAACAb/KJoHvbbbcpNzdX+/btU/v27V3O8Rg0aJDuvffeWm977NixOnjwoPPxypUrtXLlSknS119/rZiYGJWXl6u8vFwXXoDi/ffflyS99tpreu2111y2GR0drdzc3FrXBAAAgIbn8VMXzpw5o1GjRikyMlItWrRQcnKyNm3apNDQUPXo0aPKicw33HCD2rRpU+vny83NlWEY1f7ExMRIktLT010eX249Qi4AAIDv83jQfeKJJ5Senq6oqCh169ZN27ZtU//+/fXZZ595uhQAAABYmMeD7vvvv69x48bpyy+/VGZmpg4cOKAePXro8ccf93QpAAAAsDCPB90jR4643EwhMjJSzz33nLZs2aLCwkJPlwMAAACL8njQraioUFBQkMuyLl26yDAMHT161NPlAAAAwKK8ch3db7/91uVxYGCgJKm0tNQb5QAAAMCCvHJ5saFDh6pFixbq0qWLunfvrk6dOslms3mjFAAAAFiUx4PuBx98oO3bt2v79u3atm2by40Ybr31VnXt2lUJCQlKSEjQTTfdpG7dunm6RACAh5SVV2hrbqFOnS1Vy+Dm6hHTSgH+PnHTTgAW4PGgO2jQIA0aNMj5+MSJE87QWxmAFy9eLMMwZLPZVF5e7ukSAQANrKy8QoszcrQ8M1f5jh9OW4u0B2p4UrTGJscSeAHUmdfvjBYeHq5+/fqpX79+zmWnT5/Wtm3b9MUXX3ixMgBAQygrr9Bvlm/Vxr15uviktXxHiZ5bt087Dp/UkuEJhF0AdeKT7yChoaHq3bu3fvvb33q7FABAPVuckaONe/MkScZFY5WPN+w5rpczcjxaFwDr8cmgCwCwprLyCi3PzK1yJPdiNknLMw+qrLzCE2UBsCiCLgDAY7bmFirfUVrlSO7FDEl5jhJtzeVGQgBqj6ALAPCYU2fdu166u/MB4EIEXQCAx7QMbt6g8wHgQgRdAIDH9IhppQh7c1Pn6EbaA9UjppUnygJgUQRdAIDHBPj7aURSjKlzdEckRXN5MQB1wjsIAMCjxibHqk98lCRVObJb+bhPfJTGJMd6tC4A1kPQBQB4VIC/n5YMT9Dk/u0VYQ90GYuwB2py//bcLAJAvfD6ndEAAE1PgL+fxveN05jkWG3NLdSps6VqGdxcPWJaEXAB1BuCLgDAawL8/ZQU29rbZQCwKH5tBgAAgCURdAEAAGBJBF0AAABYEkEXAAAAlsSX0QD4tLLyCr6VDwCoFUv/a3HmzBlNmTJFAwYMUGRkpGw2m2bNmmV6/ePHj+vBBx9URESEWrRooaSkJH366acNVzBgQll5hTJzCvTxrm+VmVOgsvIKb5fUIMrKK/SnT/cr6ZlPdd9fPteYFdt1318+14+f2aA/fbrfsvsNAKg/lj6iW1BQoKVLl6pbt25KSUnRK6+8YnrdkpIS9e3bVydPntSLL76oqKgoLVy4UAMHDtT69et1++23N2DltdfUjn41pf0tK6/Q4owcLc/MVb6j1Lk80h6o4UnRGpsca5l9Lyuv0G+Wb9XGvXlV7pyV7yjRc+v2acfhk9xUAABwSZYOutHR0SosLJTNZlN+fr5bQffVV1/Vrl27tHnzZiUlJUmSevfurW7dumnKlCn673//21Bl10pTCkFS09zfphT8FmfkaOPePEmScdFY5eMNe47r5Ywcje8b59HaAACNR+P/F/ESbDabbLaLY4E5q1ev1g033OAMuZLUrFkzPfDAA8rKytLRo0frq8w6qwxBz63bp4ILQp/0Qwh65K/bLPNRb1PbX8m94NfYlZVXaHlmbpVAfzGbpOWZBy31/xkAUL8sHXTrYteuXeratWuV5ZXLvvzyS0+XVKOmFIKkpre/TS34bc0tVL6jtMr/24sZkvIcJdqaW+iJsgAAjZClT12oi4KCAoWHh1dZXrmsoKCgxnWPHz+uvLw8l2XZ2dmSJIfDodOnT9dbnWXlFVq2+WvZVDX0Xcgmadnmr/WrmyIv+dF2UVGRy5++pr73ty481astB0+6nJ5Rk8rgt+mrI+oZHdagNdWG2X59W3DKre1+W3BKpyMDal2XL/L1v4e+hF6ZR6/Mo1fmebJXDofD7XUIupdwqdMeLjW2aNEipaWlVTuWlZWlY8eO1bm2SvtP2VRQ5H/ZeYak/KIyvf7+JsW1vNyxsvN1+qKG2t+6aOhe/a/AJuny+1zpP1t2yHGgYfe5Li7XrwOn3NvfA3t2aeO3vru/deGrfw99Eb0yj16ZR6/M80SvDh065PY6BN0atG7dutqjtidOnJCkao/2VkpNTdWwYcNclmVnZyslJUWJiYnq0KFDvdVZvidf+mq36fnXx3dW7/iIGseLioqUlZWlxMREhYSE1EeJ9aq+97cuPNUr+8GTem3fTtPzf9Kzu88e0TXTr1vKK/TWwSydKCq77FH71iEBGjn4J5b4At6FfP3voS+hV+bRK/PolXme7NXu3eb//a9E0K1Bly5dtHNn1XBRuaxz5841rhsVFaWoqKhqx+x2u0JDQ+unSElXty5zc35LU88fEhJSr3XWl4ba37po6F7d1tGuCPteFVzmvFWbpAh7oG7reK1PBz8z/fr1j6/Tc+v2XXKO8f/mtW4VVn/F+YCy8gptOXhS/yuwyZ5fptui7D79/9NX+Op7li+iV+bRK/M80Su73e72Orx71uDuu+/Wnj17XC4jdu7cOa1YsUI333yz2rRp48XqftAjppUi7M1NfVEp0h6oHjGtPFFWg2lq+ytJAf5+GpEUY+rLWSOSoi0RisYmx6pP/PlfFi/+f135uE98lMYkx3q0roZ04Q0yRr+xU6/t89foN3ZygwwAqIPG/y/iZXz00UdatWqV3n//fUnSV199pVWrVmnVqlX6/vvvJUmjR49Ws2bNdPDgQed6o0aNUqdOnTRs2DC9+eabWr9+ve69917t3btX8+fP98q+VKephaCmtr+VmlrwC/D305LhCZrcv70i7IEuYxH2QE3u394y1wyWmuYl8wDAEyx/6sLYsWNdAuzKlSu1cuVKSdLXX3+tmJgYlZeXq7y8XIbxQ3wKDAzUp59+qilTpmj8+PH6/vvv1b17d3300Uc+d1e0scmx2nH4pDbsOV7lagSVj60Ugpra/ko/BL+XM3K0PPOg8hwlzrEIe6BGJEVrjMVukhHg76fxfeM0JjnW8ne/4wYZANAwLB90c3NzLzsnPT1d6enpVZZfeeWVWrZsWf0XVc+aWghqavtbqSkFvwsF+PspKba1t8toMBdeJ/ly52Avzzxoydc2ADQUywfdpqKphaCmtr8Xsnrwa2oqb5BxORfeIIP//wBgDkHXYppaCGpq+wvrOXX28iG3LvMBoCmz9qEvAPBxLYObN+h8AGjKCLoA4EVN8ZJ5AOApBF0A8KKmesk8APAE3jEBwMua2nWSAcBTCLoA4GVN7QYZAOApXHUBAHzAhZfM2/TVEf1nyw79pGd33dbxWgIuANQSQRcAfEiAv596RofJccBQz+gwQi4A1AFB10NKSs7fvSs7O9vLlVyaw+HQoUOHtHv3btntdm+X49PolXvol3n0yjx6ZR69Mo9emefJXlVmqMpMZQZB10MOHz4sSUpJSfFuIQAAAI3Y4cOHddNNN5maazMM43JXtUE9OHnypD777DO1bdtWgYGBl1/BS7Kzs5WSkqI1a9aoXbt23i7Hp9Er99Av8+iVefTKPHplHr0yz5O9Kikp0eHDh3X77bcrLCzM1Doc0fWQsLAwDRkyxNtlmNauXTt16tTJ22U0CvTKPfTLPHplHr0yj16ZR6/M81SvzB7JrcS3HAAAAGBJBF0AAABYEkEXAAAAlkTQhYvIyEjNnDlTkZGR3i7F59Er99Av8+iVefTKPHplHr0yz9d7xVUXAAAAYEkc0QUAAIAlEXQBAABgSQRdAAAAWBJBFwAAAJZE0AUAAIAlEXQBAABgSQRdAAAAWBJBFwAAAJZE0AUAAIAlEXQBAABgSQRdAAAAWBJBFwAAAJZE0AUAAIAlEXQBAABgSQRdAAAAWBJBFwAAAJZE0AUAAIAlEXQBAABgSQRdAAAAWBJBFwAAAJZE0AUAAIAlEXQBAABgSQRdAAAAWBJBFwAAAJZE0AUAAIAlEXQBAABgSQRdAAAAWBJBFwAAAJZE0AUAAIAlWSbofvHFF0pJSVGbNm3UokULxcfH66mnntL333/vMm/79u3q16+f7Ha7wsLCNHToUB04cKDabb700kuKj49XYGCgrrvuOqWlpamsrMwTuwMAAIA6skTQ/eqrr/TjH/9Yubm5euGFF7R27Vr98pe/1FNPPaX77rvPOW/Pnj1KTk5WaWmp3n77bb322mvat2+fbr31VuXl5blsc86cOZo4caKGDh2qTz75RKmpqZo7d67GjRvn6d0DAABALdgMwzC8XURdTZ8+XXPmzFF2drZiY2Odyx955BEtXbpUJ06cUKtWrXTvvfdq48aNysnJUWhoqCTp4MGDiouL02OPPab58+dLkgoKCnTttddqxIgRWrJkiXN7c+fO1fTp07Vr1y517NjRrRpPnjypzz77TG3btlVgYGA97DUAAEDTUVJSosOHD+v2229XWFiYuZUMC5g1a5YhycjLy3NZPmXKFMPPz89wOBxGWVmZERwcbDzyyCNV1h8wYIARFxfnfLxixQpDkpGZmeky75tvvjEkGXPmzHG7xjVr1hiS+OGHH3744Ycffvipw8+aNWtM569msoBf//rXeuGFFzR27FjNnz9fkZGR+uyzz7RkyRKNGzdOISEh2rt3r86ePauuXbtWWb9r165at26diouLFRQUpF27dkmSunTp4jLv6quvVkREhHPcHW3btpUkrVmzRu3atavFXnqGw+FQVlaWEhMTZbfbvV2OT6NX7qFf5tEr8+iVefTKPHplnid7lZ2drZSUFGemMsMSQTcmJkaZmZm6++67XU5dmDBhgl544QVJ509HkKTw8PAq64eHh8swDBUWFurqq69WQUGBAgMDFRISUu3cym3V5Pjx41XO+T18+LAk6aqrrnLrf5CnFRUV6dixY/rRj35U7f7jB/TKPfTLPHplHr0yj16ZR6/M82SvHA6HJLl1Cqglgm5ubq4GDx6sK6+8UqtWrVJkZKT++9//avbs2XI4HHr11Vedc202W43buXDM7LzqLFq0SGlpadWOZWVl6dixY5dc3xdkZWV5u4RGg165h36ZR6/Mo1fm0Svz6JV5nujVoUOH3F7HEkF36tSpOn36tHbs2OH8beK2225TRESERo0apREjRuiqq66SpGqPxp44cUI2m815YnPr1q1VXFys77//Xi1atKgyNyEh4ZL1pKamatiwYS7LKg+3JyYmqkOHDrXd1csqK6/QjiOndersObUMbqbu14YqwN/8xTWKioqcH0HwW+yl0Sv30C/z6JV59Mo8emUevTLPk73avXu32+tYIuju2LFDHTt2rNLgnj17SpJ27dqln/zkJwoODtbOnTurrL9z5061a9dOQUFBkn44N3fnzp26+eabnfOOHTum/Px8de7c+ZL1REVFKSoqqtoxu93uvOJDfSorr9DijBwtz8xVvqPUuTzSHqjhSdEamxzrVuANCQlpkDqtiF65h36ZR6/Mo1fm0Svz6JV5nuhVbc4BtsR1dNu0aaMvv/zSee5GpczMTEnStddeq2bNmmnw4MF69913debMGeecQ4cOaePGjRo6dKhz2cCBAxUUFKT09HSX7aWnp8tmsyklJaXB9qU2ysor9JvlW/Xcun0quCDkSlK+o0TPrdunR/66TWXlFV6qEAAAwPMscUR30qRJSklJUf/+/fXYY48pIiJCn3/+uZ555hl17NhRgwYNkiSlpaWpZ8+euuuuuzR16lQVFxdrxowZioiI0OTJk53bCw8P1/Tp0/Xkk08qPDxcAwYM0JYtWzRr1iw99NBDbl9Dt6EtzsjRxr3nv/xmXDRW+XjDnuN6OSNH4/vGebQ2AAAAb7HEEd2f/exn+vTTTxUaGqqJEyfqrrvu0rJly/TII49o06ZNat68uSQpPj5eGRkZCggI0M9//nM9+OCDateunTZt2qTIyEiXbU6bNk0vvPCCVq1apQEDBuill17S1KlTtXDhQm/sYo3Kyiu0PDNXl/56nGSTtDzzIEd1AQBAk2GJI7qS1Lt3b/Xu3fuy8xISErR+/XpT25wwYYImTJhQ19Ia1NbcQpdzcmtiSMpzlGhrbqGSYls3fGEAAABeZokjuk3ZqbOXD7l1mQ8AANBYEXQbuZbBzRt0PgAAQGNF0G3kesS0UoS9ualzdCPtgeoR08oTZQEAAHgdQbeRC/D304ikmCpXW7iYIWlEUrRb19IFAABozEg9FjA2OVZ94s/foOLiI7uVj/vER2lMcqxH6wIAAPAmgq4FBPj7acnwBE3u314R9kCXsQh7oCb3b68lwxM4mgsAAJoUy1xerKkL8PfT+L5xGpMcq625hTp1tlQtg5urR0wrAi4AAGiSCLoWE+Dvx3VyAQAAxKkLAAAAsCiCLgAAACyJoAsAAABLIugCAADAkgi6AAAAsCSCLgAAACyJoAsAAABLIugCAADAkgi6AAAAsCSCLgAAACyJoAsAAABLIugCAADAkgi6AAAAsCSCLgAAACyJoAsAAABLslTQ/fe//6077rhDrVq1UnBwsOLi4vT000+7zNm+fbv69esnu92usLAwDR06VAcOHKh2ey+99JLi4+MVGBio6667TmlpaSorK/PErgAAAKCOLBN033zzTd1+++1q2bKlli9frg8//FCPP/64DMNwztmzZ4+Sk5NVWlqqt99+W6+99pr27dunW2+9VXl5eS7bmzNnjiZOnKihQ4fqk08+UWpqqubOnatx48Z5etcAAABQC828XUB9OHr0qH7zm9/okUce0aJFi5zLe/fu7TJvxowZCgwM1Nq1axUaGipJSkhIUFxcnBYsWKD58+dLkgoKCjR79mw9/PDDmjt3riQpOTlZZWVlmj59uiZNmqSOHTt6aO8AAABQG5Y4ovvKK6+oqKhIjz/+eI1zzp07p7Vr1+qee+5xhlxJio6OVu/evbV69Wrnso8//ljFxcUaOXKkyzZGjhwpwzC0Zs2aet8HAAAA1C9LHNHdtGmTwsPDtWfPHg0ZMkS7du1SeHi4hg4dqj/84Q8KDQ1VTk6Ozp49q65du1ZZv2vXrlq3bp2Ki4sVFBSkXbt2SZK6dOniMu/qq69WRESEc7wmx48fr3IqRHZ2tiTJ4XDo9OnTddndBlVUVOTyJ2pGr9xDv8yjV+bRK/PolXn0yjxP9srhcLi9jiWC7tGjR/X9999r2LBh+r//+z+98MIL2rJli2bOnKldu3bpX//6lwoKCiRJ4eHhVdYPDw+XYRgqLCzU1VdfrYKCAgUGBiokJKTauZXbqsmiRYuUlpZW7VhWVpaOHTtWi730rKysLG+X0GjQK/fQL/PolXn0yjx6ZR69Ms8TvTp06JDb61gi6FZUVKi4uFgzZ87U1KlTJZ0/p7Z58+aaNGmSPv30U7Vo0UKSZLPZatzOhWNm51UnNTVVw4YNc1mWnZ2tlJQUJSYmqkOHDpfdJ28pKipSVlaWEhMTqw36+AG9cg/9Mo9emUevzKNX5tEr8zzZq927d7u9jiWCbuvWrbV//3799Kc/dVk+aNAgTZo0Sdu3b9eQIUMkqdqjsSdOnJDNZlNYWJhze8XFxfr++++dAfnCuQkJCZesJyoqSlFRUdWO2e12l3OEfVVISEijqNMX0Cv30C/z6JV59Mo8emUevTLPE72y2+1ur2OJL6NVd96tJOelxfz8/BQbG6vg4GDt3LmzyrydO3eqXbt2CgoKkvTDubkXzz127Jjy8/PVuXPn+iwfAAAADcASQfeee+6RJH300Ucuyz/88ENJUq9evdSsWTMNHjxY7777rs6cOeOcc+jQIW3cuFFDhw51Lhs4cKCCgoKUnp7usr309HTZbDalpKQ0zI7AbWXlFcrMKdDHu75VZk6BysorvF0SAADwEZY4dWHAgAEaPHiwnnrqKVVUVKhXr17aunWr0tLSdNddd+mWW26RJKWlpalnz5666667NHXqVBUXF2vGjBmKiIjQ5MmTndsLDw/X9OnT9eSTTyo8PFwDBgzQli1bNGvWLD300ENcQ9cHlJVXaHFGjpZn5irfUepcHmkP1PCkaI1NjlWAvyV+jwMAALVkmSTw97//XZMmTdLSpUs1aNAgLV68WI899phWrVrlnBMfH6+MjAwFBATo5z//uR588EG1a9dOmzZtUmRkpMv2pk2bphdeeEGrVq3SgAED9NJLL2nq1KlauHChp3cNFykrr9Bvlm/Vc+v2qeCCkCtJ+Y4SPbdunx756zaO7gIA0MRZ4oiuJAUHB2vevHmaN2/eJeclJCRo/fr1prY5YcIETZgwoT7KQz1anJGjjXvPX6fYuGis8vGGPcf1ckaOxveN82htAADAd1jmiC6ahrLyCi3PzNWlL/Am2SQtzzzIUV0AAJowgi4ala25hcp3lFY5knsxQ1Keo0Rbcws9URYAAPBBBF00KqfOll5+Uh3mAwAA6yDoolFpGdy8QecDAADrIOiiUekR00oR9uamztGNtAeqR0wrT5QFAAB8EEEXjUqAv59GJMWYOkd3RFI019IFAKAJIwWg0RmbHKs+8VGSVOXIbuXjPvFRGpMc69G6AACAbyHootEJ8PfTkuEJmty/vSLsgS5jEfZATe7fXkuGJ3A0FwCAJs4yN4xA0xLg76fxfeM0JjlWW3MLdepsqVoGN1ePmFYEXAAAIImgi0YuwN9PSbGtvV0GAADwQRz6AgAAgCURdAEAAGBJBF0AAABYEkEXAAAAlkTQBQAAgCURdAEAAGBJBF0AAABYEkEXAAAAlkTQBQAAgCURdAEAAGBJBF0AAABYEkEXAAAAlmTZoPvKK6/IZrPJbrdXGdu+fbv69esnu92usLAwDR06VAcOHKh2Oy+99JLi4+MVGBio6667TmlpaSorK2vo8gEAAFBHlgy6R48e1e9+9zu1adOmytiePXuUnJys0tJSvf3223rttde0b98+3XrrrcrLy3OZO2fOHE2cOFFDhw7VJ598otTUVM2dO1fjxo3z1K4AAACglpp5u4CGMGbMGN12220KDw/XqlWrXMZmzJihwMBArV27VqGhoZKkhIQExcXFacGCBZo/f74kqaCgQLNnz9bDDz+suXPnSpKSk5NVVlam6dOna9KkSerYsaNndwwAAACmWe6I7ooVK/TZZ59p0aJFVcbOnTuntWvX6p577nGGXEmKjo5W7969tXr1aueyjz/+WMXFxRo5cqTLNkaOHCnDMLRmzZoG2wcAAADUnaWC7vHjxzVp0iTNmzdP1157bZXxnJwcnT17Vl27dq0y1rVrV2VnZ6u4uFiStGvXLklSly5dXOZdffXVioiIcI4DAADAN1nq1IXU1FTdcMMNGjt2bLXjBQUFkqTw8PAqY+Hh4TIMQ4WFhbr66qtVUFCgwMBAhYSEVDu3clvVOX78eJXzfbOzsyVJDodDp0+fNr1PnlZUVOTyJ2pGr9xDv8yjV+bRK/PolXn0yjxP9srhcLi9jmWC7jvvvKP3339fX3zxhWw22yXnXmr8wjGz8y62aNEipaWlVTuWlZWlY8eOXbI+X5CVleXtEhoNeuUe+mUevTKPXplHr8yjV+Z5oleHDh1yex1LBF2Hw6Fx48Zp/PjxatOmjU6ePClJKi0tlSSdPHlSAQEBat26tSRVezT2xIkTstlsCgsLkyS1bt1axcXF+v7779WiRYsqcxMSEmqsJzU1VcOGDXNZlp2drZSUFCUmJqpDhw613dUGV1RUpKysLCUmJlZ7NBs/oFfuoV/m0Svz6JV59Mo8emWeJ3u1e/dut9exRNDNz8/Xd999p2effVbPPvtslfFWrVppyJAhWrVqlYKDg7Vz584qc3bu3Kl27dopKChI0g/n5u7cuVM333yzc96xY8eUn5+vzp0711hPVFSUoqKiqh2z2+0uX4TzVSEhIY2iTl9Ar9xDv8yjV+bRK/PolXn0yjxP9Kq6eyNcjiWC7lVXXaWNGzdWWT5v3jx99tln+uijjxQREaFmzZpp8ODBevfdd/WHP/xBV1xxhaTzh8I3btyoxx57zLnuwIEDFRQUpPT0dJegm56eLpvNppSUlAbfLwAAANSeJYJuUFCQkpOTqyxPT0+Xv7+/y1haWpp69uypu+66S1OnTlVxcbFmzJihiIgITZ482TkvPDxc06dP15NPPqnw8HANGDBAW7Zs0axZs/TQQw9xDV14TVl5hbbmFurU2VK1DG6uHjGtFOBvqQuoAABQLywRdN0RHx+vjIwMPf744/r5z3+uZs2aqU+fPlqwYIEiIyNd5k6bNk1XXHGFFi5cqAULFuiqq67S1KlTNW3aNC9Vj6asrLxCizNytDwzV/mOUufySHughidFa2xyLIEXAIALWDropqenKz09vcryhIQErV+/3tQ2JkyYoAkTJtRzZYB7ysor9JvlW7Vxb54uvt5HvqNEz63bpx2HT2rJ8ATCLgAA/w//IgKNwOKMHG3ce/7azMZFY5WPN+w5rpczcjxaFwAAvoygC/i4svIKLc/MrXIk92I2ScszD6qsvMITZQEA4PMIuoCP25pbqHxHaZUjuRczJOU5SrQ1t9ATZQEA4PMIuoCPO3W29PKT6jAfAACrIugCPq5lcPMGnQ8AgFURdAEf1yOmlSLszU2doxtpD1SPmFaeKAsAAJ9H0AV8XIC/n0YkxZg6R3dEUjSXFwMA4P/hX0SgERibHKs+8VGSVOXIbuXjPvFRGpMc69G6AADwZQRdoBEI8PfTkuEJmty/vSLsgS5jEfZATe7fnptFAABwEUvfGQ2wkgB/P43vG6cxybHamluoU2dL1TK4uXrEtCLgAgBQDYIu0MgE+PspKba1t8sAAMDncRgIAAAAlkTQBQAAgCURdAEAAGBJBF0AAABYEkEXAAAAllTroDtv3jwVFxfXZy0AAABAval10F2xYoXi4uL0+uuvyzBcb0565MgRLV26tM7FAQAAALVV66C7c+dOPfXUU/r973+vrl276h//+Ie++eYbHT16VEuXLtWECRPqs04AAADALbW+YcTq1as1ceJEORwOnThxQikpKbLZbM7xhx9+uF4KBAAAAGqj1kd0H3/8cfXq1UubNm3Szp07tWPHDo0ZM0b+/v765S9/qZdffrk+6wQAAADcUuuge+TIEU2dOlW33HKLOnXqpK5du2rhwoXKzMxURkaGnnzyyfqsEwAAAHBLrYNuXFycduzYUWV5QkKCnn32WS1evLgudQEAAAB1Uuugm5qaqhkzZujvf/97lTHDMFRUVFSnwtyxYcMGjRo1SvHx8QoJCdE111yjIUOGaNu2bVXmbt++Xf369ZPdbldYWJiGDh2qAwcOVLvdl156SfHx8QoMDNR1112ntLQ0lZWVNfTuAAAAoB7U+stoY8aM0YYNG3Tfffdp7ty5Gjx4sK677jrl5eXp+eefV5cuXeqzzktavHixCgoKNHHiRHXs2FF5eXl69tln1atXL33yySfq06ePJGnPnj1KTk5W9+7d9fbbb6u4uFgzZszQrbfeqh07digyMtK5zTlz5ujJJ5/U1KlTNWDAAG3ZskXTp093XlUCAAAAvq3WQVeS3n77bb3++utauHChnnnmGef1dCMjI/Xiiy/WS4FmLFy4UFFRUS7LBg4cqHbt2mnu3LnOoDtjxgwFBgZq7dq1Cg0NlXT+VIu4uDgtWLBA8+fPlyQVFBRo9uzZevjhhzV37lxJUnJyssrKyjR9+nRNmjRJHTt29Nj+AQAAwH11vgXwyJEjtXXrVhUUFCgrK0vbtm3T4cOHlZSUVB/1mXJxyJUku92ujh076vDhw5Kkc+fOae3atbrnnnucIVeSoqOj1bt3b61evdq57OOPP1ZxcbFGjhzpss2RI0fKMAytWbOmYXYEAAAA9aZOR3QvFBYWph49etTX5urs1KlT2r59u/Nobk5Ojs6ePauuXbtWmdu1a1etW7dOxcXFCgoK0q5duySpyukXV199tSIiIpzjNTl+/Ljy8vJclmVnZ0uSHA6HTp8+Xev9amiV51Z78hzrxopeuYd+mUevzKNX5tEr8+iVeZ7slcPhcHudegu6vmbcuHEqKirStGnTJJ0/HUGSwsPDq8wNDw+XYRgqLCzU1VdfrYKCAgUGBiokJKTauZXbqsmiRYuUlpZW7VhWVpaOHTvm7u54XFZWlrdLaDTolXvol3n0yjx6ZR69Mo9emeeJXh06dMjtdSwZdJ988km98cYbeumll5SQkOAyduHd2y524ZjZedVJTU3VsGHDXJZlZ2crJSVFiYmJ6tChwyXX96aioiJlZWUpMTGx2qCPH9Ar99Av8+iVefTKPHplHr0yz5O92r17t9vrWC7opqWlafbs2ZozZ44effRR5/LWrVtLUrVHY0+cOCGbzaawsDDn3OLiYn3//fdq0aJFlbkXh+eLRUVFVXvesHT+3OELzxH2VSEhIY2iTl9Ar9xDv8yjV+bRK/PolXn0yjxP9Mput7u9Tp2/jOZL0tLSNGvWLM2aNUtPPPGEy1hsbKyCg4O1c+fOKuvt3LlT7dq1U1BQkKQfzs29eO6xY8eUn5+vzp07N9AeALhYWXmFMnMK9PGub5WZU6Cy8gpvlwQAaCQsc0T36aef1qxZszR9+nTNnDmzynizZs00ePBgvfvuu/rDH/6gK664QtL58z02btyoxx57zDl34MCBCgoKUnp6um6++Wbn8vT0dNlsNqWkpDT4/gBNXVl5hRZn5Gh5Zq7yHaXO5ZH2QA1PitbY5FgF+Fvqd3UAQD2zRNB99tlnNWPGDA0cOFB33nmnPv/8c5fxXr16STp/xLdnz5666667NHXqVOcNIyIiIjR58mTn/PDwcE2fPl1PPvmkwsPDnTeMmDVrlh566CGuoQs0sLLyCv1m+VZt3Juni8+Iz3eU6Ll1+7Tj8EktGZ5A2AUA1MgSQff999+XdP76tx9//HGV8cobWcTHxysjI0OPP/64fv7zn6tZs2bq06ePFixY4HJXNEmaNm2arrjiCi1cuFALFizQVVddpalTpzqv4gCg4SzOyNHGvecv0WdcNFb5eMOe43o5I0fj+8Z5tDYAQONhiaCbkZFhem5CQoLWr19vau6ECRM0YcKEWlYFoDbKyiu0PDNXNlUNuReySVqeeVBjOIUBAFAD/nUA4FO25hYq31F6yZArnQ/BeY4Sbc0t9ERZAIBGiKALwKecOlt6+Ul1mA8AaDoIugB8Ssvg5g06HwDQdBB0AfiUHjGtFGFvXuVqCxez6fylxnrEtPJEWQCARoigC8CnBPj7aURSjKlzdEckRfNFNABAjfgXAoDPGZscqz7x52+jffGR3crHfeKjNCY51qN1AQAaF4IuAJ8T4O+nJcMTNLl/e0XYA13GIuyBmty/PTeLAABcliWuowvAegL8/TS+b5zGJMdqa26hTp0tVcvg5uoR04qACwAwhaALwKcF+PspKba1t8sAADRCHBYBAACAJRF0AQAAYEkEXQAAAFgSQRcAAACWRNAFAACAJRF0AQAAYEkEXQAAAFgSQRcAAACWRNAFAACAJRF0AQAAYEkEXQAAAFgSQRcAAACWRNAFAACAJRF0L8HhcGjSpElq06aNgoKC1L17d/3tb3/zdlkAAAAwoZm3C/BlQ4cO1ZYtWzRv3jy1b99eb775pu677z5VVFToV7/6lbfLAwAAwCUQdGvw4Ycfat26dc5wK0m9e/fWwYMH9fvf/16/+MUv5O/v7+UqAQAAUBNOXajB6tWrZbfbNWzYMJflI0eO1DfffKP//ve/XqoMAAAAZhB0a7Br1y516NBBzZq5HvTu2rWrcxwAAAC+i1MXalBQUKDrr7++yvLw8HDneE2OHz+uvLw8l2XZ2dmSzn/B7fTp0/VYaf0qKipy+RM1o1fuoV/mlJVX6PPs4/pfgU3N9h5Tr3YVCvDnmERNeF2ZR6/Mo1fmebJXDofD7XUIupdgs9lqNbZo0SKlpaVVO5aVlaVjx47VubaGlpWV5e0SGg165R76Vb3yCmn9Nzb965ifzpTZJPnrtX37dUXAPt16VYX6tTFE3q0Zryvz6JV59Mo8T/Tq0KFDbq9D0K1B69atqz1qe+LECUk/HNmtTmpqapVze7Ozs5WSkqLExER16NChfoutR0VFRcrKylJiYqJCQkK8XY5Po1fuoV81Kyuv0KRVX+lfhwt18a/QjjKbPjzsL0dguJ6/pwNHdy/C68o8emUevTLPk73avXu32+sQdGvQpUsXvfXWWzp37pzLebo7d+6UJHXu3LnGdaOiohQVFVXtmN1uV2hoaP0W2wBCQkIaRZ2+gF65h35V9adP9+tfOYWSJOOiscrHm7JP6M3teRrfN86jtTUWvK7Mo1fm0SvzPNEru93u9jocGqjB3XffLYfDoXfeecdl+bJly9SmTRvdfPPNXqoMgJWUlVdoeWZulSO5F7NJWp55UGXlFZ4oCwAsgSO6NRg0aJD69++vsWPH6vTp02rXrp3eeustffzxx1qxYgXX0AVQL7bmFirfUXrZeYakPEeJtuYWKim2dcMXBgAWQNC9hHfffVfTpk3TjBkzdOLECcXHx+utt97SL3/5S2+XBsAiTp29fMity3wAaMoIupdgt9v14osv6sUXX/R2KQAsqmVw8wadDwBNGefoAoAX9YhppQh7c1Pn6EbaA9UjppUnygIASyDoAoAXBfj7aURSTJWrLVzMkDQiKZrLiwGAG3jHBAAvG5scqz7x5y9JePGR3crHfeKjNCY51qN1AUBjR9AFAC8L8PfTkuEJmty/vSLsgS5jEfZATe7fXkuGJ3A0FwDcxJfRAMAHBPj7aXzfOI1JjtWmr47oP1t26Cc9u+u2jtcScAGglgi6AOBDAvz91DM6TI4DhnpGhxFyAaAOeAcFAACAJRF0AQAAYEmcugAAABpEWXmFtuYW6tTZUrUMbq4eMa04HQceRdAFAAD1qqy8QoszcrQ8M1f5jh9uWx1pD9TwpGiNTY4l8MIjCLoAAKDelJVX6DfLt2rj3rwq14XOd5TouXX7tOPwSS6ZB4/gFQYA8Jqy8gpl5hTo413fKjOnQGXlFd4uqUE1hf1dnJGjjXvzJKnKHf8qH2/Yc1wvZ+R4tC40TRzRBQB4XFP7aLup7G9ZeYWWZ+bKpqoh90I2ScszD2qMRfYbvotXFwDAoyo/2n5u3T4VXBD6pB8+2n7kr9ssc7SzKe3v1txC5TtKLxlypfMhOM9Roq25hZ4oC00YQRcA4FFN7aPtprS/p86WXn5SHeYD7iLoAgA85sKPti+l8qPtxn6Us6ntb8vg5g06H3AXQRcA4DFN7aPtpra/PWJaKcLe3FSwj7QHqkdMK0+U5TFN4cuGjQ1fRgMAeExT+2i7qe1vgL+fRiTF6Ll1+y45z5A0IinaMl9EaypfNmyM6DoAwGOa2kfbTW1/JWlscqz6xEdJUpUju5WP+8RHaUxyrEfraihN6cuGjRFBFwDgMU3to+2mtr/S+aO6S4YnaHL/9oqwB7qMRdgDNbl/e0vdLKIpfdmwMeLUBQCAxzS1j7ab2v5WCvD30/i+cRqTHKutuYU6dbZULYObq0dMK8vso8R1gxsDug0A8Kim9tF2U9vfCwX4+ykptrUGdr5aSbGtLRfymtqXDRsja73iAAA+r6l9tN3U9rcpaWpfNmyMGv2pCxs2bNCKFSu0efNmHT58WGFhYerRo4dmzJihhISEKvO3b9+uKVOm6PPPP1ezZs3Up08fLViwQNdff32VuS+99JIWLlyor7/+Wm3atNGDDz6oJ554QgEBAZ7YNQCwrKby0Xalpra/TUVT/LJhY9Pog+7ixYtVUFCgiRMnqmPHjsrLy9Ozzz6rXr166ZNPPlGfPn2cc/fs2aPk5GR1795db7/9toqLizVjxgzdeuut2rFjhyIjI51z58yZoyeffFJTp07VgAEDtGXLFk2fPl1Hjx7V0qVLvbGrAGA5lR9tNxVNbX+trvLLhgWXOX3BpvNH763wZcPGptEH3YULFyoqKspl2cCBA9WuXTvNnTvXJejOmDFDgYGBWrt2rUJDQyVJCQkJiouL04IFCzR//nxJUkFBgWbPnq2HH35Yc+fOlSQlJyerrKxM06dP16RJk9SxY0cP7SEAAPBFTfXLho1Jo+/4xSFXkux2uzp27KjDhw87l507d05r167VPffc4wy5khQdHa3evXtr9erVzmUff/yxiouLNXLkSJftjhw5UoZhaM2aNfW/IwAAoNFpyl82bAwa/RHd6pw6dUrbt293OZqbk5Ojs2fPqmvXrlXmd+3aVevWrVNxcbGCgoK0a9cuSVKXLl1c5l199dWKiIhwjtfk+PHjysvLc1mWnZ0tSXI4HDp9+nSt9ssTioqKXP5EzeiVe+iXefTKPHplHr0yz91e/XFInF6PCtbftn2j/KIy5/LWIQH6ZUIbjUy6VmeLHDrbINV6lydfVw6Hw+11LBl0x40bp6KiIk2bNs25rKCgQJIUHh5eZX54eLgMw1BhYaGuvvpqFRQUKDAwUCEhIdXOrdxWTRYtWqS0tLRqx7KysnTs2DF3dscrsrKyvF1Co0Gv3EO/zKNX5tEr8+iVee70Kk7SE52lA2ds+v6c1KKZdP0V5+RflqN/b7L+zSI88bo6dOiQ2+v4VNDNyMhQ7969Tc394osv1L179yrLn3zySb3xxht66aWXqr3qgs1W8/1pLhwzO686qampGjZsmMuy7OxspaSkKDExUR06dLjk+t5UVFSkrKwsJSYmVhv08QN65R76ZR69Mo9emUevzKNX5nmyV7t373Z7HZ8KujfccIP+8pe/mJr7ox/9qMqytLQ0zZ49W3PmzNGjjz7qMta69flvuVZ3NPbEiROy2WwKCwtzzi0uLtb333+vFi1aVJlbXYC+UFRUVLXnDkvnzx++8BxhXxUSEtIo6vQF9Mo99Ms8emUevTKPXplHr8zzRK/sdrvb6/hU0L366qv10EMP1WrdtLQ0zZo1S7NmzdITTzxRZTw2NlbBwcHauXNnlbGdO3eqXbt2CgoKkvTDubk7d+7UzTff7Jx37Ngx5efnq3PnzrWqEQAAAJ7T6K+6IElPP/20Zs2apenTp2vmzJnVzmnWrJkGDx6sd999V2fOnHEuP3TokDZu3KihQ4c6lw0cOFBBQUFKT0932UZ6erpsNptSUlIaYjcAAABQj3zqiG5tPPvss5oxY4YGDhyoO++8U59//rnLeK9evZz/nZaWpp49e+quu+7S1KlTnTeMiIiI0OTJk53zwsPDNX36dD355JMKDw933jBi1qxZeuihh7iGLgAAQCPQ6IPu+++/L+n8tW8//vjjKuOG8cO9SuLj45WRkaHHH39cP//5z11uAXzhXdEkadq0abriiiu0cOFCLViwQFdddZWmTp3qciUHAAAA+K5GH3QzMjLcmp+QkKD169ebmjthwgRNmDChFlUBAABYW1l5hbYcPKn/FdhkP3hSt3W0+9zd3xp90AUAAIDnlJVXaHFGjpZn5irfUSrJX6/t26lI+z4NT4rW2ORYnwm8BF0AAACYUlZeod8s36qNe/Oq3PI431Gi59bt047DJ7VkeIJPhF3vVwAAAIBGYXFGjjbuzZMkGReNVT7esOe4Xs7wjbvBEXQBAABwWWXlFVqemVvlSO7FbJKWZx5UWXmFJ8q6JIIuAAAALmtrbqHyHaVVjuRezJCU5yjR1txCT5R1SQRdAAAAXNaps6UNOr8hEHQBAABwWS2Dmzfo/IZA0AUAAMBl9YhppQh7c1Pn6EbaA9UjppUnyrokgi4AAAAuK8DfTyOSYkydozsiKZrLiwEAAKDxGJscqz7xUZJU5chu5eM+8VEakxzr0bpqQtAFAACAKQH+floyPEGT+7dXhD3QZSzCHqjJ/dv7zM0iJO6MBgAAADcE+PtpfN84jUmO1aavjug/W3boJz2767aO1/pMwK1E0AUAAIDbAvz91DM6TI4DhnpGh/lcyJUIuh5TUlIiScrOzvZyJZfmcDh06NAh7d69W3a73dvl+DR65R76ZR69Mo9emUevzKNX5nmyV5UZqjJTmUHQ9ZDDhw9LklJSUrxbCAAAQCN2+PBh3XTTTabm2gzDuNxVIlAPTp48qc8++0xt27ZVYGDg5VfwkuzsbKWkpGjNmjVq166dt8vxafTKPfTLPHplHr0yj16ZR6/M82SvSkpKdPjwYd1+++0KCwsztQ5HdD0kLCxMQ4YM8XYZprVr106dOnXydhmNAr1yD/0yj16ZR6/Mo1fm0SvzPNUrs0dyK/neWcMAAABAPSDoAgAAwJIIugAAALAkgi5cREZGaubMmYqMjPR2KT6PXrmHfplHr8yjV+bRK/PolXm+3iuuugAAAABL4oguAAAALImgCwAAAEsi6AIAAMCSCLoAAACwJIKuBTkcDk2aNElt2rRRUFCQunfvrr/97W+XXe/dd9/Vfffdp3bt2ik4OFgxMTG6//77tX///ipzk5OTZbPZqvwMHDiwIXapwdS2V+np6dXuv81m07Fjx6rMX79+vZKSktSiRQtFRETowQcf1PHjxxtilxpMbXtV02ulun5Z5XV15swZTZkyRQMGDFBkZKRsNptmzZplev3jx4/rwQcfVEREhFq0aKGkpCR9+umn1c5t7K+tuvSqqb1n1aVXTfE9qy79akrvWxs2bNCoUaMUHx+vkJAQXXPNNRoyZIi2bdtman1ff7/iFsAWNHToUG3ZskXz5s1T+/bt9eabb+q+++5TRUWFfvWrX9W43vz583XVVVdp2rRpuv7663X48GHNnTtXN910kz7//PMqt/a7/vrr9cYbb7gsM3vvaV9R215Vev311xUfH++yrHXr1i6PP/vsMw0aNEh33nmn3nvvPR0/flyPP/64+vbtq61btyowMLBe96mh1LZXixYt0unTp12Wff/99xo4cKASEhJ01VVXuYxZ4XVVUFCgpUuXqlu3bkpJSdErr7xiet2SkhL17dtXJ0+e1IsvvqioqCgtXLhQAwcO1Pr163X77bc751rhtVWXXjW196y69KpSU3rPqku/mtL71uLFi1VQUKCJEyeqY8eOysvL07PPPqtevXrpk08+UZ8+fWpct1G8XxmwlA8++MCQZLz55psuy/v372+0adPGOHfuXI3rfvfdd1WWHT161AgICDBGjx7tsvz22283OnXqVD9Fe0ldevX6668bkowtW7Zc9nl69uxpdOzY0SgrK3Mu+89//mNIMhYtWlT7HfCguvSqOunp6YYk45VXXnFZboXXlWEYRkVFhVFRUWEYhmHk5eUZkoyZM2eaWnfhwoWGJGPz5s3OZWVlZUbHjh2NxMREl7lWeG3VpVdN7T2rLr1qau9ZhlG3flXHqu9b1f09OnPmjHHllVcaffv2veS6jeH9ilMXLGb16tWy2+0aNmyYy/KRI0fqm2++0X//+98a142KiqqyrE2bNrr22mt1+PDheq/V2+rSK7OOHj2qLVu2aPjw4WrW7IcPUH784x+rffv2Wr16dZ2fwxPqu1evvvqq7Ha7fvGLX9RnmT6j8qPL2li9erVuuOEGJSUlOZc1a9ZMDzzwgLKysnT06FFJ1nlt1aVXTe09qy69Mssqryup/vtl1fet6v4e2e12dezY8bJ/jxrD+xVB12J27dqlDh06uLyQJKlr167OcXccOHBABw8erPIRoCTl5OQoPDxczZo1U2xsrKZNm6azZ8/WvngPq49e3XXXXfL391d4eLiGDh1aZZ3Kx5XbvPh53P3/4S31+brav3+//vWvf+mXv/yl7HZ7lfHG/rqqq127dtX4epGkL7/80jnvwuUXz20sr636ZuX3rPrQVN6z6ltTe986deqUtm/fXu3fows1hvcrztG1mIKCAl1//fVVloeHhzvHzTp37pxGjx4tu92uxx57zGXslltu0S9+8QvFx8fr7Nmz+uijj/SHP/xB//73v7Vx40b5+fn+71B16VXleYG9evVSaGiodu7cqXnz5qlXr176z3/+o27durlso3KbFz+PO/8/vKk+X1evvvqqJGn06NFVxqzwuqqrgoKCGl8vleMX/tnYX1v1yervWXXR1N6z6ltTe98aN26cioqKNG3atEvOawzvVwRdC7rURzVmP8YxDEOjR4/Wv/71L73zzjtq27aty/js2bNdHt9xxx2KiYnR7373O7333nu6++673S/cC2rbq4EDB7p8o/a2227TnXfeqS5dumjGjBl67733TG2roT+GrE/18bo6d+6cli1bpk6dOqlXr15Vxq3yuqord3pthddWfWgq71m11RTfs+pLU3vfevLJJ/XGG2/opZdeUkJCwmXn+/r7VeP7NQOX1Lp162p/Mzpx4oSk6n+buphhGHrooYe0YsUKpaena8iQIaae+4EHHpAkff75525U7D310asLxcTE6JZbbnHZ/8pvM9f0PO4+h7fUV68+/PBDHTt2TA899JDp525sr6u6Mttrq7y26kNTec+qb1Z+z6pPTel9Ky0tTbNnz9acOXP06KOPXnZ+Y3i/IuhaTJcuXbR7926dO3fOZfnOnTslSZ07d77k+pX/YLz++ut65ZVXnH9Z3dFYPqapa6+qYxiGy/5XbqNymxc/T22ewxvqq1evvvqqmjdvruHDh7tdQ2N5XdVVly5dany9SD/02iqvrbpqSu9ZDcGq71n1qam8b6WlpWnWrFmaNWuWnnjiCVPrNIr3qwa7ngO84sMPPzQkGX/7299clg8cOPCyl4GqqKgwRo8ebdhsNmPp0qVuP/f8+fMNScaaNWvcXtcb6tKr6hw4cMCw2+1GSkqKy/LExESjc+fOLtvLzMw0JBmLFy+u/Q54UH306ttvvzWaNWtm3HvvvW49d2N7XV3M3csaLVq0yJBkfP75585lZWVlRqdOnYybb77ZZa4VXlsXcrdXTe0960L1cbksK79nXay2/Woq71tPPfWUIcmYPn26W+s1hvcrgq4F9e/f32jVqpWxdOlSY8OGDcbDDz9sSDJWrFjhnDNq1CjD39/fyM3NdS579NFHDUnGqFGjjMzMTJef7du3O+dt2rTJ+OlPf2q8/PLLxj//+U/jH//4hzF27FjD39/f6NOnj1FeXu7R/a2L2vaqb9++RlpamrF69Wrj008/NV544QWjTZs2xhVXXGHs3LnT5Tk2btxoNGvWzLj77ruNdevWGW+88YbRtm1bo3PnzkZxcbHH9rWuaturSvPmzTMkGf/85z+r3b6VXleGcf6Xg5UrVxqvvfaaIckYNmyYsXLlSmPlypVGUVGRYRjV96u4uNjo1KmT0bZtW+ONN94w1q1bZ9x9991Gs2bNjIyMDJfnsMprq7a9aorvWbXtVVN8zzKM2verUlN431qwYIEhyRg4cGCVv0eZmZnOeY31/Yqga0FnzpwxJkyYYFx11VVG8+bNja5duxpvvfWWy5xf//rXhiTj66+/di6Ljo42JFX7Ex0d7Zy3f/9+44477jCuueYaIzAw0AgKCjK6dOlizJkzp9G9Cda2V5MmTTI6duxoXHHFFUazZs2MNm3aGA888ICxd+/eap/nn//8p9GrVy8jKCjICA8PN0aMGFHtRbp9WW17Val9+/ZGTEyM8wLuF7PS68owLv33qbI/NfXr2LFjxogRI4zw8HAjKCjI6NWrl7Fu3bpqn8cKr63a9qopvmfVtldN8T3LMOr299Awmsb71u23315jjy784L+xvl/ZDMMw3D7fAQAAAPBxjecsaQAAAMANBF0AAABYEkEXAAAAlkTQBQAAgCURdAEAAGBJBF0AAABYEkEXAAAAlkTQBQAAgCURdAEAAGBJBF0AAABYEkEXAAAAlkTQBQAf8OGHH8pmszl//P39FR0drUcffVSnT592mVteXq6oqCg9//zzbq8LAE1JM28XAACQtm/fLkl655131KZNGxUXF2vlypVauHChHA6H0tPTnXM3bdqkvLw8DR061O11AaApsRmGYXi7CABo6oYOHapPPvlEZ86ckZ/fDx+2dezYUd99950KCgqcy8aNG6esrCxt2bLF7XUBoCnh1AUA8AHbtm1Tly5dXIKqJIWGhqqoqMj52DAMrV69Wvfcc4/b6wJAU0PQBQAvKygo0KFDh9StWzeX5Xl5edq1a5d69uzpXLZ582Z9++23zqDrzroA0NQQdAHAyyrPse3cubPOnTunoqIi/fe//1VKSopKSkr01FNPOeeuWrVKXbp0UVxcnFvrbtq0Sb169VLLli3VunVr9enTR19//bVLHQsXLtQNN9yg4OBgxcTEaNasWSovL3eOx8TE6N///neN+/HnP/9ZN954owICAjRr1qwq43l5ebrzzjsVEhKi9u3ba926dc6x5ORkBQUFyW63y263q0+fPm52EQCqIugCgJdt27ZNkjRhwgQFBATIbrerV69eKi0t1SeffKLevXs757777rtVTlu43LqnTp3SkCFDNGXKFBUWFurgwYMaP368/P39nduZPXu2nnnmGf3lL3/RmTNn9N5772nVqlUaM2aM6f245ppr9NRTTyklJaXa8XHjxumqq65SXl6eFixYoHvvvdfl/OFXXnlFDodDDodDGzZsMP28AFATrroAAF62fft2BQUFadOmTbLZbGrevLmuueYatW7d2mVeVlaWDh065BJ0zay7b98+BQYGOq/SYLfbdffddzvHT548qblz5+pvf/ubbrvtNklSt27dtGLFCt1000363e9+pxtuuOGy+1G5zffee6/KmMPh0Jo1a3TgwAG1aNFCP/vZz9StWze99957GjVqlBvdAgDzOKILAF62fft2de3aVT179lSPHj3UtWvXKiFXOn/5sPbt26tz585urdu+fXuVlpbqoYce0scff1zl2rqZmZkqKyvTnXfe6bK8e/fuio6OVkZGRp33cf/+/bLb7br22mudy7p06aIvv/zS+fixxx5TZGSk+vTp4zwlAwDqgqALAF506tQpHThwQAkJCZed+84777gczTW7bsuWLbVp0yaVlJTowQcfVGRkpB544AGdOXNG0vkvtEVERLicylDpyiuvVH5+vpt7VZXD4VBoaKjLstDQUDkcDknSH/7wB3399dc6dOiQ7rrrLg0aNEgnT56s8/MCaNoIugDgRdu3b5dhGJcNqzt27FBOTk6V0xbMrCud/7LaX//6Vx07dkybN2/W5s2bNWfOHElS69atlZ+f7/LFs0rfffedIiIi3Nyrqux2e5UjyadPn5bdbpckJSYmym63Kzg4WL/97W8VGRmpzZs31/l5ATRtBF0A8KLKj+hvuummS8575513FB0d7RJqza57sYSEBA0dOlS7du2SJCUlJSkgIEAffPCBy7wdO3bo4MGDSk5Odmv71YmLi5PD4dCRI0ecy3bt2qVOnTpVO//iawIDQG3wTgIAXjR58mQZhqEbb7zxkvMuPm3BnXX37Nmj559/Xt98842k819Oe//995WYmChJCgsL0xNPPKHU1FRt2rRJ586d0//3//1/euCBBzRq1CiXL6KVlpaquLjY+XPhUeBz5845l13439L5I7pDhgzRrFmzdPbsWa1du1Y7duzQz372M508eVLr1q1TSUmJSktL9ac//UnHjh1TUlKS+UYCQHUMAIClHTlyxPj5z39uXHXVVUaLFi2Mtm3bGo899phRUlLiMu+ll14y4uLijMDAQONHP/qRMXPmTKOsrMw5Hh0dbUhy+Xn99ded4zNnzrzk+PHjx41BgwYZwcHBRrt27YxPPvnEuTwhIcEICQkxWrVqZSQnJxtbtmxp0J4AaBpshmEY3ovZAAAAQMPg1AUAAABYEkEXAAAAlkTQBQAAgCURdAEAAGBJBF0AAABYEkEXAAAAlkTQBQAAgCURdAEAAGBJBF0AAABYEkEXAAAAlkTQBQAAgCURdAEAAGBJBF0AAABY0v8PuD2rAEcs9AcAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Set default dpi of figures\n", "plt.rcParams['figure.dpi'] = 120\n", "\n", "# Find path to f06 file and plot buckling load results\n", "f06_filepath = os.path.join(ANALYSIS_DIRECTORY_PATH, input_name + '.f06') # path to .f06 file\n", "plot_buckling_loads(f06_filepath, sol_106_op2, applied_load_magnitudes, sol_105_buckling_load)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We observe that while the results for $P/P_\\text{SOL 105}<1$ are unchanged with respect to the ones in [notebook 6](06_Verification_of_SOL_106_Nonlinear_Buckling_Method.ipynb#verification), the nonlinear buckling loads predicted for $P/P_\\text{SOL 105}\\geq 1$ are different. For $P/P_\\text{SOL 105}=1$, $P_\\text{SOL 106}$ is slightly smaller than $P_\\text{SOL 105}$, while it was slightly larger in our previous results. In fact, we see that $\\alpha$ is negative for such applied load, meaning that the nonlinear buckling method predicts that the critical buckling load has already been exceeded. The negative $\\alpha$ persists for all successive applied loads. In general we observe that the magnitude of $\\alpha$ is significatively smaller for $P/P_\\text{SOL 105}\\geq 1$, meaning that the nonlinear buckling method predicts other buckling loads that are closer to each applied load compared to the prediction for $P/P_\\text{SOL 105}<1$.\n", "\n", "At the same time we observe an increasing nonlinear buckling load for $P/P_\\text{SOL 105}\\geq 1$ with an evident linear trend, similarly to our previous results. However, do these buckling loads really exist? In other words, does the tangent stiffness matrix ever become singular along the equilibrium path of our box beam?\n", "\n", "As mentioned earlier, we have calculated the smallest magnitude eigevalue of the tangent stiffness matrix to verify the structural stability of our box beam. We are going to plot the lowest eigenvalue $\\lambda$ at each converged iteartion against the applied load and, for this purpose, we define the function `plot_tangent_stiffness_matrix_eigenvalues`. This takes as input the `OP2` object and the path to the f06 file, reads the load history and the eigenvalues of the tangent stiffness matrix and finally it plots the latter against the former." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def plot_tangent_stiffness_matrix_eigenvalues(op2_output, f06_path, linear_buckling_load):\n", " # Read load history from OP2 object\n", " _, applied_loads, _ = pynastran_utils.read_load_displacement_history_from_op2(op2_object=op2_output)\n", " load_history = np.concatenate([applied_loads[subcase_id][:, 2] for subcase_id in applied_loads]) # concatenate load along z from all subcases\n", " # Read lowest eigenvalues from f06 file\n", " lowest_eigenvalues = pynastran_utils.read_kllrh_lowest_eigenvalues_from_f06(f06_path) # read eigenvalues from f06 files\n", " # Plot lowest eigenvalues of tangent stiffness matrix vs load history\n", " _, ax = plt.subplots()\n", " ax.plot(load_history/linear_buckling_load, lowest_eigenvalues[0, :], 'o')\n", " plt.xlabel('$P/P_\\mathrm{SOL 105}$')\n", " plt.ylabel('$\\lambda$, N/mm')\n", " plt.grid()\n", " plt.show()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Let's plot the eigenvalues of the tangent stiffness matrix against the applied loads of our analysis." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_tangent_stiffness_matrix_eigenvalues(sol_106_op2, f06_filepath, sol_105_buckling_load)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We observe the same plot obtained in [notebook 6](06_Verification_of_SOL_106_Nonlinear_Buckling_Method.ipynb#tangent-stiffness-matrix), which confirms that the smallest magnitude eigenvalue of the tangent stiffness matrix is always positive for the range investigated loads. As a consequence, we can also confirm that our structure is always in a stable equilibrium.\n", "\n", "Furthemore, we can use this plot to intuitively explain why the nonlinear buckling method predicts a buckling load slightly smaller than $P_\\text{SOL 105}$ for $P/P_\\text{SOL 105}=1$. We need to remind that the nonlinear buckling method performs a linearization using the last two converged solutions of the subcase. If we look at the eigenvalues for $P/P_\\text{SOL 105}$ approaching $1$, we can observe that the curve has a negative slope. Intuitively, we can imagine that if we linearized the curve around $P/P_\\text{SOL 105}=1$ we would find that lowest eigenvalue would be zero for $P/P_\\text{SOL 105}<1$, corresponding to the result calculated by the nonlinear buckling method.\n", "\n", "Despite this nice and intuitive explanation, we need to remind that what happens in reality is not so simple. In fact, the nonlinear buckling method solves en eigenvalue problem to find where the tangent stiffness matrix becomes singular based on its linearization, which is different from linearizing the trend of one of its eigenvalues. As a consequence, it might not always be possible to find a correlation between the load calculated by the nonlinear buckling method and the trend of the smallest magnitude eigenvalue of the tangent stiffness matrix." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Box beam reinforced with ribs \n", "\n", "***\n", "\n", "We consider the same box beam reinforced with ribs analyzed in our [eighth notebook](08_Nonlinear_Buckling_Analysis_of_a_Box_Beam_Reinforced_with_Ribs.ipynb). In addition to the geometric and material properties defined earlier, we need to define the number of ribs and their location." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of ribs: 10\n", "Ribs' y-coordinate [mm]:\n", "[ 0. 500. 1000. 1500. 2000. 2500. 3000. 3500. 4000. 4500.]\n" ] } ], "source": [ "# Define ribs location\n", "ribs_spacing = w/2 # half of box beam's width\n", "no_ribs = int(np.ceil(l/ribs_spacing)) + 1 # calculate number of ribs\n", "ribs_y_locations = np.linspace(0, l, no_ribs) # calculate y-coordinates of the ribs\n", "np.set_printoptions(precision=0)\n", "print(f\"Number of ribs: {no_ribs:.0f}\")\n", "print(f\"Ribs\\' y-coordinate [mm]:\")\n", "print(ribs_y_locations)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Then we generate the mesh, create the base `BDF` object and apply the concetrated load at the tip, this time connecting the nodes on the edges of the tip rib to the master node at the center with a `RBE3` element." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "---BDF Statistics---\n", "SOL None\n", "\n", "bdf.spcs[1]: 1\n", " SPC1: 1\n", "\n", "bdf.params: 0\n", " PARAM : 1\n", "\n", "bdf.nodes: 0\n", " GRID : 4514\n", "\n", "bdf.elements: 0\n", " CQUAD4 : 4680\n", "\n", "bdf.properties: 0\n", " PSHELL : 1\n", "\n", "bdf.materials: 0\n", " MAT1 : 1\n", "\n", "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "subcase=0 already exists...skipping\n" ] }, { "data": { "text/plain": [ "4515" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Generate mesh\n", "shell_element_length = 59.9 # [mm]\n", "box_beam_mesh = box_beam_utils.mesh_box_beam_with_pyvista(ribs_y_coordinates=ribs_y_locations, width=w, height=h,\n", " element_length=shell_element_length)\n", "nodes_xyz_array = box_beam_mesh.points\n", "nodes_connectivity_matrix = box_beam_mesh.faces.reshape(-1, 5)[:, 1:]\n", "\n", "# Create base BDF object\n", "ribs_reinforced_box_beam_bdf = box_beam_utils.create_base_bdf_input(young_modulus=E, poisson_ratio=nu, density=rho,\n", " shell_thickness=t, nodes_xyz_array=nodes_xyz_array,\n", " nodes_connectivity_matrix=nodes_connectivity_matrix)\n", "print(ribs_reinforced_box_beam_bdf.get_bdf_stats())\n", "\n", "# Define function to apply concetrated load at the tip\n", "def apply_tip_concentrated_load(bdf_input):\n", " # Add master node at the center of the tip section\n", " master_node_id = len(bdf_input.nodes) + 1\n", " bdf_input.add_grid(master_node_id, [w/2, l, 0.])\n", " # Find id of the nodes on the edge of the tip rib\n", " tolerance = shell_element_length/100 # we define a geometric tolerance to find the nodes on the edge of the tip rib equal to 1/100 of elements' length\n", " tip_edge_nodes_ids = [nid for nid in bdf_input.nodes if (np.abs(bdf_input.nodes[nid].xyz[1] - l) < tolerance) &\n", " (np.abs((bdf_input.nodes[nid].xyz[0]) < tolerance) |\n", " (np.abs(bdf_input.nodes[nid].xyz[0] - w) < tolerance) |\n", " (np.abs(bdf_input.nodes[nid].xyz[2] - h/2) < tolerance) |\n", " (np.abs(bdf_input.nodes[nid].xyz[2] + h/2) < tolerance))]\n", " # Add RBE3 to connect master node with edge nodes of tip rib\n", " rbe3_eid = len(bdf_input.elements) + 1\n", " bdf_input.add_rbe3(eid=rbe3_eid, refgrid=master_node_id, refc='123456', weights=[1.]*len(tip_edge_nodes_ids),\n", " comps=['123456']*len(tip_edge_nodes_ids), Gijs=tip_edge_nodes_ids)\n", " # Add concentrated force\n", " force_direction = [0., 0., 1.]\n", " pynastran_utils.add_unitary_force(bdf_object=bdf_input, nodes_ids=[master_node_id], set_id=FORCE_SET_ID,\n", " direction_vector=force_direction)\n", " # Return id of master node\n", " return master_node_id\n", "\n", "# Apply load\n", "apply_tip_concentrated_load(ribs_reinforced_box_beam_bdf)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Similarly to what we did earlier, we recall the buckling load predicted by SOL 105 and we define 11 load magnitudes equally spaced between 0 and twice the linear buckling load. We discard the load case with null magnitude and we keep the other 10 load cases." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Applied loads [N]: [ 620. 1240. 1861. 2481. 3101. 3721. 4341. 4962. 5582. 6202.]\n" ] } ], "source": [ "sol_105_buckling_load = 3101. # [N]\n", "applied_load_magnitudes = np.linspace(0, 2*sol_105_buckling_load, 11)[1:]\n", "np.set_printoptions(precision=0, suppress=True)\n", "print(f'Applied loads [N]: {applied_load_magnitudes}')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Now we run the analysis calling the function `run_nonlinear_buckling_method_sweep` and plot the buckling loads, the critical buckling factors and the eigenvalues of the tangent stiffness matrix." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Nastran job ribs_reinforced_box_beam.bdf completed\n", "Wall time: 2189.0 s\n" ] }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Run analysis\n", "input_name = 'ribs_reinforced_box_beam'\n", "sol_106_op2 = run_nonlinear_buckling_method_sweep(ribs_reinforced_box_beam_bdf, applied_load_magnitudes, input_name,\n", " run_flag=False)\n", "\n", "# Find path to f06 file and plot buckling load results\n", "f06_filepath = os.path.join(ANALYSIS_DIRECTORY_PATH, input_name + '.f06') # path to .f06 file\n", "plot_buckling_loads(f06_filepath, sol_106_op2, applied_load_magnitudes, sol_105_buckling_load)\n", "\n", "# Plot lowest eigenvalues of tangent stiffness matrix vs load history\n", "plot_tangent_stiffness_matrix_eigenvalues(sol_106_op2, f06_filepath, sol_105_buckling_load)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Also in this case we observe that the nonlinear buckling method predicts the same buckling load as SOL 105 for $P/P_\\text{SOL 105}<1$, a slightly smaller buckling load than SOL 105 for $P/P_\\text{SOL 105}=1$ and finally increasing buckling loads for $P/P_\\text{SOL 105}>1$, again with a linear trend. The buckling factors are large and decreasing for $P/P_\\text{SOL 105}<1$ and then negative with a smaller magnitude for $P/P_\\text{SOL 105}\\geq 1$, except for the last factor. The smallest magnitude eigenvalue of the tangent stiffness matrix results in the same behavior as in our [previous notebook](08_Nonlinear_Buckling_Analysis_of_a_Box_Beam_Reinforced_with_Ribs.ipynb#nonlinear-buckling-method-verification): it is constant up to almost $P/P_\\text{SOL 105}=1$, it undergoes an abrupt drop, it recovers and then it gradually decreases again. However, the value is always positive, meaning that our box beam never encounters a critical point along its equilibrium path." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Box beam reinforced with ribs and stiffeners \n", "\n", "***\n", "\n", "Now we consider the same box beam reinforced with ribs and stiffeners analyzed in our [last notebook](12_Nonlinear_Buckling_Analysis_of_a_Box_Beam_Reinforced_with_Ribs_and_Stiffeners.ipynb). We define the number of stiffeners, their location and their height. Then we generate the mesh, create the base `BDF` object and we apply the concentrated tip load in the same way as done for the box beam reinforced with ribs only." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of stiffeners: 2\n", "Stiffeners x-coordinate [mm]:\n", "[333. 667.]\n", "Stiffeners height: 20 mm\n", "---BDF Statistics---\n", "SOL None\n", "\n", "bdf.spcs[1]: 1\n", " SPC1: 1\n", "\n", "bdf.params: 0\n", " PARAM : 1\n", "\n", "bdf.nodes: 0\n", " GRID : 8562\n", "\n", "bdf.elements: 0\n", " CQUAD4 : 8784\n", "\n", "bdf.properties: 0\n", " PSHELL : 1\n", "\n", "bdf.materials: 0\n", " MAT1 : 1\n", "\n", "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "subcase=0 already exists...skipping\n" ] }, { "data": { "text/plain": [ "8563" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Define location and height of stiffeners\n", "stiffeners_spacing = ribs_spacing/1.4\n", "no_stiffeners = int(np.ceil(w/stiffeners_spacing)) - 1\n", "stiffeners_x_locations = np.linspace(0, w, no_stiffeners + 2)[1:-1]\n", "stiffeners_height = h/10\n", "print(f\"Number of stiffeners: {no_stiffeners:d}\")\n", "print(f\"Stiffeners x-coordinate [mm]:\")\n", "print(stiffeners_x_locations)\n", "print(f\"Stiffeners height: {stiffeners_height:.0f} mm\")\n", "\n", "# Generate mesh\n", "shell_element_length = 47.0 # from previous mesh convergence study [mm]\n", "box_beam_mesh = box_beam_utils.mesh_stiffened_box_beam_with_pyvista(width=w, height=h, ribs_y_coordinates=ribs_y_locations,\n", " stiffeners_x_coordinates=stiffeners_x_locations,\n", " stiffeners_height=stiffeners_height,\n", " element_length=shell_element_length)\n", "nodes_xyz_array = box_beam_mesh.points\n", "nodes_connectivity_matrix = box_beam_mesh.faces.reshape(-1, 5)[:, 1:]\n", "\n", "# Create base BDF object\n", "ribs_stiffeners_reinforced_box_beam_bdf = box_beam_utils.create_base_bdf_input(young_modulus=E, poisson_ratio=nu,\n", " density=rho, shell_thickness=t,\n", " nodes_xyz_array=nodes_xyz_array,\n", " nodes_connectivity_matrix=nodes_connectivity_matrix)\n", "print(ribs_stiffeners_reinforced_box_beam_bdf.get_bdf_stats())\n", "\n", "# Apply load\n", "apply_tip_concentrated_load(ribs_stiffeners_reinforced_box_beam_bdf)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We recall the buckling load predicted by SOL 105, define the applied loads, run our analysis and produce our plots." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Applied loads [N]: [ 1685. 3370. 5054. 6739. 8424. 10109. 11794. 13478. 15163. 16848.]\n", "Nastran job ribs_stiffeners_reinforced_box_beam.bdf completed\n", "Wall time: 4765.0 s\n" ] }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "WARNING: subcase.py:683 nwords_to_lsem=1000 nwords_to_lsem//4=250\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Define applied loads\n", "sol_105_buckling_load = 8424. # [N]\n", "applied_load_magnitudes = np.linspace(0, 2*sol_105_buckling_load, 11)[1:]\n", "np.set_printoptions(precision=0, suppress=True)\n", "print(f'Applied loads [N]: {applied_load_magnitudes}')\n", "\n", "# Run analysis\n", "input_name = 'ribs_stiffeners_reinforced_box_beam'\n", "sol_106_op2 = run_nonlinear_buckling_method_sweep(ribs_stiffeners_reinforced_box_beam_bdf, applied_load_magnitudes,\n", " input_name, run_flag=True)\n", "\n", "# Find path to f06 file and plot buckling load results\n", "f06_filepath = os.path.join(ANALYSIS_DIRECTORY_PATH, input_name + '.f06') # path to .f06 file\n", "plot_buckling_loads(f06_filepath, sol_106_op2, applied_load_magnitudes, sol_105_buckling_load)\n", "\n", "# Plot lowest eigenvalues of tangent stiffness matrix vs load history\n", "plot_tangent_stiffness_matrix_eigenvalues(sol_106_op2, f06_filepath, sol_105_buckling_load)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Once again, we find that the nonlinear buckling method predicts the same buckling load as SOL 105 for $P/P_\\text{SOL 105}<1$, a slightly smaller buckling load than SOL 105 for $P/P_\\text{SOL 105}=1$ and finally increasing buckling loads for $P/P_\\text{SOL 105}>1$. This time the linear trend seems to be broken for the largest applied load. This result suggests that we should not always expect to find a relation between buckling loads and applied loads and that when we observe it, it is probably fortuitous.\n", "\n", "Similarly to the previous cases, the buckling factors are large and decreasing for $P/P_\\text{SOL 105}<1$ and negative with a smaller magnitude for $P/P_\\text{SOL 105}\\geq 1$, with the exception of the largest applied load that results in a positive critical buckling factor. This result suggests that the succession of the values of $\\alpha$ for $P/P_\\text{SOL 105}\\geq 1$ is case-dependent and that we should not expect to observe any repetitive behavior.\n", "\n", "Finally, the smallest magnitude eigenvalue of the tangent stiffness matrix is the same as in our [previous notebook](12_Nonlinear_Buckling_Analysis_of_a_Box_Beam_Reinforced_with_Ribs_and_Stiffeners.ipynb#nonlinear-buckling-method-verification): it is constant up to an applied load slightly lower than $P/P_\\text{SOL 105}=1$, it undergoes an abrupt decrease and finally the rate of decrease becomes more gradual around $P/P_\\text{SOL 105}=1.25$. The value never reaches 0 for the load range investigated here, meaning that also the box beam reinforced with ribs and stiffeners never encounters a critical or unstable point along its equilibrium path." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Conclusions \n", "\n", "***\n", "\n", "In this notebook we have explained a mistake that we did in our previous notebooks when applying the nonlinear buckling method and we have rerun the nonlinear buckling analysis for all the box beam configurations investigated so far. We found some small differences in the results of the nonlinear buckling method, which however did not change the validity of our hypothesis regarding the bifurcation break of our box beam. In fact, after the correction of our eigenvalue calculation settings, we have found the lowest eigenvalues of the tangent stiffness matrix to have the same trends as in our results, for all the box beam configurations. Namely, we always observed positive values of the lowest eigenvalue, meaning that the structure does never encounter a critical point along its equilibrium path, similarly to what happens along the natural path of the broken supercritical pitchfork of the imperfect Euler's column." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.17" } }, "nbformat": 4, "nbformat_minor": 0 }