{ "cells": [ { "cell_type": "markdown", "source": [ "# Intro & Import packages" ], "metadata": { "collapsed": false } }, { "cell_type": "markdown", "source": [ " Title: Simple 2D Beam Bridge Model in OpenSees with Moving Loads\n\n", " Author: Mohammad Talebi-Kalaleh, \n", " Research Assistant at University of Alberta, Structural Engineering\n\n", " Email: talebika@ualberta.ca\n\n", "\n" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 12, "outputs": [], "source": [ "import openseespy.opensees as ops\n", "import openseespy.postprocessing.ops_vis as opsv\n", "import numpy as np\n", "import matplotlib.pyplot as plt" ], "metadata": { "collapsed": false } }, { "cell_type": "markdown", "source": [ "# Update global plot settings" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 13, "outputs": [], "source": [ "plt.rcParams.update({\n", " 'font.size': 16,\n", " 'lines.linewidth': 2,\n", " 'figure.facecolor': 'white',\n", " 'savefig.facecolor': 'white',\n", " 'axes.facecolor': 'white', # White background behind the data\n", " 'axes.edgecolor': 'black', # Black border around axes\n", " 'axes.linewidth': 1.2, # Thickness of the black border\n", " 'axes.grid': True,\n", " 'grid.color': 'gray', # Gray grid lines\n", " 'grid.linestyle': '--', # Dashed grid lines\n", " 'grid.linewidth': 0.6, # Thinner grid lines\n", "})" ], "metadata": { "collapsed": false } }, { "cell_type": "markdown", "source": [ "# Utility Functions" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 14, "outputs": [], "source": [ "def build_bridge_model(bridge_length,\n", " support_positions,\n", " E,\n", " rho,\n", " A,\n", " I,\n", " damping_ratio,\n", " mesh_size=0.5):\n", " \"\"\"\n", " Constructs a 2D beam bridge (3 DOFs per node) in OpenSees using\n", " elasticBeamColumn elements. Assigns boundary conditions, mass, and\n", " Rayleigh damping based on the first two modes.\n", "\n", " Parameters\n", " ----------\n", " bridge_length : float\n", " Total bridge length in meters.\n", " support_positions : list of float\n", " Positions of interior supports along the bridge (m from left end).\n", " E : float\n", " Elastic (Young's) Modulus in Pa.\n", " rho : float\n", " Material density (kg/m^3).\n", " A : list[float] or float\n", " Cross-sectional area(s) [m^2]. If uniform, pass one value; for multiple\n", " spans with different sections, pass one A per span.\n", " I : list[float] or float\n", " Second moment(s) of area [m^4]. Same indexing as A.\n", " damping_ratio : float\n", " Desired damping ratio for the first two modes (Rayleigh).\n", " mesh_size : float\n", " Element length for discretization (m).\n", "\n", " Returns\n", " -------\n", " dict\n", " A dictionary with keys:\n", " - 'all_node_tags': list of int (node tags)\n", " - 'all_node_positions': list of float (x-coords)\n", " - 'span_element_tags': list of lists of element tags\n", " - 'support_node_tags': node tags of supports\n", " - 'omega': [omega1, omega2]\n", " \"\"\"\n", " # Clear any existing OpenSees model\n", " ops.wipe()\n", "\n", " # Define a 2D model with 3 dofs/node\n", " ops.model('BasicBuilder', '-ndm', 2, '-ndf', 3)\n", "\n", " # Ensure 0 and bridge_length are included in supports\n", " all_support_positions = sorted(set([0.0] + support_positions + [bridge_length]))\n", "\n", " current_node_tag = 1\n", " span_node_tags = []\n", " all_node_positions = []\n", "\n", " # Mesh each span according to mesh_size\n", " for i in range(len(all_support_positions) - 1):\n", " span_start = all_support_positions[i]\n", " span_end = all_support_positions[i+1]\n", " span_length = span_end - span_start\n", " n_seg = int(np.ceil(span_length / mesh_size))\n", " dx = span_length / n_seg\n", " this_span_nodes = []\n", "\n", " for j in range(n_seg + 1):\n", " xcoord = span_start + j * dx\n", " if i == 0:\n", " current_node_tag += 1\n", " ops.node(current_node_tag, xcoord, 0.0)\n", " all_node_positions.append(xcoord)\n", " else:\n", " if j != 0:\n", " current_node_tag += 1\n", " ops.node(current_node_tag, xcoord, 0.0)\n", " all_node_positions.append(xcoord)\n", "\n", " this_span_nodes.append(current_node_tag)\n", " span_node_tags.append(this_span_nodes)\n", "\n", " all_node_tags = [tag for span_nodes in span_node_tags for tag in span_nodes]\n", " all_node_tags = list(set(all_node_tags)) # pick unique node names\n", " number_of_nodes = len(all_node_tags)\n", "\n", " # Assign boundary conditions (hinge at first support, roller at others)\n", " support_node_tags = []\n", " for sPosIdx, sPos in enumerate(all_support_positions):\n", " # find the node in all_node_positions closest to sPos\n", " idx = np.argmin(np.abs(np.array(all_node_positions) - sPos))\n", " support_node_tag = all_node_tags[idx]\n", " support_node_tags.append(support_node_tag)\n", " if sPosIdx == 0:\n", " # Hinge\n", " ops.fix(support_node_tag, 1, 1, 0)\n", " else:\n", " # Roller in x-direction\n", " ops.fix(support_node_tag, 0, 1, 0)\n", "\n", " # Beam transformation\n", " transf_tag = 1\n", " ops.geomTransf('Linear', transf_tag)\n", "\n", " # If A or I are single values, replicate them across all spans\n", " n_spans = len(all_support_positions) - 1\n", " if len(A) == 1:\n", " A = A * n_spans\n", " if len(I) == 1:\n", " I = I * n_spans\n", "\n", " # Create elements for each span\n", " current_element_tag = 1\n", " span_element_tags = []\n", " for i, span_nodes in enumerate(span_node_tags):\n", " Ei = E\n", " Ai = A[i]\n", " Ii = I[i]\n", "\n", " this_span_elems = []\n", " for j in range(len(span_nodes) - 1):\n", " nd_i = span_nodes[j]\n", " nd_j = span_nodes[j + 1]\n", " ops.element('elasticBeamColumn',\n", " current_element_tag,\n", " nd_i,\n", " nd_j,\n", " Ai,\n", " Ei,\n", " Ii,\n", " transf_tag)\n", " this_span_elems.append(current_element_tag)\n", " current_element_tag += 1\n", "\n", " span_element_tags.append(this_span_elems)\n", "\n", " # Assign nodal mass (distribute half to each element end)\n", " for i, span_nodes in enumerate(span_node_tags):\n", " linear_mass_i = rho * A[i] # linear mass (kg/m)\n", " for j in range(len(span_nodes) - 1):\n", " nd_i = span_nodes[j]\n", " nd_j = span_nodes[j + 1]\n", " xi = ops.nodeCoord(nd_i)[0]\n", " xj = ops.nodeCoord(nd_j)[0]\n", " le = xj - xi\n", " # half of the mass to node i, half to node j\n", " ops.mass(nd_i, 0.0, ops.nodeMass(nd_i)[1] + 0.5 * linear_mass_i * le, 0.0)\n", " ops.mass(nd_j, 0.0, ops.nodeMass(nd_j)[1] + 0.5 * linear_mass_i * le, 0.0)\n", "\n", " # Eigen analysis for first 2 modes\n", " num_modes = 2\n", " eigenvals = ops.eigen(num_modes)\n", " omega_list = np.sqrt(eigenvals)\n", " # Plot mode shapes (optional)\n", " for i, omega in enumerate(omega_list):\n", " opsv.plot_mode_shape(i+1)\n", " plt.title(f'Mode {i+1}, $f_{i+1}$={round(omega/(2*np.pi), 2)} Hz')\n", " plt.xlim([min(all_support_positions), max(all_support_positions)])\n", " plt.show()\n", "\n", " # Return dictionary with metadata for future usage\n", " bridge_dict = {\n", " 'all_node_tags': all_node_tags,\n", " 'all_node_positions': all_node_positions,\n", " 'span_node_tags': span_node_tags,\n", " 'span_element_tags': span_element_tags,\n", " 'all_support_positions': all_support_positions,\n", " 'support_node_tags': support_node_tags,\n", " 'number_of_nodes': number_of_nodes,\n", " 'omega': omega_list,\n", " 'damping_ratio': damping_ratio\n", " }\n", " return bridge_dict\n", "\n", "def interpolate_position_at_time(t, time_position_table):\n", " \"\"\"\n", " Interpolate the trailing axle position at time 't' using np.interp.\n", " If t < t_min, returns x_min; if t > t_max, returns x_max.\n", " \"\"\"\n", " # Extract separate arrays for times and positions\n", " times = np.array([row[0] for row in time_position_table])\n", " positions = np.array([row[1] for row in time_position_table])\n", "\n", " # Use np.interp for linear interpolation\n", " x_t = np.interp(t, times, positions)\n", " return x_t\n", "\n", "def get_nodal_forces_for_all_times(time_steps,\n", " trailing_axle_path,\n", " vehicle_config,\n", " node_tags,\n", " node_positions):\n", " \"\"\"\n", " Pre-compute the full time history of vertical load at each node due to\n", " a vehicle whose trailing axle position is given by 'trailing_axle_path',\n", " and whose axle loads/distances are given in 'vehicle_config'.\n", "\n", " vehicle_config = {\n", " 'loads': [axle1_load, axle2_load, ...],\n", " 'distances': [0.0, dist2, dist3, ...]\n", " }\n", "\n", " Parameters:\n", " -----------\n", " time_steps : np.array\n", " Array of times (s).\n", " trailing_axle_path: list of [time, position]\n", " The (time, x-position) history of the trailing axle.\n", " vehicle_config : dict\n", " 'loads' -> list of axle load magnitudes (N),\n", " 'distances' -> list of distances from trailing axle (m).\n", " node_tags : list of int\n", " Node tags in order along the bridge.\n", " node_positions : list of float\n", " x-coordinates of the node_tags (same order).\n", "\n", " Returns:\n", " --------\n", " node_load_history : dict\n", " key=node_tag, value = array of shape (len(time_steps),)\n", " containing the downward load for that node.\n", " \"\"\"\n", "\n", " axle_loads = vehicle_config['loads']\n", " axle_distances = vehicle_config['distances']\n", " n_axles = len(axle_loads) # number of axles\n", "\n", " node_load_history = {nd: np.zeros(len(time_steps)) for nd in node_tags}\n", "\n", " for it, t in enumerate(time_steps):\n", " # Trailing axle position by interpolation\n", " trailing_pos = interpolate_position_at_time(t, trailing_axle_path)\n", "\n", " # For each axle, compute x-position\n", " for ax_idx in range(n_axles):\n", " x_axle = trailing_pos + axle_distances[ax_idx]\n", " load_val = axle_loads[ax_idx]\n", "\n", " # Skip if off the bridge\n", " if x_axle < min(node_positions) or x_axle > max(node_positions):\n", " continue\n", "\n", " # Find segment to do linear interpolation\n", " for iSeg in range(len(node_positions) - 1):\n", " x_i = node_positions[iSeg]\n", " x_j = node_positions[iSeg + 1]\n", " nd_i = node_tags[iSeg]\n", " nd_j = node_tags[iSeg + 1]\n", "\n", " if x_i <= x_axle <= x_j:\n", " seg_length = x_j - x_i\n", " if seg_length < 1e-12:\n", " node_load_history[nd_i][it] += load_val\n", " else:\n", " r = (x_axle - x_i)/seg_length\n", " node_load_history[nd_i][it] += load_val*(1.0 - r)\n", " node_load_history[nd_j][it] += load_val*r\n", " break\n", "\n", " return node_load_history\n", "\n", "def run_dynamic_analysis_with_path_ts(bridge_dict,\n", " trailing_axle_path,\n", " vehicle_config,\n", " dt):\n", " \"\"\"\n", " Constructs Path TimeSeries for each node, capturing the node's\n", " time-varying load. Then performs a transient analysis step-by-step\n", " to collect nodal/element responses at each time step.\n", "\n", " Parameters\n", " ----------\n", " bridge_dict : dict\n", " Output of build_bridge_model(...).\n", " trailing_axle_path : list of [time, position]\n", " Time-position history for the trailing axle.\n", " vehicle_config : dict\n", " 'loads': [...], 'distances': [...]\n", " dt : float\n", " Time step (s).\n", "\n", " Returns\n", " -------\n", " results : dict\n", " Contains time array, midspan disp/vel/acc, shear/moment over time,\n", " and envelope values.\n", " \"\"\"\n", "\n", " node_tags = bridge_dict['all_node_tags']\n", " node_positions = bridge_dict['all_node_positions']\n", " span_element_tags = bridge_dict['span_element_tags']\n", " all_support_positions = bridge_dict['all_support_positions']\n", " omega1, omega2 = bridge_dict['omega'][:2]\n", " damping_ratio = bridge_dict['damping_ratio']\n", "\n", " # Determine overall startTime and endTime from trailing_axle_path\n", " trailing_axle_path = sorted(trailing_axle_path, key=lambda row: row[0])\n", " start_time = trailing_axle_path[0][0]\n", " end_time = trailing_axle_path[-1][0]\n", " total_time = end_time - start_time\n", "\n", " nSteps = int(np.ceil(total_time/dt)) + 1 if total_time > 1e-12 else 2\n", " time_steps = np.linspace(start_time, end_time, nSteps)\n", "\n", " # Build nodal load history\n", " node_load_history = get_nodal_forces_for_all_times(\n", " time_steps, trailing_axle_path, vehicle_config,\n", " node_tags, node_positions\n", " )\n", "\n", " # Create Path TimeSeries & Patterns\n", " for nd in node_tags:\n", " ts_tag = 1000 + nd\n", " # We can use the entire time_steps array\n", " # For the load values, we supply node_load_history[nd].\n", " # We'll ensure after the last time, we hold the last load => -useLast\n", " ops.timeSeries('Path', ts_tag,\n", " '-time', *time_steps,\n", " '-values', *node_load_history[nd],\n", " '-factor', 1.0,\n", " '-useLast', # hold last value after final time\n", " '-prependZero' # ensure starts at 0 at time=0\n", " )\n", "\n", " pat_tag = 2000 + nd\n", " ops.pattern('Plain', pat_tag, ts_tag)\n", " # y-dof is 2 in 2D => (Fx, Fy, Mz) => (0, -1, 0) for scale\n", " ops.load(nd, 0.0, -1.0, 0.0)\n", "\n", " # Rayleigh damping\n", " alphaM = damping_ratio * (2.*omega1*omega2)/(omega1+omega2)\n", " betaKcomm = 2.*damping_ratio/(omega1+omega2)\n", " ops.rayleigh(alphaM, 0., 0., betaKcomm)\n", "\n", " # Analysis configuration\n", " start_time = time_steps[0]\n", " ops.constraints('Transformation')\n", " ops.numberer('Plain')\n", " ops.system('BandGeneral')\n", " ops.algorithm('Linear')\n", " ops.integrator('Newmark', 0.5, 0.25)\n", " ops.analysis('Transient')\n", " ops.setTime(time_steps[0])\n", "\n", " # Identify first midspan node (or other node) for response tracking\n", " midspan_x = 0.5*(all_support_positions[0] + all_support_positions[1])\n", " idx_mid = np.argmin(np.abs(np.array(node_positions) - midspan_x))\n", " mid_node_tag = node_tags[idx_mid]\n", "\n", " # Lists to store time, disp, vel, acc\n", " time_list = []\n", " disp_list = []\n", " vel_list = []\n", " acc_list = []\n", "\n", " # Track shear & moment time histories\n", " shear_records = []\n", " moment_records = []\n", " all_element_tags = [e for span_elems in span_element_tags for e in span_elems]\n", " # Step-by-step analysis\n", " for iStep in range(nSteps):\n", " # The current step time\n", " current_time = start_time + iStep*dt\n", " # We let OpenSees do the time integration of dt\n", " # but we might check if there's a tiny rounding\n", " ops.setTime(current_time)\n", "\n", " ok = ops.analyze(1, dt)\n", " if ok != 0:\n", " print(f\"Analysis failed at step {iStep} (time ~ {ops.getTime():.4f}).\")\n", " break\n", "\n", " # Record time & midspan\n", " tNow = ops.getTime()\n", " time_list.append(tNow)\n", " disp_list.append(ops.nodeDisp(mid_node_tag, 2))\n", " vel_list.append(ops.nodeVel(mid_node_tag, 2))\n", " acc_list.append(ops.nodeAccel(mid_node_tag, 2))\n", "\n", " # Shear & moment in each element (i-end)\n", " # eleForce => [Fx_i, Fz_i, My_i, Fx_j, Fz_j, My_j]\n", " shear_this = []\n", " moment_this= []\n", " for ele in all_element_tags:\n", " f = ops.eleForce(ele)\n", " shear_i = f[1]\n", " moment_i = f[2]\n", " shear_this.append(shear_i)\n", " moment_this.append(moment_i)\n", " shear_records.append(shear_this)\n", " moment_records.append(moment_this)\n", "\n", " # Convert to arrays\n", " time_array = np.array(time_list)\n", " disp_array = np.array(disp_list)\n", " vel_array = np.array(vel_list)\n", " acc_array = np.array(acc_list)\n", "\n", " shear_time_history = np.array(shear_records)\n", " moment_time_history = np.array(moment_records)\n", "\n", " # Envelope\n", " shear_envelope_max = np.max(shear_time_history, axis=0)\n", " shear_envelope_min = np.min(shear_time_history, axis=0)\n", " moment_envelope_max = np.max(moment_time_history, axis=0)\n", " moment_envelope_min = np.min(moment_time_history, axis=0)\n", "\n", " results = {\n", " 'time': time_array,\n", " 'midspan_disp': disp_array,\n", " 'midspan_vel': vel_array,\n", " 'midspan_acc': acc_array,\n", " 'shear_time_history': shear_time_history,\n", " 'moment_time_history': moment_time_history,\n", " 'shear_envelope_max': shear_envelope_max,\n", " 'shear_envelope_min': shear_envelope_min,\n", " 'moment_envelope_max': moment_envelope_max,\n", " 'moment_envelope_min': moment_envelope_min,\n", " 'element_tags': all_element_tags\n", " }\n", "\n", " return results\n", "\n", "def post_process_and_plot(results_dict):\n", " \"\"\"\n", " Simple post-processing:\n", " - Plots midspan displacement, velocity, acceleration vs. time.\n", " - Plots shear & moment envelope diagrams.\n", " \"\"\"\n", " t = results_dict['time']\n", " disp= results_dict['midspan_disp']\n", " vel = results_dict['midspan_vel']\n", " acc = results_dict['midspan_acc']\n", "\n", " fig, axs = plt.subplots(3,1, figsize=(9,10), sharex=True)\n", " axs[0].plot(t, 1000*disp, 'b-', label='Midspan Disp (mm)')\n", " axs[0].legend()\n", " axs[0].set_xlim([min(t), max(t)])\n", "\n", " axs[1].plot(t, 1000*vel, 'r-', label='Midspan Vel (mm/s)')\n", " axs[1].legend()\n", " axs[1].set_xlim([min(t), max(t)])\n", "\n", " axs[2].plot(t, acc/9.81, 'g-', label='Midspan Acc (g)')\n", " axs[2].legend()\n", " axs[2].set_xlim([min(t), max(t)])\n", " axs[2].set_xlabel('Time (s)')\n", "\n", " plt.suptitle('Midspan Response Time Histories')\n", " plt.tight_layout()\n", " plt.show()\n", "\n", " # Envelope\n", " shear_max = results_dict['shear_envelope_max']\n", " shear_min = results_dict['shear_envelope_min']\n", " moment_max = results_dict['moment_envelope_max']\n", " moment_min = results_dict['moment_envelope_min']\n", " elem_tags = results_dict['element_tags']\n", "\n", " x_elem = []\n", " for et in elem_tags:\n", " nd_i, nd_j = ops.eleNodes(et)\n", " xi = ops.nodeCoord(nd_i)[0]\n", " x_elem.append(xi)\n", " x_elem = np.array(x_elem)\n", "\n", " sort_idx = np.argsort(x_elem)\n", " x_sorted = x_elem[sort_idx]\n", " sh_max_sorted = shear_max[sort_idx] / 1000.0\n", " sh_min_sorted = shear_min[sort_idx] / 1000.0\n", " m_max_sorted = moment_max[sort_idx] / 1000.0\n", " m_min_sorted = moment_min[sort_idx] / 1000.0\n", "\n", " fig2, ax2 = plt.subplots(2,1, figsize=(9,8), sharex=True)\n", " ax2[0].plot(x_sorted, sh_max_sorted, 'r-', label='V max')\n", " ax2[0].plot(x_sorted, sh_min_sorted, 'b-', label='V min')\n", " ax2[0].set_ylabel('Shear (kN)')\n", " ax2[0].legend()\n", " ax2[0].set_xlim([min(x_sorted), max(x_sorted)])\n", "\n", " ax2[1].plot(x_sorted, m_max_sorted, 'r-', label='M max')\n", " ax2[1].plot(x_sorted, m_min_sorted, 'b-', label='M min')\n", " ax2[1].set_xlabel('Position (m)')\n", " ax2[1].set_ylabel('Moment (kN.m)')\n", " ax2[1].legend()\n", " ax2[1].set_xlim([min(x_sorted), max(x_sorted)])\n", "\n", " plt.suptitle('Shear & Moment Envelope Diagrams')\n", " plt.tight_layout()\n", " plt.show()" ], "metadata": { "collapsed": false } }, { "cell_type": "markdown", "source": [ "# Main (example)\n", "Example usage:\n", " 1) Build a 90 m bridge with interior supports at 30, 60 => three 30 m spans.\n", " 2) Vehicle with 3 axles (20 kN each), 3 m apart.\n", " 3) Trailing axle from x=0 at t=0 to x=bridge_length at t=(bridge_length/speed).\n", " 4) Use np.interp for trailing axle position interpolation.\n", " 5) Step-by-step analysis, plot results." ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 15, "outputs": [ { "data": { "text/plain": "
", "image/png": "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" }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": "
", "image/png": "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" }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": "
", "image/png": "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" }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": "
", "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# 1) Bridge geometry & properties\n", "bridge_length = 90.0\n", "support_positions = [30, 60] # interior support => three spans of 30m\n", "E = 20.0e9 # Pa\n", "rho = 2500.0 # kg/m^3\n", "A = [3 * 1.5] # cross-sectional area (m^2)\n", "I = [1/12 * 3 * 1.5**3] # second moment of area (m^4)\n", "damping_ratio = 0.005\n", "mesh_size = 0.5\n", "\n", "# Build the bridge model\n", "bridge_dict = build_bridge_model(\n", " bridge_length,\n", " support_positions,\n", " E,\n", " rho,\n", " A,\n", " I,\n", " damping_ratio,\n", " mesh_size\n", ")\n", "\n", "# 2) Define a vehicle configuration dict\n", "# 3 axles, each 20kN, second axle 3m and the third one 6m ahead of the trailing load, respectively\n", "vehicle_config = {\n", " 'loads': [20000.0, 20000.0, 20000.0], # N\n", " 'distances': [0.0, 3.0, 6.0] # m\n", "}\n", "\n", "# 3) Trailing axle path: from (t=0, x=0) to (t=end, x=bridge_length)\n", "speed = 15 # m/s # if you need to perform static analysis (for influence line or etc.) put speed a very small number\n", "trailing_axle_path = [\n", " [0.0, 0.0],\n", " [bridge_length/speed, bridge_length]\n", "]\n", "# 4) Run dynamic analysis\n", "dt = 0.01 # analysis time steps\n", "results_dict = run_dynamic_analysis_with_path_ts(\n", " bridge_dict,\n", " trailing_axle_path,\n", " vehicle_config,\n", " dt\n", ")\n", "\n", "# 5) Post-process & plot\n", "post_process_and_plot(results_dict)\n", "\n", "# 6) Clean up\n", "ops.wipe()" ], "metadata": { "collapsed": false } } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.6" } }, "nbformat": 4, "nbformat_minor": 0 }