diff --git a/ME_2016/mini_project_2/.ipynb_checkpoints/direct-checkpoint.ipynb b/ME_2016/mini_project_2/.ipynb_checkpoints/direct-checkpoint.ipynb new file mode 100644 index 0000000..208de3a --- /dev/null +++ b/ME_2016/mini_project_2/.ipynb_checkpoints/direct-checkpoint.ipynb @@ -0,0 +1,154 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "bb0a3f4e-6f1a-459c-b7af-df7d82b82a97", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import sympy as sm\n", + "from scipy.optimize import fsolve\n", + "from scipy.integrate import quad\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "8504b0c4-befd-4b9e-8c32-dfb65a82a831", + "metadata": {}, + "outputs": [], + "source": [ + "f_pprime, f_prime, f = sm.symbols('f\\'\\', f\\', f')\n", + "v_prime, v = sm.symbols('v\\', v')\n", + "u_prime, u = sm.symbols('u\\', u')\n", + "epsilon, lambduh, alpha_1, mu, alpha_2, g = sm.symbols('epsilon, lambda, alpha_1, mu, alpha_2, g')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "9301e042-edff-4579-b00b-53d2a6162e6f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\epsilon^{2} f' \\lambda + f + f'' = \\epsilon v'$" + ], + "text/plain": [ + "Eq(epsilon**2*f'*lambda + f + f'', epsilon*v')" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nine_a = sm.Eq(f_pprime+epsilon**2 *lambduh*f_prime + f, epsilon*v_prime)\n", + "nine_a" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "3710753d-59ca-42c3-8791-15b02f317001", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\alpha_{1} v - u' + v' = - \\epsilon f$" + ], + "text/plain": [ + "Eq(alpha_1*v - u' + v', -epsilon*f)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nine_b = sm.Eq((v_prime-u_prime) + alpha_1*v, -epsilon*f)\n", + "nine_b" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "a6796232-a2c0-40e5-8190-5a2c64bdb50d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\alpha_{2} u - \\mu \\left(- u' + v'\\right) + u' = g$" + ], + "text/plain": [ + "Eq(alpha_2*u - mu*(-u' + v') + u', g)" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nine_c = sm.Eq(-mu*(v_prime-u_prime) + u_prime + alpha_2*u, g)\n", + "nine_c" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "a100efcd-77d8-4d9b-a1a3-277c318549b0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{f'': -alpha_1*epsilon*mu*v - alpha_1*epsilon*v - alpha_2*epsilon*u - epsilon**2*f*mu - epsilon**2*f - epsilon**2*f'*lambda + epsilon*g - f,\n", + " u': -alpha_1*mu*v - alpha_2*u - epsilon*f*mu + g,\n", + " v': -alpha_1*mu*v - alpha_1*v - alpha_2*u - epsilon*f*mu - epsilon*f + g}" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Solve the system of equations\n", + "solutions = sm.solve([nine_a, nine_b, nine_c], (v_prime, u_prime, f_pprime))\n", + "\n", + "# Display the solutions\n", + "solutions" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ME_2016/mini_project_2/.ipynb_checkpoints/main-checkpoint.py b/ME_2016/mini_project_2/.ipynb_checkpoints/main-checkpoint.py new file mode 100644 index 0000000..79c0512 --- /dev/null +++ b/ME_2016/mini_project_2/.ipynb_checkpoints/main-checkpoint.py @@ -0,0 +1,203 @@ +import numpy as np +from scipy.optimize import fsolve +from scipy.integrate import quad +import matplotlib.pyplot as plt + +# Persistent storage for fsolve initial conditions +nsolve_ics_storage = {'nsolve_ics': None} + +# Helper functions for g1, g1timescos, and g1timessin +def g1(phi0, x, params): + """ + Purpose of the function: + Computes the transistor's nondimensionalized function `g1`, which represents + the piecewise relationship between input and output voltages. + + Inputs: + 1. phi0 (float or array-like): Phase angle(s) at which the function is evaluated. + 2. x (array-like): Fourier coefficients [U, G, H, X, Y]. + 3. params (dict): Dictionary containing nondimensional parameters: + - ep, gamma, u0. + + Outputs: + 1. g1out (array-like): The value of the `g1` function at the input phase angles. + + Notes: + - Implements piecewise behavior for the `g1` function based on the conditional + `ep * v1mu1 >= u0 - 1`. + - This is based on equations 28 and 34 in the referenced model. + """ + + U, V, G, H, X, Y = x[0], 0, x[1], x[2], x[3], x[4] + ep = params['ep'] + gamma = params['gamma'] + u0 = params['u0'] + + # Equation 34 + v1mu1 = (V - U) + (G - X) * np.cos(phi0) + (H - Y) * np.sin(phi0) + + # Equation 28 + cond = ep * v1mu1 >= u0 - 1 + g1out = np.where( + cond, + gamma * v1mu1 * (2 * (1 - u0) + ep * v1mu1), + -gamma / ep * (1 - u0)**2 + ) + return g1out + +def g1timescos(phi0, x, params): + """Compute g1(phi0) * cos(phi0).""" + return g1(phi0, x, params) * np.cos(phi0) + +def g1timessin(phi0, x, params): + """Compute g1(phi0) * sin(phi0).""" + return g1(phi0, x, params) * np.sin(phi0) + +# Harmonic balance system (hbsystem_case1) +def hbsystem_case1(x, params): + """ + Purpose of the function: + Computes the residuals for the harmonic balance system (Eq. 33a-f). + These residuals are minimized by `fsolve` to find the Fourier coefficients. + + Inputs: + 1. x (array-like): A vector of Fourier coefficients [U, G, H, X, Y]. + 2. params (dict): Dictionary containing nondimensional parameters: + - mu, a1, a2, ep, gamma, a0 (current state), and u0 (steady-state solution). + + Outputs: + 1. F (array-like): A vector of residuals corresponding to equations 33a-f. + + Notes: + - The residuals involve integrals over `phi0` (0 to 2π), which are computed using + numerical quadrature (`quad`). + - The function incorporates `g1`, `g1timescos`, and `g1timessin`. + """ + mu = params['mu'] + a1 = params['a1'] + a2 = params['a2'] + ep = params['ep'] + gamma = params['gamma'] + a0 = params['a0cur'] + u0 = params['u0'] + + # Fourier coefficients + U, V, G, H, X, Y = x[0], 0, x[1], x[2], x[3], x[4] + + # Equations 33a-f + F = np.zeros(5) + F[0] = -a2 * U + (1 / (2 * np.pi)) * quad(lambda phi: g1(phi, x, params), 0, 2 * np.pi)[0] + F[1] = H - Y + a1 * G + F[2] = -mu * H + (mu + 1) * Y + a2 * X - (1 / np.pi) * quad(lambda phi: g1timescos(phi, x, params), 0, 2 * np.pi)[0] + F[3] = -G + X + a1 * H + a0 + F[4] = mu * G - (mu + 1) * X + a2 * Y - (1 / np.pi) * quad(lambda phi: g1timessin(phi, x, params), 0, 2 * np.pi)[0] + #print(f'F: {F}') + return F + +# ODE function for A0 +def odefun_A0(t, A0, params): + """ + Purpose of the function: + Defines the ordinary differential equation (ODE) for `A0` as part of the + larger Colpitts oscillator system. Computes the time derivative of `A0`. + + Inputs: + 1. t (float): Current time (unused in this specific ODE but required by solver). + 2. A0 (float): Current value of `A0`. + 3. params (dict): Dictionary containing nondimensional parameters: + - lambda, a0cur (current A0 state), and others used in `hbsystem_case1`. + + Outputs: + 1. dA0 (float): The time derivative of `A0`. + + Notes: + - Uses `fsolve` to solve the harmonic balance equations (via `hbsystem_case1`). + - Returns `dA0` using the computed `H` value (harmonic balance coefficient). + """ + global nsolve_ics_storage + + # Initialize fsolve initial conditions if not set + if nsolve_ics_storage['nsolve_ics'] is None: + nsolve_ics_storage['nsolve_ics'] = np.array([100, 100, 100, 100, 100]) + + # Update current A0 in parameters + params['a0cur'] = A0 + lambda_ = params['lambda'] + + # Solve harmonic balance system + nsolve_ics = nsolve_ics_storage['nsolve_ics'] + x = fsolve(lambda x: hbsystem_case1(x, params), nsolve_ics, xtol=1e-4) + + # Update fsolve initial conditions for next iteration + nsolve_ics_storage['nsolve_ics'] = x + + # Extract H from the solution + H = x[2] + + # Compute dA0/d_eta_2 + dA0 = (-1 / 2) * (lambda_ * A0 - H) + #print(f'dA0 {dA0}') + print(f't {t}') + return dA0 + +# Main function to solve the system and plot results +def main(): + # Dimensional parameters + Cm = 2.201e-15 + Cs = 1.62e-11 + Cg = 2.32e-11 + Lm = 4.496e-2 + Rm = 5.62e1 + Rs = 7.444e3 + Rg = 5.168e4 + Vth = -0.95 + beta = 0.12 + B = 0.8 + + # Compute nondimensional parameters + mu = Cg / Cs + a1 = np.sqrt(Lm * Cm) / (Cg * Rg) + a2 = np.sqrt(Lm * Cm) / (Cs * Rs) + ep = np.sqrt(Cm / Cg) + lmbda = Rm * Cg / np.sqrt(Lm * Cm) + gamma = beta * abs(Vth) * np.sqrt(Lm * Cm) / Cs + u0 = (1 + a2 / (2 * gamma)) - np.sqrt((1 + a2 / (2 * gamma))**2 - 1) + + # Parameters + params = { + 'mu': mu, + 'a1': a1, + 'a2': a2, + 'ep': ep, + 'lambda': lmbda, + 'gamma': gamma, + 'u0': u0, + 'a0cur': 0, + 'v0': 0, + } + + # Initial conditions and time span + a0ic = 0 + tspan = [0, 200] + + # Solve the ODE + from scipy.integrate import solve_ivp + sol = solve_ivp( + fun=lambda t, A0: odefun_A0(t, A0, params), + t_span=tspan, + y0=[a0ic], + method='RK45', + max_step=1e-0 + ) + + # Plot the results + plt.plot(sol.t / params['ep']**2, np.abs(sol.y[0])) + plt.xlabel('Scaled Time (t / ep^2)') + plt.ylabel('A0 (Amplitude)') + plt.title('Dynamics of A0 Over Time') + plt.grid() + plt.savefig('test.png') + +# Run the main function +if __name__ == "__main__": + main() diff --git a/ME_2016/mini_project_2/ME2016__MINI_PROJECT_2.pdf b/ME_2016/mini_project_2/ME2016__MINI_PROJECT_2.pdf new file mode 100644 index 0000000..c3284b3 Binary files /dev/null and b/ME_2016/mini_project_2/ME2016__MINI_PROJECT_2.pdf differ diff --git a/ME_2016/mini_project_2/README.md b/ME_2016/mini_project_2/README.md new file mode 100644 index 0000000..cb232c3 --- /dev/null +++ b/ME_2016/mini_project_2/README.md @@ -0,0 +1,16 @@ +Okay, full disclosure. This folder and the organization of this code is MESSY. +Here's the layout of things to understand what's what. + +# "direct.ipynb" +This is the symbolic manipulation done to create the state space equations for the direct numerical part. + +# "main.py" +Is the averaging solution and the direct numerical solution actually being done. + +**The top half is the averaging solution, adapted from code in MATLAB given by Nikhil Bajaj.** Most of this code is translated into Python with the help of ChatGPT 4.0, and then checked for congruency by hand. + +The second half lazily redefines all the parameters and then implements a simple ODE solver on the state-space equations for the direct simulation. + +Finally, everything is plotted and the figure is saved. + +If you have any questions, contact me at dane.sabo@pitt.edu diff --git a/ME_2016/mini_project_2/direct.ipynb b/ME_2016/mini_project_2/direct.ipynb new file mode 100644 index 0000000..47b2dc2 --- /dev/null +++ b/ME_2016/mini_project_2/direct.ipynb @@ -0,0 +1,253 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "bb0a3f4e-6f1a-459c-b7af-df7d82b82a97", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import sympy as sm\n", + "from scipy.optimize import fsolve\n", + "from scipy.integrate import quad\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8504b0c4-befd-4b9e-8c32-dfb65a82a831", + "metadata": {}, + "outputs": [], + "source": [ + "f_pprime, f_prime, f = sm.symbols('f\\'\\', f\\', f')\n", + "v_prime, v = sm.symbols('v\\', v')\n", + "u_prime, u = sm.symbols('u\\', u')\n", + "epsilon, lambduh, alpha_1, mu, alpha_2, g = sm.symbols('epsilon, lambda, alpha_1, mu, alpha_2, g')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9301e042-edff-4579-b00b-53d2a6162e6f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\epsilon^{2} f' \\lambda + f + f'' = \\epsilon v'$" + ], + "text/plain": [ + "Eq(epsilon**2*f'*lambda + f + f'', epsilon*v')" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nine_a = sm.Eq(f_pprime+epsilon**2 *lambduh*f_prime + f, epsilon*v_prime)\n", + "nine_a" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3710753d-59ca-42c3-8791-15b02f317001", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\alpha_{1} v - u' + v' = - \\epsilon f$" + ], + "text/plain": [ + "Eq(alpha_1*v - u' + v', -epsilon*f)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nine_b = sm.Eq((v_prime-u_prime) + alpha_1*v, -epsilon*f)\n", + "nine_b" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a6796232-a2c0-40e5-8190-5a2c64bdb50d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\alpha_{2} u - \\mu \\left(- u' + v'\\right) + u' = g$" + ], + "text/plain": [ + "Eq(alpha_2*u - mu*(-u' + v') + u', g)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nine_c = sm.Eq(-mu*(v_prime-u_prime) + u_prime + alpha_2*u, g)\n", + "nine_c" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a100efcd-77d8-4d9b-a1a3-277c318549b0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{f'': -alpha_1*epsilon*mu*v - alpha_1*epsilon*v - alpha_2*epsilon*u - epsilon**2*f*mu - epsilon**2*f - epsilon**2*f'*lambda + epsilon*g - f,\n", + " u': -alpha_1*mu*v - alpha_2*u - epsilon*f*mu + g,\n", + " v': -alpha_1*mu*v - alpha_1*v - alpha_2*u - epsilon*f*mu - epsilon*f + g}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Solve the system of equations\n", + "solutions = sm.solve([nine_a, nine_b, nine_c], (v_prime, u_prime, f_pprime))\n", + "\n", + "# Display the solutions\n", + "solutions" + ] + }, + { + "cell_type": "markdown", + "id": "c336be4f-8aaa-4c37-ad4e-a7b89d3a74e1", + "metadata": {}, + "source": [ + "Define our states:\n", + "Variable Name | State\n", + "-----|------\n", + "f | x_1\n", + "f_prime | x_2\n", + "u | x_3\n", + "v | x_4\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "851d9ebc-6613-416c-8249-cd537806da06", + "metadata": {}, + "outputs": [], + "source": [ + "# Dimensional parameters\n", + "Cm = 2.201e-15\n", + "Cs = 1.62e-11\n", + "Cg = 2.32e-11\n", + "Lm = 4.496e-2\n", + "Rm = 5.62e1\n", + "Rs = 7.444e3\n", + "Rg = 5.168e4\n", + "Vth = -0.95\n", + "beta = 0.12\n", + "B = 0.8\n", + "\n", + "# Compute nondimensional parameters\n", + "mu = Cg / Cs\n", + "alpha_1 = np.sqrt(Lm * Cm) / (Cg * Rg)\n", + "alpha_2 = np.sqrt(Lm * Cm) / (Cs * Rs)\n", + "epsilon = np.sqrt(Cm / Cg)\n", + "lambduh = Rm * Cg / np.sqrt(Lm * Cm)\n", + "gamma = beta * abs(Vth) * np.sqrt(Lm * Cm) / Cs\n", + "\n", + "def g(value):\n", + " if value >= 0:\n", + " output = gamma*value**2\n", + " else:\n", + " output = 0\n", + " return output\n", + " \n", + "\n", + "def colpitts(t, X):\n", + " x_1, x_2, x_3, x_4 = X\n", + " dx1_dt = x_2\n", + " dx2_dt = -alpha_1*epsilon*mu*x_4 - alpha_1*epsilon*x_4 - \\\n", + " alpha_2*epsilon*x_3 - epsilon**2*x_1*mu - epsilon**2*x_1 - \\\n", + " epsilon**2*x_2*lambduh + epsilon*g(x_4-x_3+1) - x_1\n", + " dx3_dt = -alpha_1*mu*x_4 - alpha_2*x_3 - epsilon*x_1*mu + g(x_4-x_3+1)\n", + " dx4_dt = -alpha_1*mu*x_4 - alpha_1*x_4 - alpha_2*x_3 - epsilon*x_1*mu - epsilon*x_1 + g(x_4-x_3+1)\n", + " return [dx1_dt, dx2_dt, dx3_dt, dx4_dt]\n", + "\n", + "tspan = [0, 20]\n", + " \n", + "# Solve the ODE\n", + "from scipy.integrate import solve_ivp\n", + "sol = solve_ivp(\n", + " fun=colpitts,\n", + " t_span=tspan,\n", + " y0=[0,0,0,0],\n", + " method='RK45',\n", + " max_step=1e-4\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "151bf097-8daa-4bd8-9963-9b175203dbe2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the results\n", + "plt.plot(sol.t / epsilon**2, sol.y[0])\n", + "plt.xlabel('Scaled Time (t / ep^2)')\n", + "plt.ylabel('A0 (Amplitude)')\n", + "plt.title('Dynamics of A0 Over Time')\n", + "plt.grid()\n", + "plt.savefig('test.png')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ME_2016/mini_project_2/main.py b/ME_2016/mini_project_2/main.py index 79c0512..ca97452 100644 --- a/ME_2016/mini_project_2/main.py +++ b/ME_2016/mini_project_2/main.py @@ -178,23 +178,65 @@ def main(): # Initial conditions and time span a0ic = 0 - tspan = [0, 200] + tspan = [0, 100] # Solve the ODE + print('AVERAGING SOLUTION') from scipy.integrate import solve_ivp sol = solve_ivp( fun=lambda t, A0: odefun_A0(t, A0, params), t_span=tspan, y0=[a0ic], method='RK45', - max_step=1e-0 + atol = 1e-3 ) - + #### DIRECT INTEGRATION + # Compute nondimensional parameters + mu = Cg / Cs + alpha_1 = np.sqrt(Lm * Cm) / (Cg * Rg) + alpha_2 = np.sqrt(Lm * Cm) / (Cs * Rs) + epsilon = np.sqrt(Cm / Cg) + lambduh = Rm * Cg / np.sqrt(Lm * Cm) + gamma = beta * abs(Vth) * np.sqrt(Lm * Cm) / Cs + tspan_2 = [0, 1e6] + + def g(value): + if value >= 0: + output = gamma*value**2 + else: + output = 0 + return output + + + def colpitts(t, X): + x_1, x_2, x_3, x_4 = X + dx1_dt = x_2 + dx2_dt = -alpha_1*epsilon*mu*x_4 - alpha_1*epsilon*x_4 - \ + alpha_2*epsilon*x_3 - epsilon**2*x_1*mu - epsilon**2*x_1 - \ + epsilon**2*x_2*lambduh + epsilon*g(x_4-x_3+1) - x_1 + dx3_dt = -alpha_1*mu*x_4 - alpha_2*x_3 - epsilon*x_1*mu + g(x_4-x_3+1) + dx4_dt = -alpha_1*mu*x_4 - alpha_1*x_4 - alpha_2*x_3 - epsilon*x_1*mu - epsilon*x_1 + g(x_4-x_3+1) + print(f't: {t*epsilon**2}') + return [dx1_dt, dx2_dt, dx3_dt, dx4_dt] + + +# Solve the ODE + print('DIRECT SOLUTION') + sol2 = solve_ivp( + fun=colpitts, + t_span=tspan_2, + y0=[0,0,0,0], + method='RK45', + atol = 1e-13, + rtol = 1e-6 + ) + # Plot the results - plt.plot(sol.t / params['ep']**2, np.abs(sol.y[0])) + plt.plot(sol.t / params['ep']**2, np.abs(sol.y[0]), sol2.t, np.abs(sol2.y[0])) plt.xlabel('Scaled Time (t / ep^2)') - plt.ylabel('A0 (Amplitude)') - plt.title('Dynamics of A0 Over Time') + plt.ylabel('Amplitude') + plt.title('Averaging solution compared to direct numerical solution') + plt.legend(['A0','||f||']) plt.grid() plt.savefig('test.png') diff --git a/ME_2016/mini_project_2/test.png b/ME_2016/mini_project_2/test.png new file mode 100644 index 0000000..5d0256b Binary files /dev/null and b/ME_2016/mini_project_2/test.png differ