From 3166eafd46c2ed98deef2ab64fcb61c6cb960bef Mon Sep 17 00:00:00 2001 From: Jeff Eldredge Date: Mon, 21 Aug 2023 15:04:52 -0700 Subject: [PATCH 01/11] Added hybrid pitch-heave notebook --- Project.toml | 1 + .../notebooks/Airfoil in uniform flow.ipynb | 6 +- ...brid Model Force Compare Oscil Heave.ipynb | 2596 +++++++++++++++++ 3 files changed, 2600 insertions(+), 3 deletions(-) create mode 100644 other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb diff --git a/Project.toml b/Project.toml index d4744ca..eed8da0 100644 --- a/Project.toml +++ b/Project.toml @@ -18,6 +18,7 @@ PlotUtils = "995b91a9-d308-5afd-9ec6-746e21dbc043" RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" Reexport = "189a3867-3050-52da-a836-e630ba90ab69" SchwarzChristoffel = "6e93f119-a087-51f0-a155-b73ce4943121" +UnPack = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" [compat] ColorTypes = "0.10, 0.11" diff --git a/binder/notebooks/Airfoil in uniform flow.ipynb b/binder/notebooks/Airfoil in uniform flow.ipynb index 07b33a2..c19d2e9 100644 --- a/binder/notebooks/Airfoil in uniform flow.ipynb +++ b/binder/notebooks/Airfoil in uniform flow.ipynb @@ -638,15 +638,15 @@ "lastKernelId": null }, "kernelspec": { - "display_name": "Julia 1.4.2", + "display_name": "Julia 1.8.2", "language": "julia", - "name": "julia-1.4" + "name": "julia-1.8" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.4.2" + "version": "1.8.2" } }, "nbformat": 4, diff --git a/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb b/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb new file mode 100644 index 0000000..a909383 --- /dev/null +++ b/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb @@ -0,0 +1,2596 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Circulation Transfer" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "using PotentialFlow\n", + "\n", + "using Plots\n", + "using ProgressMeter\n", + "using UnPack" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#pyplot()\n", + "default(tickfont = font(\"CMU Serif\", 9), \n", + " titlefont = font(\"CMU Serif\", 14), \n", + " guidefont = font(\"CMU Serif\", 12), \n", + " grid = false)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "RGBA{Float64}(0.30196078431372547,0.6862745098039216,0.2901960784313726,1.0)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "myred = RGBA(228/255,26/255,28/255,1.0)\n", + "myblue = RGBA(55/255,126/255,184/255,1.0)\n", + "mygreen = RGBA(77/255,175/255,74/255,1.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Impulse matching correction" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "impulse_matching_correction" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + " impulse_matching_correction(vs, vt, plate) -> ComplexF64\n", + "\n", + "Compute the impulse matching position correction for a target vortex `vt` when the circulation\n", + "of a source vortex `vs` is to be fully transferred to it. Equation (A26) of Darakananda and Eldredge JFM 2019\n", + "with Γ̇ = ΓₛΔt. Assumes a flat plate body.\n", + "\"\"\"\n", + "function impulse_matching_correction(vs, vt, plate::Plate)\n", + " @unpack c, α, L = plate\n", + " \n", + " c⁺ = plate.zs[end]\n", + " c⁻ = plate.zs[1]\n", + "\n", + " z̃t = 2(vt.z - c)*exp(-im*α)/L\n", + " z̃s = 2(vs.z - c)*exp(-im*α)/L\n", + " \n", + " pt = Plates.unit_impulse(z̃t)\n", + " ps = Plates.unit_impulse(z̃s)\n", + "\n", + " η = z̃t/(√(z̃t + 1)*√(z̃t - 1))\n", + "\n", + " Δp = ps - pt\n", + " Δz = im*0.5L*exp(im*α)*(Δp*(1 + η') + Δp'*(η' - 1))/(η + η')*(circulation(vs)/circulation(vt))\n", + "# if isnan(Δz) || isinf(Δz)\n", + "# error(\"Δz is $Δz\")\n", + "# end\n", + " return Δz\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "transfer_circulation!" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + " total_impulse(point,plate) -> ComplexF64\n", + "\n", + "Return the total linear impulse of vortex `point` and its modification due to the presence of plate `plate`.\n", + "\"\"\"\n", + "function total_impulse(point, plate)\n", + " @unpack c, α, L = plate\n", + " \n", + " z = Elements.position(point)\n", + " Γ = circulation(point)\n", + "\n", + " z̃ = 2exp(-im*α)*(z - c)/L\n", + " exp(im*α)*0.5L*Γ*(imag(z) - im*real(√(z - 1)*√(z + 1)))\n", + "end\n", + "\n", + "\"\"\"\n", + " transfer_circulation!(sheet,point,Δz,plate,ϵ=1e-3;[max_segments=10]) -> Vortex.Blob\n", + "\n", + "Return a vortex blob that is initially identical to `point` and, where appropriate,\n", + "accrues the circulation of the last several segments of the vortex sheet `sheet`.\n", + "In these cases, it also removes the last several segments of `sheet`. The position\n", + "correction `Δz`, which accounts for the impulse matching correction due to the\n", + "transfer of circulation from each segment, is added to the position of `point`\n", + "to create the output vortex blob. `ϵ` is the maximum allowable discrepancy in\n", + "the impulse due to the circulation transfer (compared to the impulse if no circulation\n", + "is transferred). `max_segments` is the maximum number of sheet segments that can be considered\n", + "for transfer; it defaults to 10.\n", + "\"\"\"\n", + "function transfer_circulation!(sheet, point, Δz, plate, ϵ = 1e-3; max_segments=10)\n", + " z₀ = Elements.position(point)\n", + " Γ₀ = circulation(point)\n", + "\n", + " ΣΔz = zero(ComplexF64)\n", + " ΣΓ = 0.0\n", + "\n", + " Σp = total_impulse(Vortex.Point(z₀, Γ₀), plate)\n", + "\n", + " segments = 0\n", + " \n", + " # If the sheet isn't long enough to transfer, then return with no transfer\n", + " if length(sheet) < max_segments+2\n", + " return point\n", + " end\n", + "\n", + " for n in 1:length(sheet)-max_segments # Don't eat into the last `max_segments` segments\n", + " if isnan(Δz[n]) || isinf(Δz[n])\n", + " if n ≤ 2\n", + " return point\n", + " else\n", + " segments = n-1\n", + " break;\n", + " end\n", + " end\n", + "\n", + " ΣΔz += Δz[n]\n", + " ΣΓ += circulation(sheet.blobs[n])\n", + "\n", + " p₊ = total_impulse(Vortex.Point(z₀ + ΣΔz, Γ₀ + ΣΓ), plate) # impulse of active vortex with this segment transferred\n", + " Σp += total_impulse(sheet.blobs[n], plate) # impulse of the sheet if this segment is not transferred\n", + "\n", + " if abs2(p₊ - Σp) > ϵ^2\n", + " if n ≤ 2\n", + " return point\n", + " else\n", + " segments = n-1\n", + " break\n", + " end\n", + " end\n", + " segments += 1\n", + " end\n", + " \n", + " # Change the position and strength of `point`, using the impulse correction\n", + " # and strength of each segment\n", + " z = z₀ + sum(Δz[1:segments-1]) + 0.5Δz[segments]\n", + " Γ = Γ₀ + sum(circulation(sheet.blobs[1:segments-1])) +\n", + " 0.5(sheet.Ss[segments] -sheet.Ss[segments-1])\n", + " point₊ = Vortex.Blob(z, Γ, point.δ)\n", + "\n", + " # Remove the transferred segments from the sheet\n", + " splice!(sheet.blobs, 1:segments-1)\n", + " splice!(sheet.Ss, 1:segments-1)\n", + " sheet.blobs[1] = sheet.blobs[1](Γ = 0.5(sheet.Ss[2] - sheet.Ss[1]))\n", + "\n", + " return point₊\n", + "end" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Motion Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Time Marching Deatils" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "compute_ẋ! (generic function with 1 method)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function compute_ẋ!(ẋ, x, t)\n", + " plate, ambient_sys = x\n", + " motion = ẋ[1]\n", + " motion.ċ, motion.c̈, motion.α̇, motion.α̈ = motion.kin(t)\n", + "\n", + " Plates.enforce_no_flow_through!(plate, motion, ambient_sys, t)\n", + " reset_velocity!(ẋ, x)\n", + " self_induce_velocity!(ẋ, x, t)\n", + "end" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The centers of new vortex sheet segments are placed a third of the distance between the edges of the plate to last segment of sheet:" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "new_element (generic function with 3 methods)" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + " new_vortex(edge,angle,δ,plate,motion) -> Vortex.Blob\n", + "\n", + "Create a new vortex blob near the edge `edge` of the plate, with unit strength\n", + "\"\"\"\n", + "new_vortex(edge, α, δ, plate, motion) = Vortex.Blob(edge - 1e-2im*exp(im*α)*sign(Plates.normal(motion.ċ+im*motion.α̇*(edge-plate.c),α)), 1.0, δ)\n", + "\n", + "\n", + "\"\"\"\n", + " new_vortex(blobs::Vector{Vortex.Blob},edge,angle,δ,plate,motion) -> Vortex.Sheet\n", + "\n", + "Create a new vortex sheet near the edge `edge` of the plate with unit strength, using the vortex blobs in `blobs`\n", + "to place the sheet segments. (The blobs are placed at the sheet segment centroids.)\n", + "\"\"\"\n", + "function new_vortex(blobs::Vector{T}, edge, α, δ, plate, motion) where T <: Vortex.Blob\n", + " Δz = (blobs[end].z - edge)/2 \n", + " Vortex.Sheet([0.5, 1.5] .* Δz .+ edge, [0.0, 1.0], δ)\n", + "end\n", + "\n", + "\"\"\"\n", + " new_vortex(blobs::Vector{Vortex.Blob},sheet::Vortex.Sheet,edge,angle,δ,plate,motion) -> Vortex.Blob\n", + "\n", + "Create vortex blobs near the edge `edge` of the plate with unit strength, using the last vortex sheet segment in `sheet`\n", + "to place the blobs.\n", + "\"\"\"\n", + "function new_vortex(::Vector{T}, sheet::Vortex.Sheet, edge, α, δ, plate, motion) where T <: Vortex.Blob\n", + " z = (edge + 2sheet.zs[end])/3\n", + " Vortex.Blob.([sheet.zs[end], z], [0.5, 0.5], δ)\n", + "end\n", + "\n", + "\n", + "\"\"\"\n", + " shed_new_vorticity!(sys,motion,δ,t,lesp=0.0,tesp=0.0) -> Plate, \n", + "\n", + "Return \n", + "\"\"\"\n", + "function shed_new_vorticity!(sys, motion, δ, t, lesp = 0.0, tesp = 0.0)\n", + " plate, ambient_sys = sys\n", + " le_sys, te_sys = ambient_sys\n", + "\n", + "\n", + " nlev = new_vortex(le_sys..., plate.zs[end], plate.α, δ, plate, motion)\n", + " ntev = new_vortex(te_sys..., plate.zs[1], plate.α, δ, plate, motion)\n", + "\n", + " Γ₊, Γ₋, _, _ = Plates.vorticity_flux!(plate, nlev, ntev, t, lesp, tesp)\n", + "\n", + " (plate, add_new_vortex!.(ambient_sys, (nlev, ntev), (Γ₊, Γ₋)))\n", + "end\n", + "\n", + "function add_new_vortex!(::Tuple{}, b::Vortex.Blob, Γ)\n", + " if Γ != 0\n", + " ([Vortex.Blob(b.z, Γ, b.δ)],)\n", + " else\n", + " ()\n", + " end\n", + "end\n", + "\n", + "function add_new_vortex!(sys::Tuple{Vector{T}}, sheet::Vortex.Sheet, Γ) where T <: Vortex.Blob\n", + " (sys[1], Vortex.Sheet(sheet.zs, [0.0, Γ], sheet.blobs[1].δ))\n", + "end\n", + "\n", + "function add_new_vortex!(sys::Tuple{Vector{T}, Vortex.Sheet}, segment::Vector{T}, Γ) where T <: Vortex.Blob\n", + " _, sheet = sys\n", + " Vortex.Sheets.append_segment!(sheet, segment[2].z, Γ)\n", + " sys\n", + "end\n", + "\n", + "#=\n", + "function new_vortex(sys::Tuple{Vector{T}}, edge, α, δ) where T <: Vortex.Blob\n", + " Δz = (sys[1][end].z - edge)/2 \n", + "\n", + " Vortex.Sheet([0.5, 1.5] .* Δz + edge, [0.0, 1.0], δ)\n", + "end\n", + "\n", + "function new_vortex(sys::Tuple{Vector{T}, Vortex.Sheet}, edge, α, δ) where T <: Vortex.Blob\n", + " _, sheet = sys\n", + "\n", + " z = (edge + 2sheet.zs[end])/3\n", + "\n", + " Vortex.Blob.([sheet.zs[end], z], [0.5, 0.5], δ)\n", + "end\n", + "=#\n", + "\n", + "new_element(::Tuple{}) = ()\n", + "new_element(sys::Tuple{Vector{T}}) where T <: Vortex.Blob = (sys[1][1],) \n", + "function new_element(sys::Tuple{Vector{T}, Vortex.Sheet}) where T <: Vortex.Blob\n", + " _, sheet = sys\n", + " (sheet.blobs[end],)\n", + "end" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison with Theodorsen " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, let's set up the exact solution" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "C(κ::Float64) = hankelh2(1,κ)/(hankelh2(1,κ)+im*hankelh2(0,κ))\n", + "\n", + "struct Theodorsen\n", + " kin :: RigidBodyMotions.PitchHeave\n", + " L :: Float64\n", + "end\n", + "\n", + "function (theo::Theodorsen)(t::Float64)\n", + " @unpack L, kin = theo\n", + " @unpack Y,Ẏ,U₀,α,a,α̇,Ÿ,α̈,K = kin\n", + " # defined for motion in +x direction\n", + " ReΓb = π*L*(-Ẏ(t) + U₀*α(t) + (1/4 + a)*L*α̇(t))\n", + " ImΓb = π*L*(-2K*Y(t) - U₀*α̇(t)/(2K) + (1/4 + a)*L*2K*α(t))\n", + " fy = π*(L/2)^2*(-Ÿ(t) + a*α̈(t) + U₀*α̇(t)) + U₀*real((ReΓb+im*ImΓb)*C(K))\n", + " momp = π*(L/2)^2*(a*Ÿ(t)-(L^2/32+a^2)*α̈(t)-(L/4+a)*U₀*α̇(t)) + (L/4-a)*U₀*real((ReΓb+im*ImΓb)*C(K))\n", + " return fy, momp+a*fy\n", + "end" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now set up the problem parameters and kinematic" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "f* = 0.3183098861837907\n", + "Δα = 2.0\n", + "α(1/4) = 2.0\n", + "A/c = 0.0\n", + "K = 1.0\n" + ] + } + ], + "source": [ + "L = 1.0 # chord length\n", + "\n", + "N = 128 # number of plate control points\n", + "\n", + "Δt = 1e-2; # time step\n", + "δ = 0.1 #0.01\n", + "lesp = 10 #0.1\n", + "tesp = 0.0\n", + "\n", + "a = 0.25 # location of pitch axis, a = 0.5 is leading edge\n", + "ϕ = -π/2 # phase lag of pitch to heave\n", + "A = 0.0 # amplitude/chord\n", + "fstar = 1/π # fc/U\n", + "α₀ = 0 # mean angle of attack\n", + "Δα = 2π/180 # amplitude of pitching\n", + "\n", + "K = π*fstar # reduced frequency, K = πfc/U\n", + "println(\"f* = \",fstar)\n", + "println(\"Δα = \",Δα*180/π)\n", + "println(\"α(1/4) = \",abs(atan(2*K*A)-Δα)*180/π)\n", + "println(\"A/c = \",A)\n", + "println(\"K = \",K)\n", + "\n", + "oscil = RigidBodyMotions.PitchHeave(1.0,a,K,ϕ,α₀,Δα,A);" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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", + "0\n", + "\n", + "\n", + "2\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "8\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "12\n", + "\n", + "\n", + "Convective time\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−10\n", + "\n", + "\n", + "−5\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "5\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "Effective angle (deg)\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "2\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "8\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "12\n", + "\n", + "\n", + "Convective time\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−10\n", + "\n", + "\n", + "−5\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "5\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "Effective angle (deg)\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GKS: could not find font CMU Serif.ttf\n" + ] + } + ], + "source": [ + "t = 0:0.01:(4.0./fstar)\n", + "#plot(t,oscil.Ẏ.(t))\n", + "#plot!(t,oscil.α̇.(t))\n", + "Vy = map(x -> imag(x[1]),oscil.(t))\n", + "αeff = atan.(-Vy)+oscil.α.(t)\n", + "plot(t,αeff*180/π,ylim=(-10,10),ylabel=\"Effective angle (deg)\",xlabel=\"Convective time\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run it!" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(Plate: N = 128, L = 1.0, c = 0.0 + 0.0im, α = 2.0ᵒ\n", + " LESP = 0.07, TESP = -0.0, (), (PotentialFlow.Blobs.Blob{Float64, Float64}[Vortex.Blob(-0.5000444084765729 - 0.007455840081059527im, -0.015428105436724654, 0.1)],))" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plate = Plate(N, L, 0, oscil.α(0.0))\n", + "motion = Plates.RigidBodyMotion(oscil);\n", + "Plates.enforce_no_flow_through!(plate, motion, (), 0.0)\n", + "\n", + "sys = (plate, ((), ()))\n", + "#sys = (plate, ())\n", + "\n", + "\n", + "# sys[1] is the plate, sys[2] is the vortex system\n", + "# sys[2][i] corresponds to edge i (i = 1 is leading edge, i = 2 is trailing edge)\n", + "# sys[2][i][1] is the set of blobs associated with edge i\n", + "# sys[2][i][2] is the vortex sheet associated with edge i\n", + "# sys[2][i][1][1] is the current active vortex for edge i\n", + "\n", + "sys = shed_new_vorticity!(sys, motion, δ, 0.0, lesp, 0.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:00\u001b[39m\n" + ] + } + ], + "source": [ + "plate = Plate(N, L, 0, oscil.α(0.0))\n", + "motion = Plates.RigidBodyMotion(oscil);\n", + "Plates.enforce_no_flow_through!(plate, motion, (), 0.0)\n", + "\n", + "sys = (plate, ((), ()))\n", + "#sys = (plate, ())\n", + "\n", + "\n", + "# sys[1] is the plate, sys[2] is the vortex system\n", + "# sys[2][i] corresponds to edge i (i = 1 is leading edge, i = 2 is trailing edge)\n", + "# sys[2][i][1] is the set of blobs associated with edge i\n", + "# sys[2][i][2] is the vortex sheet associated with edge i\n", + "# sys[2][i][1][1] is the current active vortex for edge i\n", + "\n", + "sys = shed_new_vorticity!(sys, motion, δ, 0.0, lesp, 0.0)\n", + "states = Tuple[];\n", + "forces = [];\n", + "moments = [];\n", + "\n", + "tf = 12\n", + "T = Δt:Δt:tf\n", + "\n", + "# Set up Theodorsen solution results\n", + "#theo = Theodorsen(oscil,L)\n", + "#fytheo = map(x -> x[1], theo.(Δt:Δt:tf))\n", + "#momtheo = map(x -> x[2], theo.(Δt:Δt:tf))\n", + "\n", + "counter = [0, 0]\n", + "ϵ = 1e-3 #1.75e-4 #1e-3\n", + "countermin = [Inf,20] #[Inf,Inf]\n", + "@showprogress for t in T\n", + " push!(states, deepcopy(sys))\n", + "\n", + " # Perform the impulse matching correction on the active vortex position, but only if there is a sheet and vortex\n", + " Δzs = [length(sys[2][i]) == 2 ? [impulse_matching_correction(sblob, sys[2][i][1][1], sys[1]) for sblob in sys[2][i][2].blobs] : [] for i in 1:2]\n", + " \n", + " ẋs = (motion, allocate_velocity(sys[2]))\n", + " compute_ẋ!(ẋs, sys, t)\n", + " \n", + " push!(forces, Plates.force(plate, motion, sys[2], ẋs[2], (new_element(sys[2][1])..., new_element(sys[2][2])...), Δt)) \n", + " push!(moments, Plates.moment(plate, motion, sys[2], ẋs[2], (new_element(sys[2][1])..., new_element(sys[2][2])...), Δt)) \n", + "\n", + " advect!(sys, sys, ẋs, Δt)\n", + " \n", + " for i in 1:2 # each edge\n", + "# @show sys[2][i]\n", + " if length(sys[2][i]) != 2\n", + "# @show \"! $i\"\n", + " continue\n", + " end\n", + " point = transfer_circulation!(sys[2][i][2], sys[2][i][1][1], Δzs[i], plate, ϵ)\n", + " if point == sys[2][i][1][1]\n", + " counter[i] += 1\n", + "# @show \":( $i)\"\n", + " else\n", + "# @show i\n", + " counter[i] = 0\n", + " sys[2][i][1][1] = point\n", + " end\n", + " if length(sys[2][i][2]) > 2 && counter[i] > countermin[i]\n", + " tips = sys[2][i][2].blobs[1:2]\n", + " newPoint = Vortex.Blob(0.5*(tips[1].z + tips[2].z), 2circulation(tips[1]), tips[1].δ)\n", + " splice!(sys[2][i][2].blobs, 1)\n", + " splice!(sys[2][i][2].Ss, 1)\n", + " sys[2][i][2].blobs[1] = Vortex.Blob(tips[2].z, 0.5*(sys[2][i][2].Ss[2] - sys[2][i][2].Ss[1]), tips[2].δ)\n", + " pushfirst!(sys[2][i][1], newPoint) # used to be unshift!\n", + " counter[i] = 0\n", + " end\n", + " end\n", + " \n", + " length(sys[2][1]) == 2 && Sheets.arclength(sys[2][1][2]) ≥ 50Δt && Sheets.filter!(sys[2][1][2], 2Δt, 8Δt)\n", + " length(sys[2][2]) == 2 && Sheets.arclength(sys[2][2][2]) ≥ 50Δt && Sheets.filter!(sys[2][2][2], 2Δt, 8Δt)\n", + " \n", + " # or remeshing instead\n", + " #length(sys[2][1]) == 2 && Sheets.arclength(sys[2][1][2]) ≥ 30Δt && Sheets.remesh!(sys[2][1][2],2Δt)\n", + " #length(sys[2][2]) == 2 && Sheets.arclength(sys[2][2][2]) ≥ 30Δt && Sheets.remesh!(sys[2][2][2],2Δt)\n", + " \n", + " Plates.enforce_no_flow_through!(plate, motion, sys[2], t)\n", + " sys = shed_new_vorticity!(sys, motion, δ, t, lesp, 0.0)\n", + " \n", + "\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": {}, + "outputs": [], + "source": [ + "forces_tmin4em1 = deepcopy(forces);\n", + "moments_tmin4em1 = deepcopy(moments);\n", + "states_tmin4em1 = deepcopy(states);" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = plot(states[1200],color = cgrad(:RdBu,rev=true), ratio=1,legend=:none,markersize=4,markerstrokealpha=1,\n", + " markerstrokewidth=0.5,linewidth=1.5,ticks=nothing,border=nothing,framestyle=false,\n", + " clim=(-0.5,0.5),ylim=(-2,2),xlim=(-1,15))\n", + "#zc = map(x -> 0.5x[1].zs[64] + 0.5x[1].zs[65],states[1:end]) \n", + "#plot!(real.(zc),imag.(zc))\n", + "#savefig(\"oscil-alf05A05-sheet.pdf\")\n", + "#savefig(\"oscil-alf05A05-eps175em3tmin1em1.pdf\")\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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", + "0.0\n", + "\n", + "\n", + "2.5\n", + "\n", + "\n", + "5.0\n", + "\n", + "\n", + "7.5\n", + "\n", + "\n", + "10.0\n", + "\n", + "\n", + "Convective Time\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−0.50\n", + "\n", + "\n", + "−0.25\n", + "\n", + "\n", + "0.00\n", + "\n", + "\n", + "0.25\n", + "\n", + "\n", + "0.50\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0.0\n", + "\n", + "\n", + "2.5\n", + "\n", + "\n", + "5.0\n", + "\n", + "\n", + "7.5\n", + "\n", + "\n", + "10.0\n", + "\n", + "\n", + "Convective Time\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−0.50\n", + "\n", + "\n", + "−0.25\n", + "\n", + "\n", + "0.00\n", + "\n", + "\n", + "0.25\n", + "\n", + "\n", + "0.50\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = plot(ylabel = \"\\$C_y\\$\", ylim = (-0.5,0.5), \n", + " xlabel = \"Convective Time\")\n", + "#plot!(Δt:Δt:tf, 2imag.(forces_tmin1em1), linewidth = 1.5, linestyle = :solid, label = \"\\$T_{min}=0.1\\$\")\n", + "#plot!(Δt:Δt:tf, 2imag.(forces_tmin4em1), linewidth = 1.5, linestyle = :solid, label = \"\\$T_{min}=0.4\\$\")\n", + "plot!(Δt:Δt:tf, 2imag.(forces), linewidth = 1.5, linestyle = :solid, label = \"sheet\")\n", + "#plot!(Δt:Δt:tf, 2fytheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")\n", + "#savefig(\"oscil-forces.pdf\")\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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", + "0.0\n", + "\n", + "\n", + "2.5\n", + "\n", + "\n", + "5.0\n", + "\n", + "\n", + "7.5\n", + "\n", + "\n", + "10.0\n", + "\n", + "\n", + "Convective Time\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−0.05\n", + "\n", + "\n", + "0.00\n", + "\n", + "\n", + "0.05\n", + "\n", + "\n", + "0.10\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0.0\n", + "\n", + "\n", + "2.5\n", + "\n", + "\n", + "5.0\n", + "\n", + "\n", + "7.5\n", + "\n", + "\n", + "10.0\n", + "\n", + "\n", + "Convective Time\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−0.05\n", + "\n", + "\n", + "0.00\n", + "\n", + "\n", + "0.05\n", + "\n", + "\n", + "0.10\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = plot(ylabel = \"\\$C_M\\$\", ylim = (-0.1,0.1), \n", + " xlabel = \"Convective Time\")\n", + "#plot!(Δt:Δt:tf, 2moments_tmin1em1, linewidth = 1.5, linestyle = :solid, label = \"\\$T_{min}=0.1\\$\")\n", + "#plot!(Δt:Δt:tf, 2moments_tmin4em1, linewidth = 1.5, linestyle = :solid, label = \"\\$T_{min}=0.4\\$\")\n", + "plot!(Δt:Δt:tf, 2moments, linewidth = 1.5, linestyle = :solid, label = \"sheet\")\n", + "#plot!(Δt:Δt:tf, 2momtheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Calculate error and number of elements" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "ename": "LoadError", + "evalue": "UndefVarError: `forces_tmin1em1` not defined\n\nSome of the types have been truncated in the stacktrace for improved reading. To emit complete information\nin the stack trace, evaluate `TruncatedStacktraces.VERBOSE[] = true` and re-run the code.\n", + "output_type": "error", + "traceback": [ + "UndefVarError: `forces_tmin1em1` not defined\n\nSome of the types have been truncated in the stacktrace for improved reading. To emit complete information\nin the stack trace, evaluate `TruncatedStacktraces.VERBOSE[] = true` and re-run the code.\n", + "", + "Stacktrace:", + " [1] top-level scope", + " @ In[39]:1" + ] + } + ], + "source": [ + "println(\"Error from reference = \",norm(forces_tmin1em1-forces_ref)/norm(forces_ref))\n", + "println(\"Total number of vortex elements at tf = \",sum(length(states_tmin1em1[end][2][j][i]) for i = 1:2, j = 2))\n", + "println(\"Total number of vortex elements in ref at tf = \",sum(length(states_ref[end][2][j][i]) for i = 1:2, j = 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 235, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error from reference = 0.004194867745700374\n", + "Total number of vortex elements at tf = 386\n", + "Total number of vortex elements in ref at tf = 2208\n" + ] + } + ], + "source": [ + "println(\"Error from reference = \",norm(forces_tmin4em1-forces_ref)/norm(forces_ref))\n", + "println(\"Total number of vortex elements at tf = \",sum(length(states_tmin4em1[end][2][j][i]) for i = 1:2, j = 2))\n", + "println(\"Total number of vortex elements in ref at tf = \",sum(length(states_ref[end][2][j][i]) for i = 1:2, j = 2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluation of Kinsey and Dumas results" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "f* = 0.14\n", + "Δα = 5.0\n", + "α(1/4) = 5.0\n", + "K = 0.4398229715025711\n", + "χ = Inf\n" + ] + } + ], + "source": [ + "L = 1.0 # chord length\n", + "ċ = L # translation velocity\n", + "# α = π/3#*ramp(0)#π/30 # angle of attack\n", + "\n", + "N = 128 # number of plate control points\n", + "\n", + "Δt = 1e-2; # time step\n", + "δ = 0.05 #0.01\n", + "lesp = 10.0 #0.1\n", + "tesp = 0.0\n", + "\n", + "a = 0.5 #0.2 # location of pitch axis, a = 0.5 is leading edge\n", + "ϕ = -π/2 # phase lag of pitch to heave\n", + "A = 0.0 #1.0 # amplitude/chord\n", + "fstar = 0.14 # fc/U\n", + "α₀ = 0π/180 # mean angle of attack\n", + "Δα = 5π/180 #20π/180 # amplitude of pitching\n", + "\n", + "# specify feathering parameter\n", + "#χ = 1.0 # feathering parameter\n", + "#Δα = χ*atan(2π*A*fstar)\n", + "#fstar = tan(Δα/χ)/(2π*A)\n", + "#println(\"α(1/4) = \",α₀/χ - α₀)\n", + "χ = Δα/atan(2π*A*fstar)\n", + "K = π*fstar # reduced frequency, K = πfc/U\n", + "println(\"f* = \",fstar)\n", + "println(\"Δα = \",Δα*180/π)\n", + "println(\"α(1/4) = \",abs(atan(2*K*A)-Δα)*180/π)\n", + "println(\"K = \",K)\n", + "println(\"χ = \",χ)\n", + "\n", + "\n", + "oscil = RigidBodyMotions.PitchHeave(1.0,a,K,ϕ,α₀,Δα,A);" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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", + "0\n", + "\n", + "\n", + "5\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "15\n", + "\n", + "\n", + "20\n", + "\n", + "\n", + "25\n", + "\n", + "\n", + "Convective time\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−30\n", + "\n", + "\n", + "−20\n", + "\n", + "\n", + "−10\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "20\n", + "\n", + "\n", + "30\n", + "\n", + "\n", + "Effective angle (deg)\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "5\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "15\n", + "\n", + "\n", + "20\n", + "\n", + "\n", + "25\n", + "\n", + "\n", + "Convective time\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−30\n", + "\n", + "\n", + "−20\n", + "\n", + "\n", + "−10\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "20\n", + "\n", + "\n", + "30\n", + "\n", + "\n", + "Effective angle (deg)\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t = 0:0.01:(4.0./fstar)\n", + "#plot(t,oscil.Ẏ.(t))\n", + "#plot!(t,oscil.α̇.(t))\n", + "Vy = map(x -> imag(x[1]),oscil.(t))\n", + "αeff = atan.(-Vy)+oscil.α.(t)\n", + "plot(t,αeff*180/π,ylim=(-30,30),ylabel=\"Effective angle (deg)\",xlabel=\"Convective time\")" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:01\u001b[39m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total number of vortex elements at tf = 48\n" + ] + } + ], + "source": [ + "plate = Plate(N, L, 0, oscil.α(0.0))\n", + "motion = Plates.RigidBodyMotion(oscil);\n", + "Plates.enforce_no_flow_through!(plate, motion, (), 0.0)\n", + "\n", + "sys = (plate, ((), ()))\n", + "\n", + "# sys[1] is the plate, sys[2] is the vortex system\n", + "# sys[2][i] corresponds to edge i (i = 1 is leading edge, i = 2 is trailing edge)\n", + "# sys[2][i][1] is the set of blobs associated with edge i\n", + "# sys[2][i][2] is the vortex sheet associated with edge i\n", + "# sys[2][i][1][1] is the current active vortex for edge i\n", + "\n", + "sys = shed_new_vorticity!(sys, motion, δ, 0.0, lesp, 0.0)\n", + "states = Tuple[];\n", + "forces = [];\n", + "\n", + "tf = 20\n", + "T = Δt:Δt:tf\n", + "\n", + "counter = [0, 0]\n", + "ϵ = 1e-4 #0 #1e-3\n", + "countermin = [30,30] #[10,10] #[Inf, Inf]\n", + "@showprogress for t in T\n", + " push!(states, deepcopy(sys))\n", + "\n", + " # Perform the impulse matching correction on the active vortex position, but only if there is a sheet and vortex\n", + " Δzs = [length(sys[2][i]) == 2 ? [impulse_matching_correction(sblob, sys[2][i][1][1], sys[1]) for sblob in sys[2][i][2].blobs] : [] for i in 1:2]\n", + " \n", + " ẋs = (motion, allocate_velocity(sys[2]))\n", + " compute_ẋ!(ẋs, sys, t)\n", + " \n", + " push!(forces, Plates.force(plate, motion, sys[2], ẋs[2], (new_element(sys[2][1])..., new_element(sys[2][2])...), Δt)) \n", + " advect!(sys, sys, ẋs, Δt)\n", + " \n", + " for i in 1:2 # each edge\n", + "# @show sys[2][i]\n", + " if length(sys[2][i]) != 2\n", + "# @show \"! $i\"\n", + " continue\n", + " end\n", + " point = transfer_circulation!(sys[2][i][2], sys[2][i][1][1], Δzs[i], plate, ϵ)\n", + " if point == sys[2][i][1][1]\n", + " # nothing was done to the active blob in this step.\n", + " counter[i] += 1\n", + "# @show \":( $i)\"\n", + " else\n", + "# @show i\n", + " counter[i] = 0\n", + " sys[2][i][1][1] = point\n", + " end\n", + " if length(sys[2][i][2]) > 2 && counter[i] > countermin[i]\n", + " # convert current active vortex into an inactive one, and release tip of sheet as new active vortex\n", + " tips = sys[2][i][2].blobs[1:2]\n", + " # factor of 2 in circulation is due to the trapezoidal weight on blob strength of first blob\n", + " newPoint = Vortex.Blob(0.5*(tips[1].z + tips[2].z), 2circulation(tips[1]), tips[1].δ)\n", + " splice!(sys[2][i][2].blobs, 1)\n", + " splice!(sys[2][i][2].Ss, 1)\n", + " # now the second blob is the first blob and needs to have its strength adjusted for trapezoidal weight\n", + " sys[2][i][2].blobs[1] = Vortex.Blob(tips[2].z, 0.5*(sys[2][i][2].Ss[2] - sys[2][i][2].Ss[1]), tips[2].δ)\n", + " pushfirst!(sys[2][i][1], newPoint) # used to be unshift!\n", + " counter[i] = 0\n", + " end\n", + " end\n", + " \n", + " length(sys[2][1]) == 2 && Sheets.arclength(sys[2][1][2]) ≥ 50Δt && Sheets.filter!(sys[2][1][2], 2Δt, 8Δt)\n", + " length(sys[2][2]) == 2 && Sheets.arclength(sys[2][2][2]) ≥ 50Δt && Sheets.filter!(sys[2][2][2], 2Δt, 8Δt)\n", + " \n", + " # or remeshing instead\n", + " #length(sys[2][1]) == 2 && Sheets.arclength(sys[2][1][2]) ≥ 30Δt && Sheets.remesh!(sys[2][1][2],2Δt)\n", + " #length(sys[2][2]) == 2 && Sheets.arclength(sys[2][2][2]) ≥ 30Δt && Sheets.remesh!(sys[2][2][2],2Δt)\n", + " \n", + " Plates.enforce_no_flow_through!(plate, motion, sys[2], t)\n", + " sys = shed_new_vorticity!(sys, motion, δ, t, lesp, 0.0)\n", + " \n", + "\n", + "end\n", + "println(\"Total number of vortex elements at tf = \",sum(length(states[end][2][j][i]) for i = 1:2, j = 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2000" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "length(states)" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = plot(states[end],color = cgrad(:RdBu,rev=true), ratio=1,legend=:none,markersize=3,markerstrokealpha=1,\n", + " markerstrokewidth=0.5,linewidth=2,ticks=nothing,border=nothing,framestyle=false,\n", + " clim=(-1,1),ylim=(-3,3)) #,xlim=(-2,13))\n", + "zc = map(x -> 0.5x[1].zs[64] + 0.5x[1].zs[65],states[1:end]) \n", + "plot!(real.(zc),imag.(zc),linestyle=:dash,color=:black,linewidth=1)\n", + "#savefig(\"oscil-alf60A1-eps1em3tmin02-t50.pdf\")\n", + "#savefig(\"oscil-alf20A1-sheet-t12.pdf\")\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [], + "source": [ + "for n in [20, 50, 100]\n", + " plot(states[n], ratio=1, markersize = 3, markerstrokealpha = 0, linewidth=1,\n", + " color = :RdBu_r, clim = (-0.02, 0.02), legend = :none,\n", + " ylim = (-1.2,0.5), xlim = real(states[n][1].zs[end]) .+ (-2, 0.1), size = (200, 160))\n", + " #plot!(filter(b -> circulation(b) < 0, states[n][2][1][1]), marker_z = nothing, markersize = 3, markerstrokealpha = 0, markercolor = :white)\n", + " #savefig(\"pitchup_k07_d10_t$(lpad(n, 3, 0)).pdf\")\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jeff/.julia/v0.6/Conda/deps/usr/lib/python2.7/site-packages/matplotlib/cbook/deprecation.py:107: MatplotlibDeprecationWarning: Passing one of 'on', 'true', 'off', 'false' as a boolean is deprecated; use an actual boolean (True/False) instead.\n", + " warnings.warn(message, mplDeprecation, stacklevel=1)\n" + ] + } + ], + "source": [ + "plt = plot(states[100],color = :RdBu_r, ratio=1,legend=:none,markersize=4,markerstrokealpha=1,\n", + " markerstrokewidth=0.5,linewidth=2,ticks=nothing,border=nothing,framestyle=false,\n", + " clim=(-1,1),ylim=(-2,2))" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3-element Array{Float64,1}:\n", + " 0.383144\n", + " 16.0873 \n", + " 89.3972 " + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "180*pitchup.α.([0.2, 0.5, 1.5])/π" + ] + }, + { + "cell_type": "code", + "execution_count": 286, + "metadata": {}, + "outputs": [], + "source": [ + "forces_alf20A1_eps1em3cmin20 = deepcopy(forces);\n", + "states_alf20A1_eps1em3cmin20 = deepcopy(states);" + ] + }, + { + "cell_type": "code", + "execution_count": 297, + "metadata": {}, + "outputs": [], + "source": [ + "forces_alf20A1_sheet = deepcopy(forces_sheet);\n", + "states_alf20A1_sheet = deepcopy(states_sheet);" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "metadata": {}, + "outputs": [], + "source": [ + "plot(T,180pitchup_k07.α.(T)/π,xlim = (0,5), ylim = (0,100),legend=false)\n", + "plot!(T,180pitchup_k02.α.(T)/π,xlim = (0,5), ylim = (0,100),legend=false)\n", + "savefig(\"pitchup_alpha.pdf\")" + ] + }, + { + "cell_type": "code", + "execution_count": 295, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5000" + ] + }, + "execution_count": 295, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "length(forces_alf20A1_eps1em3cmin20)" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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", + "0\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "20\n", + "\n", + "\n", + "30\n", + "\n", + "\n", + "40\n", + "\n", + "\n", + "50\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−3\n", + "\n", + "\n", + "−2\n", + "\n", + "\n", + "−1\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "2\n", + "\n", + "\n", + "3\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "20\n", + "\n", + "\n", + "30\n", + "\n", + "\n", + "40\n", + "\n", + "\n", + "50\n", + "\n", + "\n", + "Convective Time\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−3\n", + "\n", + "\n", + "−2\n", + "\n", + "\n", + "−1\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "2\n", + "\n", + "\n", + "3\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "20\n", + "\n", + "\n", + "30\n", + "\n", + "\n", + "40\n", + "\n", + "\n", + "50\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−3\n", + "\n", + "\n", + "−2\n", + "\n", + "\n", + "−1\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "2\n", + "\n", + "\n", + "3\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "20\n", + "\n", + "\n", + "30\n", + "\n", + "\n", + "40\n", + "\n", + "\n", + "50\n", + "\n", + "\n", + "Convective Time\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−3\n", + "\n", + "\n", + "−2\n", + "\n", + "\n", + "−1\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "2\n", + "\n", + "\n", + "3\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Vy = map(x -> imag(x[1]),oscil.(Δt:Δt:50))\n", + "plt = plot(layout = (2,1), \n", + " ylabel = [\"\\$C_y\\$\" \"\\$C_x\\$\"], ylim = [(-3,3) (-3, 3)], \n", + " xlabel = [\"\" \"Convective Time\"], size = (600, 300), legend = :none)\n", + "plot!((Δt:Δt:50), [2imag.(forces) 2real.(forces)], linewidth = 1.5, linestyle = :solid)\n", + "#plot!((Δt:Δt:12), [2imag.(forces_alf20A1_sheet) 2real.(forces_alf20A1_sheet)], linewidth = 1.5, linestyle = :solid)\n", + "#plot!((Δt:Δt:tf), [Vy Vy])\n", + "#savefig(\"oscil-force-alf20A1.pdf\")\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 439, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.8254777667281494" + ] + }, + "execution_count": 439, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mean(2real.(forces_alf20A1_eps1em3cmin20))" + ] + }, + { + "cell_type": "code", + "execution_count": 442, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.5356737589022174" + ] + }, + "execution_count": 442, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mean(imag.(forces_alf20A1_eps1em3cmin20).*Vy)" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "execution_count": 147, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = plot(layout = (2,1), \n", + " ylabel = [\"\\$C_L\\$\" \"\\$C_D\\$\"], ylim = [(0, 12) (0, 12)], \n", + " xlabel = [\"\" \"Convective Time\"], size = (600, 300), legend = :none)\n", + "plot!(Δt:Δt:tf, [2imag.(forces) -2real.(forces)], linewidth = 1, linestyle = :dash)\n", + "# sheet_forces = open(deserialize, \"aoa60_sheet_force.dat\")\n", + "# plot!(plt, range(Δt, Δt, length(sheet_forces)), [2imag.(sheet_forces) -2real.(sheet_forces)], linewidth = 2, label=\"Sheet Only\", legend = :none)\n", + "#savefig(\"pitchup07_hybrid_force.pdf\")\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "@webio": { + "lastCommId": null, + "lastKernelId": null + }, + "kernelspec": { + "display_name": "Julia 1.9.2", + "language": "julia", + "name": "julia-1.9" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From b0e42654114045793493b4235ca6184d53b7dbc5 Mon Sep 17 00:00:00 2001 From: Jeff Eldredge Date: Mon, 21 Aug 2023 15:24:42 -0700 Subject: [PATCH 02/11] Made some streamlining improvements to hybrid notebook --- ...brid Model Force Compare Oscil Heave.ipynb | 344 +++++++++--------- 1 file changed, 181 insertions(+), 163 deletions(-) diff --git a/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb b/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb index a909383..5d0ceb8 100644 --- a/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb +++ b/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb @@ -48,12 +48,12 @@ " width=\"25mm\" height=\"25mm\" viewBox=\"0 0 1 1\" stroke=\"none\"\n", " preserveAspectRatio=\"none\" shape-rendering=\"crispEdges\">\n", "\n", - " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", "\n", "" @@ -282,7 +282,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -291,7 +291,7 @@ "new_element (generic function with 3 methods)" ] }, - "execution_count": 37, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -329,9 +329,10 @@ "\n", "\n", "\"\"\"\n", - " shed_new_vorticity!(sys,motion,δ,t,lesp=0.0,tesp=0.0) -> Plate, \n", + " shed_new_vorticity!(sys,motion,δ,t,lesp=0.0,tesp=0.0) \n", "\n", - "Return \n", + "Returns the plate/vortex system after adding new vortices of the appropriate type\n", + "at the plate edges, in order to satisfy the respective regularization conditions at those edges.\n", "\"\"\"\n", "function shed_new_vorticity!(sys, motion, δ, t, lesp = 0.0, tesp = 0.0)\n", " plate, ambient_sys = sys\n", @@ -343,10 +344,11 @@ "\n", " Γ₊, Γ₋, _, _ = Plates.vorticity_flux!(plate, nlev, ntev, t, lesp, tesp)\n", "\n", - " (plate, add_new_vortex!.(ambient_sys, (nlev, ntev), (Γ₊, Γ₋)))\n", + " plate, (add_new_vortex!(le_sys..., nlev, Γ₊), add_new_vortex!(te_sys..., ntev, Γ₋))\n", + "\n", "end\n", "\n", - "function add_new_vortex!(::Tuple{}, b::Vortex.Blob, Γ)\n", + "function add_new_vortex!(b::Vortex.Blob, Γ)\n", " if Γ != 0\n", " ([Vortex.Blob(b.z, Γ, b.δ)],)\n", " else\n", @@ -354,14 +356,13 @@ " end\n", "end\n", "\n", - "function add_new_vortex!(sys::Tuple{Vector{T}}, sheet::Vortex.Sheet, Γ) where T <: Vortex.Blob\n", - " (sys[1], Vortex.Sheet(sheet.zs, [0.0, Γ], sheet.blobs[1].δ))\n", + "function add_new_vortex!(blobs::Vector{T}, sheet::Vortex.Sheet, Γ) where T <: Vortex.Blob\n", + " blobs, Vortex.Sheet(sheet.zs, [0.0, Γ], sheet.blobs[1].δ)\n", "end\n", "\n", - "function add_new_vortex!(sys::Tuple{Vector{T}, Vortex.Sheet}, segment::Vector{T}, Γ) where T <: Vortex.Blob\n", - " _, sheet = sys\n", + "function add_new_vortex!(blobs::Vector{T}, sheet::Vortex.Sheet, segment::Vector{T}, Γ) where T <: Vortex.Blob\n", " Vortex.Sheets.append_segment!(sheet, segment[2].z, Γ)\n", - " sys\n", + " blobs, sheet\n", "end\n", "\n", "#=\n", @@ -436,7 +437,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -490,165 +491,165 @@ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0\n", "\n", - "\n", + "\n", "2\n", "\n", - "\n", + "\n", "4\n", "\n", - "\n", + "\n", "6\n", "\n", - "\n", + "\n", "8\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "12\n", "\n", - "\n", + "\n", "Convective time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−10\n", "\n", - "\n", + "\n", "−5\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "5\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "Effective angle (deg)\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0\n", "\n", - "\n", + "\n", "2\n", "\n", - "\n", + "\n", "4\n", "\n", - "\n", + "\n", "6\n", "\n", - "\n", + "\n", "8\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "12\n", "\n", - "\n", + "\n", "Convective time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−10\n", "\n", - "\n", + "\n", "−5\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "5\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "Effective angle (deg)\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ] }, "execution_count": 10, @@ -681,17 +682,17 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(Plate: N = 128, L = 1.0, c = 0.0 + 0.0im, α = 2.0ᵒ\n", - " LESP = 0.07, TESP = -0.0, (), (PotentialFlow.Blobs.Blob{Float64, Float64}[Vortex.Blob(-0.5000444084765729 - 0.007455840081059527im, -0.015428105436724654, 0.1)],))" + " LESP = 0.07, TESP = -0.0, ((), (PotentialFlow.Blobs.Blob{Float64, Float64}[Vortex.Blob(-0.5000444084765729 - 0.007455840081059527im, -0.015428105436724654, 0.1)],)))" ] }, - "execution_count": 35, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -716,7 +717,35 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "ename": "LoadError", + "evalue": "BoundsError: attempt to access Tuple{} at index [1]\n\nSome of the types have been truncated in the stacktrace for improved reading. To emit complete information\nin the stack trace, evaluate `TruncatedStacktraces.VERBOSE[] = true` and re-run the code.\n", + "output_type": "error", + "traceback": [ + "BoundsError: attempt to access Tuple{} at index [1]\n\nSome of the types have been truncated in the stacktrace for improved reading. To emit complete information\nin the stack trace, evaluate `TruncatedStacktraces.VERBOSE[] = true` and re-run the code.\n", + "", + "Stacktrace:", + " [1] indexed_iterate", + " @ ./tuple.jl:88 [inlined]", + " [2] indexed_iterate(t::Tuple{}, i::Int64)", + " @ Base ./tuple.jl:88", + " [3] top-level scope", + " @ In[19]:2" + ] + } + ], + "source": [ + "p1, p2 = sys\n", + "p21, p22 = p2\n", + "p21" + ] + }, + { + "cell_type": "code", + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -814,18 +843,7 @@ }, { "cell_type": "code", - "execution_count": 120, - "metadata": {}, - "outputs": [], - "source": [ - "forces_tmin4em1 = deepcopy(forces);\n", - "moments_tmin4em1 = deepcopy(moments);\n", - "states_tmin4em1 = deepcopy(states);" - ] - }, - { - "cell_type": "code", - "execution_count": 39, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -835,94 +853,94 @@ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\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/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, - "execution_count": 39, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } From 21d947eab435da1f4f42914c5112020bc3f02eef Mon Sep 17 00:00:00 2001 From: Jeff Eldredge Date: Mon, 21 Aug 2023 15:45:34 -0700 Subject: [PATCH 03/11] Some more streamlining of hybrid notebook --- ...brid Model Force Compare Oscil Heave.ipynb | 1304 ++++++++--------- 1 file changed, 630 insertions(+), 674 deletions(-) diff --git a/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb b/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb index 5d0ceb8..e51a2d7 100644 --- a/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb +++ b/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb @@ -282,16 +282,16 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 69, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "new_element (generic function with 3 methods)" + "new_element" ] }, - "execution_count": 33, + "execution_count": 69, "metadata": {}, "output_type": "execute_result" } @@ -348,6 +348,12 @@ "\n", "end\n", "\n", + "\"\"\"\n", + " add_new_vortex!(blob::Vortex.Blob,Γ) -> (blob,)\n", + "\n", + "Create a new vortex blob with the position and radius of `blob`, but with strength `Γ`,\n", + "unless `Γ` is zero, in which case it returns an empty tuple.\n", + "\"\"\"\n", "function add_new_vortex!(b::Vortex.Blob, Γ)\n", " if Γ != 0\n", " ([Vortex.Blob(b.z, Γ, b.δ)],)\n", @@ -356,10 +362,21 @@ " end\n", "end\n", "\n", + "\"\"\"\n", + " add_new_vortex!(blobs::Vector{Vortex.Blob},sheet,Γ) -> (blob,)\n", + "\n", + "Return blobs and a sheet with the same positions and radii as `sheet`, but with the strengths\n", + "set to 0 and `Γ`. This is meant for cases in which the sheet is initially created.\n", + "\"\"\"\n", "function add_new_vortex!(blobs::Vector{T}, sheet::Vortex.Sheet, Γ) where T <: Vortex.Blob\n", " blobs, Vortex.Sheet(sheet.zs, [0.0, Γ], sheet.blobs[1].δ)\n", "end\n", "\n", + "\"\"\"\n", + " add_new_vortex!(blobs::Vector{Vortex.Blob},sheet,segment::Vector{Vortex.Blob},Γ) -> (blob,)\n", + "\n", + "Return blobs and a sheet that appends the last vortex in `segment` to `sheet`, with strength `Γ`.\n", + "\"\"\"\n", "function add_new_vortex!(blobs::Vector{T}, sheet::Vortex.Sheet, segment::Vector{T}, Γ) where T <: Vortex.Blob\n", " Vortex.Sheets.append_segment!(sheet, segment[2].z, Γ)\n", " blobs, sheet\n", @@ -381,10 +398,26 @@ "end\n", "=#\n", "\n", - "new_element(::Tuple{}) = ()\n", - "new_element(sys::Tuple{Vector{T}}) where T <: Vortex.Blob = (sys[1][1],) \n", - "function new_element(sys::Tuple{Vector{T}, Vortex.Sheet}) where T <: Vortex.Blob\n", - " _, sheet = sys\n", + "\"\"\"\n", + " new_element() -> ()\n", + "\n", + "Returns an empty tuple\n", + "\"\"\"\n", + "new_element() = ()\n", + "\n", + "\"\"\"\n", + " new_element(blobs::Vector{Vortex.Blob}) -> (Vortex.Blob,)\n", + "\n", + "Returns the most recently added vortex in `blobs`\n", + "\"\"\"\n", + "new_element(blobs::Vector{T}) where T <: Vortex.Blob = (blobs[1],) \n", + "\n", + "\"\"\"\n", + " new_element(blobs::Vector{Vortex.Blob},sheet::Vortex.Sheet) -> (Vortex.Blob,) \n", + "\n", + "Returns the most recently added vortex in `sheet`\n", + "\"\"\"\n", + "function new_element(blobs::Vector{T}, sheet::Vortex.Sheet) where T <: Vortex.Blob\n", " (sheet.blobs[end],)\n", "end" ] @@ -405,7 +438,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 70, "metadata": {}, "outputs": [], "source": [ @@ -437,7 +470,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 71, "metadata": {}, "outputs": [ { @@ -481,7 +514,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 72, "metadata": {}, "outputs": [ { @@ -491,177 +524,170 @@ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0\n", "\n", - "\n", + "\n", "2\n", "\n", - "\n", + "\n", "4\n", "\n", - "\n", + "\n", "6\n", "\n", - "\n", + "\n", "8\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "12\n", "\n", - "\n", + "\n", "Convective time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−10\n", "\n", - "\n", + "\n", "−5\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "5\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "Effective angle (deg)\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0\n", "\n", - "\n", + "\n", "2\n", "\n", - "\n", + "\n", "4\n", "\n", - "\n", + "\n", "6\n", "\n", - "\n", + "\n", "8\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "12\n", "\n", - "\n", + "\n", "Convective time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−10\n", "\n", - "\n", + "\n", "−5\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "5\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "Effective angle (deg)\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 10, + "execution_count": 72, "metadata": {}, "output_type": "execute_result" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GKS: could not find font CMU Serif.ttf\n" - ] } ], "source": [ @@ -682,70 +708,14 @@ }, { "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(Plate: N = 128, L = 1.0, c = 0.0 + 0.0im, α = 2.0ᵒ\n", - " LESP = 0.07, TESP = -0.0, ((), (PotentialFlow.Blobs.Blob{Float64, Float64}[Vortex.Blob(-0.5000444084765729 - 0.007455840081059527im, -0.015428105436724654, 0.1)],)))" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plate = Plate(N, L, 0, oscil.α(0.0))\n", - "motion = Plates.RigidBodyMotion(oscil);\n", - "Plates.enforce_no_flow_through!(plate, motion, (), 0.0)\n", - "\n", - "sys = (plate, ((), ()))\n", - "#sys = (plate, ())\n", - "\n", - "\n", - "# sys[1] is the plate, sys[2] is the vortex system\n", - "# sys[2][i] corresponds to edge i (i = 1 is leading edge, i = 2 is trailing edge)\n", - "# sys[2][i][1] is the set of blobs associated with edge i\n", - "# sys[2][i][2] is the vortex sheet associated with edge i\n", - "# sys[2][i][1][1] is the current active vortex for edge i\n", - "\n", - "sys = shed_new_vorticity!(sys, motion, δ, 0.0, lesp, 0.0)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "LoadError", - "evalue": "BoundsError: attempt to access Tuple{} at index [1]\n\nSome of the types have been truncated in the stacktrace for improved reading. To emit complete information\nin the stack trace, evaluate `TruncatedStacktraces.VERBOSE[] = true` and re-run the code.\n", - "output_type": "error", - "traceback": [ - "BoundsError: attempt to access Tuple{} at index [1]\n\nSome of the types have been truncated in the stacktrace for improved reading. To emit complete information\nin the stack trace, evaluate `TruncatedStacktraces.VERBOSE[] = true` and re-run the code.\n", - "", - "Stacktrace:", - " [1] indexed_iterate", - " @ ./tuple.jl:88 [inlined]", - " [2] indexed_iterate(t::Tuple{}, i::Int64)", - " @ Base ./tuple.jl:88", - " [3] top-level scope", - " @ In[19]:2" - ] - } - ], - "source": [ - "p1, p2 = sys\n", - "p21, p22 = p2\n", - "p21" - ] + "outputs": [], + "source": [] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 77, "metadata": {}, "outputs": [ { @@ -796,9 +766,11 @@ " ẋs = (motion, allocate_velocity(sys[2]))\n", " compute_ẋ!(ẋs, sys, t)\n", " \n", - " push!(forces, Plates.force(plate, motion, sys[2], ẋs[2], (new_element(sys[2][1])..., new_element(sys[2][2])...), Δt)) \n", - " push!(moments, Plates.moment(plate, motion, sys[2], ẋs[2], (new_element(sys[2][1])..., new_element(sys[2][2])...), Δt)) \n", + " lesys, tesys = sys[2]\n", + " push!(forces, Plates.force(plate, motion, sys[2], ẋs[2], (new_element(lesys...)..., new_element(tesys...)...), Δt)) \n", + " push!(moments, Plates.moment(plate, motion, sys[2], ẋs[2], (new_element(lesys...)..., new_element(tesys...)...), Δt)) \n", "\n", + " \n", " advect!(sys, sys, ẋs, Δt)\n", " \n", " for i in 1:2 # each edge\n", @@ -843,104 +815,106 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 78, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, - "execution_count": 29, + "execution_count": 78, "metadata": {}, "output_type": "execute_result" } @@ -949,8 +923,8 @@ "plt = plot(states[1200],color = cgrad(:RdBu,rev=true), ratio=1,legend=:none,markersize=4,markerstrokealpha=1,\n", " markerstrokewidth=0.5,linewidth=1.5,ticks=nothing,border=nothing,framestyle=false,\n", " clim=(-0.5,0.5),ylim=(-2,2),xlim=(-1,15))\n", - "#zc = map(x -> 0.5x[1].zs[64] + 0.5x[1].zs[65],states[1:end]) \n", - "#plot!(real.(zc),imag.(zc))\n", + "zc = map(x -> 0.5x[1].zs[64] + 0.5x[1].zs[65],states[1:end]) \n", + "plot!(real.(zc),imag.(zc))\n", "#savefig(\"oscil-alf05A05-sheet.pdf\")\n", "#savefig(\"oscil-alf05A05-eps175em3tmin1em1.pdf\")\n", "plt" @@ -958,7 +932,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 79, "metadata": {}, "outputs": [ { @@ -968,68 +942,68 @@ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0.0\n", "\n", - "\n", + "\n", "2.5\n", "\n", - "\n", + "\n", "5.0\n", "\n", - "\n", + "\n", "7.5\n", "\n", - "\n", + "\n", "10.0\n", "\n", - "\n", + "\n", "Convective Time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−0.50\n", "\n", - "\n", + "\n", "−0.25\n", "\n", - "\n", + "\n", "0.00\n", "\n", - "\n", + "\n", "0.25\n", "\n", - "\n", + "\n", "0.50\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0.0\n", "\n", - "\n", + "\n", "2.5\n", "\n", - "\n", + "\n", "5.0\n", "\n", - "\n", + "\n", "7.5\n", "\n", - "\n", + "\n", "10.0\n", "\n", - "\n", + "\n", "Convective Time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−0.50\n", "\n", - "\n", + "\n", "−0.25\n", "\n", - "\n", + "\n", "0.00\n", "\n", - "\n", + "\n", "0.25\n", "\n", - "\n", + "\n", "0.50\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 16, + "execution_count": 79, "metadata": {}, "output_type": "execute_result" } @@ -1451,7 +1425,7 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 49, "metadata": {}, "outputs": [ { @@ -1504,7 +1478,7 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 50, "metadata": {}, "outputs": [ { @@ -1514,176 +1488,176 @@ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0\n", "\n", - "\n", + "\n", "5\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "15\n", "\n", - "\n", + "\n", "20\n", "\n", - "\n", + "\n", "25\n", "\n", - "\n", + "\n", "Convective time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−30\n", "\n", - "\n", + "\n", "−20\n", "\n", - "\n", + "\n", "−10\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "20\n", "\n", - "\n", + "\n", "30\n", "\n", - "\n", + "\n", "Effective angle (deg)\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0\n", "\n", - "\n", + "\n", "5\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "15\n", "\n", - "\n", + "\n", "20\n", "\n", - "\n", + "\n", "25\n", "\n", - "\n", + "\n", "Convective time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−30\n", "\n", - "\n", + "\n", "−20\n", "\n", - "\n", + "\n", "−10\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "20\n", "\n", - "\n", + "\n", "30\n", "\n", - "\n", + "\n", "Effective angle (deg)\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 75, + "execution_count": 50, "metadata": {}, "output_type": "execute_result" } @@ -1699,7 +1673,7 @@ }, { "cell_type": "code", - "execution_count": 96, + "execution_count": 60, "metadata": {}, "outputs": [ { @@ -1713,7 +1687,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Total number of vortex elements at tf = 48\n" + "Total number of vortex elements at tf = 31\n" ] } ], @@ -1734,12 +1708,12 @@ "states = Tuple[];\n", "forces = [];\n", "\n", - "tf = 20\n", + "tf = 60\n", "T = Δt:Δt:tf\n", "\n", "counter = [0, 0]\n", - "ϵ = 1e-4 #0 #1e-3\n", - "countermin = [30,30] #[10,10] #[Inf, Inf]\n", + "ϵ = 1e-3 #0 #1e-3\n", + "countermin = [10,10] #[10,10] #[Inf, Inf]\n", "@showprogress for t in T\n", " push!(states, deepcopy(sys))\n", "\n", @@ -1749,7 +1723,7 @@ " ẋs = (motion, allocate_velocity(sys[2]))\n", " compute_ẋ!(ẋs, sys, t)\n", " \n", - " push!(forces, Plates.force(plate, motion, sys[2], ẋs[2], (new_element(sys[2][1])..., new_element(sys[2][2])...), Δt)) \n", + " push!(forces, Plates.force(plate, motion, sys[2], ẋs[2], (new_element(sys[2][1]...)..., new_element(sys[2][2]...)...), Δt)) \n", " advect!(sys, sys, ẋs, Δt)\n", " \n", " for i in 1:2 # each edge\n", @@ -1799,16 +1773,16 @@ }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 61, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "2000" + "6000" ] }, - "execution_count": 91, + "execution_count": 61, "metadata": {}, "output_type": "execute_result" } @@ -1819,160 +1793,126 @@ }, { "cell_type": "code", - "execution_count": 97, + "execution_count": 62, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, - "execution_count": 97, + "execution_count": 62, "metadata": {}, "output_type": "execute_result" } @@ -1990,13 +1930,13 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 66, "metadata": {}, "outputs": [], "source": [ "for n in [20, 50, 100]\n", " plot(states[n], ratio=1, markersize = 3, markerstrokealpha = 0, linewidth=1,\n", - " color = :RdBu_r, clim = (-0.02, 0.02), legend = :none,\n", + " color = cgrad(:RdBu,rev=true), clim = (-0.02, 0.02), legend = :none,\n", " ylim = (-1.2,0.5), xlim = real(states[n][1].zs[end]) .+ (-2, 0.1), size = (200, 160))\n", " #plot!(filter(b -> circulation(b) < 0, states[n][2][1][1]), marker_z = nothing, markersize = 3, markerstrokealpha = 0, markercolor = :white)\n", " #savefig(\"pitchup_k07_d10_t$(lpad(n, 3, 0)).pdf\")\n", @@ -2107,87 +2047,91 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": 64, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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", - "0\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "30\n", - "\n", - "\n", - "40\n", - "\n", - "\n", - "50\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "20\n", + "\n", + "\n", + "30\n", + "\n", + "\n", + "40\n", + "\n", + "\n", + "50\n", + "\n", + "\n", + "60\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−3\n", "\n", - "\n", + "\n", "−2\n", "\n", - "\n", + "\n", "−1\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "1\n", "\n", - "\n", + "\n", "2\n", "\n", - "\n", + "\n", "3\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", + "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "0\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "10\n", "\n", - "\n", - "10\n", + "\n", + "20\n", "\n", - "\n", - "20\n", + "\n", + "30\n", "\n", - "\n", - "30\n", + "\n", + "40\n", "\n", - "\n", - "40\n", + "\n", + "50\n", "\n", - "\n", - "50\n", + "\n", + "60\n", "\n", - "\n", + "\n", "Convective Time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−3\n", "\n", - "\n", + "\n", "−2\n", "\n", - "\n", + "\n", "−1\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "1\n", "\n", - "\n", + "\n", "2\n", "\n", - "\n", + "\n", "3\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "30\n", - "\n", - "\n", - "40\n", - "\n", - "\n", - "50\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "20\n", + "\n", + "\n", + "30\n", + "\n", + "\n", + "40\n", + "\n", + "\n", + "50\n", + "\n", + "\n", + "60\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−3\n", "\n", - "\n", + "\n", "−2\n", "\n", - "\n", + "\n", "−1\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "1\n", "\n", - "\n", + "\n", "2\n", "\n", - "\n", + "\n", "3\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", + "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "0\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "10\n", "\n", - "\n", - "10\n", + "\n", + "20\n", "\n", - "\n", - "20\n", + "\n", + "30\n", "\n", - "\n", - "30\n", + "\n", + "40\n", "\n", - "\n", - "40\n", + "\n", + "50\n", "\n", - "\n", - "50\n", + "\n", + "60\n", "\n", - "\n", + "\n", "Convective Time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−3\n", "\n", - "\n", + "\n", "−2\n", "\n", - "\n", + "\n", "−1\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "1\n", "\n", - "\n", + "\n", "2\n", "\n", - "\n", + "\n", "3\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n" ] }, - "execution_count": 81, + "execution_count": 64, "metadata": {}, "output_type": "execute_result" } @@ -2512,7 +2468,7 @@ "plt = plot(layout = (2,1), \n", " ylabel = [\"\\$C_y\\$\" \"\\$C_x\\$\"], ylim = [(-3,3) (-3, 3)], \n", " xlabel = [\"\" \"Convective Time\"], size = (600, 300), legend = :none)\n", - "plot!((Δt:Δt:50), [2imag.(forces) 2real.(forces)], linewidth = 1.5, linestyle = :solid)\n", + "plot!((Δt:Δt:60), [2imag.(forces) 2real.(forces)], linewidth = 1.5, linestyle = :solid)\n", "#plot!((Δt:Δt:12), [2imag.(forces_alf20A1_sheet) 2real.(forces_alf20A1_sheet)], linewidth = 1.5, linestyle = :solid)\n", "#plot!((Δt:Δt:tf), [Vy Vy])\n", "#savefig(\"oscil-force-alf20A1.pdf\")\n", From 635bc5217935989e590535148aa545dd944798d2 Mon Sep 17 00:00:00 2001 From: Jeff Eldredge Date: Mon, 21 Aug 2023 16:51:21 -0700 Subject: [PATCH 04/11] Further refinements to hybrid notebook --- ...brid Model Force Compare Oscil Heave.ipynb | 1051 ++++++++--------- 1 file changed, 508 insertions(+), 543 deletions(-) diff --git a/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb b/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb index e51a2d7..be46b17 100644 --- a/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb +++ b/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb @@ -48,12 +48,12 @@ " width=\"25mm\" height=\"25mm\" viewBox=\"0 0 1 1\" stroke=\"none\"\n", " preserveAspectRatio=\"none\" shape-rendering=\"crispEdges\">\n", "\n", - " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", "\n", "" @@ -282,7 +282,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -291,7 +291,7 @@ "new_element" ] }, - "execution_count": 69, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -313,7 +313,8 @@ "\"\"\"\n", "function new_vortex(blobs::Vector{T}, edge, α, δ, plate, motion) where T <: Vortex.Blob\n", " Δz = (blobs[end].z - edge)/2 \n", - " Vortex.Sheet([0.5, 1.5] .* Δz .+ edge, [0.0, 1.0], δ)\n", + " #Vortex.Sheet([0.5, 1.5] .* Δz .+ edge, [0.0, 1.0], δ)\n", + " Vortex.Sheet([1.5, 0.5] .* Δz .+ edge, [0.0, 1.0], δ)\n", "end\n", "\n", "\"\"\"\n", @@ -375,7 +376,8 @@ "\"\"\"\n", " add_new_vortex!(blobs::Vector{Vortex.Blob},sheet,segment::Vector{Vortex.Blob},Γ) -> (blob,)\n", "\n", - "Return blobs and a sheet that appends the last vortex in `segment` to `sheet`, with strength `Γ`.\n", + "Return blobs and a sheet that appends the last vortex in `segment` to the end of `sheet`, with strength `Γ`.\n", + "This is the newly-created entry from the edge.\n", "\"\"\"\n", "function add_new_vortex!(blobs::Vector{T}, sheet::Vortex.Sheet, segment::Vector{T}, Γ) where T <: Vortex.Blob\n", " Vortex.Sheets.append_segment!(sheet, segment[2].z, Γ)\n", @@ -438,7 +440,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -470,7 +472,7 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -514,7 +516,7 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -524,170 +526,177 @@ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0\n", "\n", - "\n", + "\n", "2\n", "\n", - "\n", + "\n", "4\n", "\n", - "\n", + "\n", "6\n", "\n", - "\n", + "\n", "8\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "12\n", "\n", - "\n", + "\n", "Convective time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−10\n", "\n", - "\n", + "\n", "−5\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "5\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "Effective angle (deg)\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0\n", "\n", - "\n", + "\n", "2\n", "\n", - "\n", + "\n", "4\n", "\n", - "\n", + "\n", "6\n", "\n", - "\n", + "\n", "8\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "12\n", "\n", - "\n", + "\n", "Convective time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−10\n", "\n", - "\n", + "\n", "−5\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "5\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "Effective angle (deg)\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 72, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GKS: could not find font CMU Serif.ttf\n" + ] } ], "source": [ @@ -708,21 +717,14 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 77, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:00\u001b[39m\n" + "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:02\u001b[39m\n" ] } ], @@ -738,7 +740,7 @@ "# sys[1] is the plate, sys[2] is the vortex system\n", "# sys[2][i] corresponds to edge i (i = 1 is leading edge, i = 2 is trailing edge)\n", "# sys[2][i][1] is the set of blobs associated with edge i\n", - "# sys[2][i][2] is the vortex sheet associated with edge i\n", + "# sys[2][i][2] is the vortex sheet associated with edge i. Its first entry is the \n", "# sys[2][i][1][1] is the current active vortex for edge i\n", "\n", "sys = shed_new_vorticity!(sys, motion, δ, 0.0, lesp, 0.0)\n", @@ -756,12 +758,12 @@ "\n", "counter = [0, 0]\n", "ϵ = 1e-3 #1.75e-4 #1e-3\n", - "countermin = [Inf,20] #[Inf,Inf]\n", + "countermin = [Inf,20] #[Inf,20] #[Inf,Inf]\n", "@showprogress for t in T\n", " push!(states, deepcopy(sys))\n", "\n", " # Perform the impulse matching correction on the active vortex position, but only if there is a sheet and vortex\n", - " Δzs = [length(sys[2][i]) == 2 ? [impulse_matching_correction(sblob, sys[2][i][1][1], sys[1]) for sblob in sys[2][i][2].blobs] : [] for i in 1:2]\n", + " #Δzs = [length(sys[2][i]) == 2 ? [impulse_matching_correction(sblob, sys[2][i][1][1], sys[1]) for sblob in sys[2][i][2].blobs] : [] for i in 1:2]\n", " \n", " ẋs = (motion, allocate_velocity(sys[2]))\n", " compute_ẋ!(ẋs, sys, t)\n", @@ -770,42 +772,57 @@ " push!(forces, Plates.force(plate, motion, sys[2], ẋs[2], (new_element(lesys...)..., new_element(tesys...)...), Δt)) \n", " push!(moments, Plates.moment(plate, motion, sys[2], ẋs[2], (new_element(lesys...)..., new_element(tesys...)...), Δt)) \n", "\n", - " \n", " advect!(sys, sys, ẋs, Δt)\n", " \n", " for i in 1:2 # each edge\n", - "# @show sys[2][i]\n", - " if length(sys[2][i]) != 2\n", - "# @show \"! $i\"\n", - " continue\n", - " end\n", - " point = transfer_circulation!(sys[2][i][2], sys[2][i][1][1], Δzs[i], plate, ϵ)\n", - " if point == sys[2][i][1][1]\n", + " \n", + " # If this edge's vortex system is not set up, then skip the transfer\n", + " length(sys[2][i]) == 2 || continue\n", + " \n", + " edge_blobs, edge_sheet = sys[2][i]\n", + " active_blob = edge_blobs[1]\n", + " \n", + " Δzs = [impulse_matching_correction(sblob, edge_blobs[1], plate) for sblob in edge_sheet.blobs] \n", + " \n", + " point = transfer_circulation!(edge_sheet, edge_blobs[1], Δzs, plate, ϵ)\n", + "\n", + " if point == edge_blobs[1]\n", " counter[i] += 1\n", - "# @show \":( $i)\"\n", " else\n", - "# @show i\n", " counter[i] = 0\n", - " sys[2][i][1][1] = point\n", + " edge_blobs[1] = point\n", " end\n", - " if length(sys[2][i][2]) > 2 && counter[i] > countermin[i]\n", - " tips = sys[2][i][2].blobs[1:2]\n", - " newPoint = Vortex.Blob(0.5*(tips[1].z + tips[2].z), 2circulation(tips[1]), tips[1].δ)\n", - " splice!(sys[2][i][2].blobs, 1)\n", - " splice!(sys[2][i][2].Ss, 1)\n", - " sys[2][i][2].blobs[1] = Vortex.Blob(tips[2].z, 0.5*(sys[2][i][2].Ss[2] - sys[2][i][2].Ss[1]), tips[2].δ)\n", - " pushfirst!(sys[2][i][1], newPoint) # used to be unshift!\n", + " \n", + " # if we have waited long enough, and sheet is sufficiently long, then\n", + " # convert current active vortex into an inactive one, and release tip of sheet as new active vortex\n", + " if length(edge_sheet) > 2 && counter[i] > countermin[i]\n", + " tips = edge_sheet.blobs[1:2]\n", + " \n", + " # factor of 2 in circulation is due to the trapezoidal weight on blob strength of first blob\n", + " new_active = Vortex.Blob(0.5*(tips[1].z + tips[2].z), 2circulation(tips[1]), tips[1].δ)\n", + " \n", + " # remove the first entry from the sheet, since this has been transferred to the active blob\n", + " splice!(edge_sheet.blobs, 1)\n", + " splice!(edge_sheet.Ss, 1)\n", + " \n", + " # now the second sheet element is the first element and needs to have its strength adjusted for trapezoidal weight\n", + " edge_sheet.blobs[1] = Vortex.Blob(tips[2].z, 0.5*(edge_sheet.Ss[2] - edge_sheet.Ss[1]), tips[2].δ)\n", + " pushfirst!(edge_blobs, new_active)\n", " counter[i] = 0\n", " end\n", " end\n", " \n", - " length(sys[2][1]) == 2 && Sheets.arclength(sys[2][1][2]) ≥ 50Δt && Sheets.filter!(sys[2][1][2], 2Δt, 8Δt)\n", - " length(sys[2][2]) == 2 && Sheets.arclength(sys[2][2][2]) ≥ 50Δt && Sheets.filter!(sys[2][2][2], 2Δt, 8Δt)\n", - " \n", - " # or remeshing instead\n", - " #length(sys[2][1]) == 2 && Sheets.arclength(sys[2][1][2]) ≥ 30Δt && Sheets.remesh!(sys[2][1][2],2Δt)\n", - " #length(sys[2][2]) == 2 && Sheets.arclength(sys[2][2][2]) ≥ 30Δt && Sheets.remesh!(sys[2][2][2],2Δt)\n", - " \n", + " for i in 1:2\n", + " length(sys[2][i]) == 2 || continue\n", + " edge_blobs, edge_sheet = sys[2][i]\n", + " \n", + " # Filter\n", + " Sheets.arclength(edge_sheet) ≥ 50Δt && Sheets.filter!(edge_sheet, 2Δt, 8Δt)\n", + " \n", + " # or remesh\n", + " #Sheets.arclength(edge_sheet) ≥ 30Δt && Sheets.remesh!(edge_sheet,2Δt)\n", + " end\n", + " \n", " Plates.enforce_no_flow_through!(plate, motion, sys[2], t)\n", " sys = shed_new_vorticity!(sys, motion, δ, t, lesp, 0.0)\n", " \n", @@ -815,114 +832,114 @@ }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, - "execution_count": 78, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "plt = plot(states[1200],color = cgrad(:RdBu,rev=true), ratio=1,legend=:none,markersize=4,markerstrokealpha=1,\n", + "plt = plot(states[end],color = cgrad(:RdBu,rev=true), ratio=1,legend=:none,markersize=4,markerstrokealpha=1,\n", " markerstrokewidth=0.5,linewidth=1.5,ticks=nothing,border=nothing,framestyle=false,\n", - " clim=(-0.5,0.5),ylim=(-2,2),xlim=(-1,15))\n", + " clim=(-0.5,0.5),ylim=(-2,2))\n", "zc = map(x -> 0.5x[1].zs[64] + 0.5x[1].zs[65],states[1:end]) \n", "plot!(real.(zc),imag.(zc))\n", "#savefig(\"oscil-alf05A05-sheet.pdf\")\n", @@ -932,78 +949,78 @@ }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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", "0.0\n", "\n", - "\n", + "\n", "2.5\n", "\n", - "\n", + "\n", "5.0\n", "\n", - "\n", + "\n", "7.5\n", "\n", - "\n", + "\n", "10.0\n", "\n", - "\n", + "\n", "Convective Time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−0.50\n", "\n", - "\n", + "\n", "−0.25\n", "\n", - "\n", + "\n", "0.00\n", "\n", - "\n", + "\n", "0.25\n", "\n", - "\n", + "\n", "0.50\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0.0\n", "\n", - "\n", + "\n", "2.5\n", "\n", - "\n", + "\n", "5.0\n", "\n", - "\n", + "\n", "7.5\n", "\n", - "\n", + "\n", "10.0\n", "\n", - "\n", + "\n", "Convective Time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−0.50\n", "\n", - "\n", + "\n", "−0.25\n", "\n", - "\n", + "\n", "0.00\n", "\n", - "\n", + "\n", "0.25\n", "\n", - "\n", + "\n", "0.50\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 79, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -1151,74 +1168,74 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 140, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeWBU1d038N85d7IRIAtZJntIIBIUWQJFRFHMAii4UHCjUqSI+qiPrVahT3209S1Vaxd9rAsqamu1LoCySUISRMMqBEVQ1oSskwVIAiFkmznn/ePaNA2QTJK5c+/M/X7+IsPcmTNnzpzfPTuTUhIAAIBZcb0TAAAAoCcEQgAAMDUEQgAAMDUEQgAAMDWL1m9QUFCQnZ0tpYyNjV28eLHF0ot3dDgcBw4ccDgc48aNc+0rAwAAqJims0YPHDiwdu3aJUuWKIqybdu2PXv2PPzww05e+8orr5SXl0dFRfn7+y9evNiFrwwAANBB267RVatWLVy4UFEUIpo8eXJlZWV9fb2T1y5YsOCZZ5655ZZbXP7KAAAAHbQNhM3NzVartePPtLS0oqIiJ68dMGCARq8MAADQQcNA2N7e7ufn1/kRq9VaU1Nj5FcGAACz0TAQ2u12X1/fzo/4+/vb7XYjvzIAAJiNhjMtLRZLW1tb50daW1tdMrez+1fOy8tbsmRJcnJyx//+4he/mDRpUv/fFwAAvI+GgdDHx6elpaXzI1VVVUlJSVq/ckNDA+d87ty56p+KoqSkpPT/TQEAwCtpu/bO39+/pqYmMjJS/bOwsDArK6vLcxobG+vq6hISElz1yn5+flFRUR2BEAAAoBvazhqdM2fOW2+9JYQgoh07dkRFRYWEhHR+gsPhWLhw4aJFi3bu3OnaVwYAAHCGti3CUaNG1dfXP/nkk0RktVoffPDBLk9Q+y2Lioo62nYdXnnlFZvN1tzcXFtbW1ZWRkQPPPBAVFSUk68MAADgDG13ltHFunXr3njjjbVr1+qdEAAA8ADYdBsAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNh9kCAHgMu91eUFDgcDj0TogOFEUZN25cUFCQy18ZgRAAwGPs3r179uzZ48eP1zshOjh69Oh///d/P/LIIy5/ZQRCAACP4XA4LrvsstzcXL0TooPHH39co6YwxggBAMDUEAgBAMDUEAgBAMDUEAgBAMDUEAgBAMDUEAgBAMDUEAgBAMA1Tp48+fLLL+udil5DIAQAANeorq5etmxZf17h3Llz48ePt9vtrkqSMxAIAQCg706cONHY2NjlwcbGxubm5i4PtrW1nT17tsuDUsr6+vqOPx0OR2FhoZtPjEcgBACAvvjqq6+Sk5MzMzMnTJgwffp09UEp5c9//vO0tDSr1fqb3/xGfbC+vv7WW2+95JJLxowZM2PGjFOnTqmPP/PMM3FxcVdfffUll1yya9cuIrr77ruJ6Iorrhg/fvx3333nng+CLdYAADzYpkq52Sbc8Eb+Ci25XAnoFDT++Mc/PvbYY/fddx8RnTx5Un2wurp67NixL7zwQmlp6ciRI++77z6r1frII49ERUUVFRVxzh955JH//d//feWVV1auXLly5coDBw4EBwfn5ubOmzfv8OHDb7/99qpVq3bu3Onj4+OGD6VCIAQA8GCflYu/H3VTIFyYwuMHso5H4uLi3nnnnaCgoKysrLCwMPXBgQMHzp8/n4gSEhKGDh167NixyMjIlStX/vWvf928eTMRDR8+/MUXXySijz/+eOLEiXv27CEixlh9ff3x48cjIyPd8Fm6QCAEAPBgL1yhvHCFostbP/PMMytWrPj73//+s5/97Gc/+9lLL71ERIMGDWLsh2Dp6+vb1tbW3Nx89uzZvXv3Hjx4UH38zjvvJKITJ040NTXl5eWpD95zzz2+vr56fA4EQgAA6BNfX9/777///vvvr66uTkxMfOyxxy74tAEDBiQkJMyYMaNjHFGVmpqqKMqzzz7b+cGWlhYistvt6BoFAACje/LJJ1NTUxMSEgoLC0NDQyMiIs6cOXPBZz7zzDP33nvvb3/726SkpGPHjp06deqxxx5bsmTJhAkTwsLCpkyZUldXl52d/frrr/v7+6ekpDz11FPDhg27+eabIyIi3PBBMGsUAAD6YsKECVu3bn3xxRfLy8u3bt3q7+8fHh7+wAMPdDxhwYIFCQkJRHTHHXd8+OGH+/bte/XVVw8dOjR16lQiio+P37dvn8PheP311zdt2pSRkaFelZOTExkZWVxc3Nra6p4Pwty8XMMN1q1b98Ybb6xdu1bvhAAAuNjWrVt/9atfFRQU6J0QHTz++OPh4eEX64DtD7QIAQDA1BAIAQDA1BAIAQDA1BAIAQDA1BAIAQDA1BAIAQDA1LCgHgDAk5w8efLjjz/WOxU6OHz4cHh4uBavjEAIAOAxkpKSRo8ebc5A6OfnN3HiRC1eGYEQAMBjREdHf/DBB3qnwttgjBAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEwNgRAAAEzNovUbFBQUZGdnSyljY2MXL15ssfTiHbu5ds2aNTk5OUFBQeqfqamp8+fPd3HSAQDABLQNhAcOHCgoKHj66acVRdm2bdvLL7/88MMPu+rau+++e8KECRqkGgAATETbrtFVq1YtXLhQURQimjx5cmVlZX19vRuuBQAAcJK2gbC5udlqtXb8mZaWVlRU5IZrAQAAnKRh12h7e7ufn1/nR6xWa01NjauuXbNmzerVq4lISjlv3rxRo0b1O8kAAGA6GgZCu93u6+vb+RF/f/+GhgaXXDtp0qSRI0cOHz6ciJqampYtWxYeHt65BQkAAOAMDbtGLRZLW1tb50daW1udnDXa47URERFqFCSiwMDAefPmbd68Wf2zpKQkOzs7tJMNGzb065MAAID30rBF6OPj09LS0vmRqqqqpKQkLa4NDQ2tq6tT/52YmJienv7+++93/G/HKgsAAIAutJ0s4+/v33lgr7CwcNiwYV2e09jYWFpa2rdrOxw+fDghIaHjTx8fn5BOOMe+AQAAcGHaRog5c+a89dZbQggi2rFjR1RUVEhISOcnOByOhQsXLlq0aOfOnc5fW1ZW9tRTT9XW1qp/VlRUrFu3LiMjQ9PPAgAAXknbBfWjRo2qr69/8sknichqtT744INdnqAoSkpKSlFRUWRkpPPXxsfHL1iwYMWKFadPn1YUJTAwcMmSJQEBAZp+FgAA8EpMSql3Glxs3bp1b7zxxtq1a/VOCAAAeAAMngEAgKkhEAIAgKlpfvoEABhcbTNVNMnIAIoJZHqnxVzaBeVVyp21oslOUQNYVgwbFYqvQAcIhAAmZRf05mHx1+/Fd/U/TBRIHswWj+APjeQBqBi0988isXS3KDsrLZwCLXS6jYgoM4b93yRlRDDCoVuhvIOehKTPyuW6MnG8UVo4jQ5ldyTzy3FTrL3iRnlrvqPwpLwigv1pohI3kGqb6dNSseQrx5uHxYfXKWOH4FvQSpuge7c63jkifhTOXr7SkhnD/BSqbaZ3j4lnvnGkfWpfcbVyezLGrdwHgRB0U3hSLipwfHNKhvjRZSHsXCv9eb94bp+4cxh/cZIyxK/nV4C++fqUnLbRLiStylBmJ/67wn1gJP+8Si74wjFlvf2TDEtGDGKh67UJmp1r/6xc/mac8r9jOf9XHkcE0KOj+E+G8ds22+dtcZy106JLEAvdBBkN+vj7UTF5nf1kC70/Vamd5/PlTMuemy01P/F5YixfeVykfWLv6K8D1zrUILM22gN92M6bLJ2joGpqFPvqJsuwweymXPv2GnwFLiaJfval47Nyufwq5alx/46CHSIDKGe6ZXosu2+rY02p0CONZoRACDpYcVgs+MIxxcr2zbbckcwt/yqGwb70dJqybZbFLunaDfYDiIWu1tBGN+Y6FEb51yvDBl+4wRcZQLkzLLGB7OZce3kTvgJXeuGA+Mcx8bvxyj0jLlr3+im0Mt2SFsbu2uI4fBr57w4IhOBu2RXy3q2OGXFs/TRL6IX6P9PCWMFMxU9h12c7aprdnj6vdk+Bo6RRrs6wJA3qrtszzJ/WZSltgu7Y7HCgKnaRr0/JpV85ZifyX43poeINsNDqDMVfoTs2O9rQLNQeAiG4VelZOe9z++Wh7KN0i+/FS9/QQWx9llLXKm/fbEdF7Cr/OCZWHhfLxitXRvY8+JcSxF6brGyrkc9/i5rYBdoFLfjCER7A3rxacWboNSaQrZiifH1KPvMN8l9zCITgPkLS/C0Oh6SVGUpgT/O0xgxhr0xWtlTJP6AidoVTrfSLnY7JkezRUc7+6m9P5nOH8t/udRxFB12//eWA+LZOvjqZhzg9C2xWPJ83jD+zz3EE+a8xBEJwn1cOii+r5UtXKt33y3WYP5zfnsx/u9fxfQMqgv769W7H6TZafpVy/gSNbvzflYqfQg/vdGiWLlOoOke/+9pxcwKfFd+7KvdPExV/hX6B/NcYAiG4SdU5+vVux4w4dtewXpS6lyYpg3zo/q3oH+2Xb+vkm4fFQ5fyS0N6tyLCGkC/GadsLJfZFfgG+u6pvY42QX+6otf1bWQAPTlW+axc5lUi/zWEQAhu8us9jlZB/zdJ6dVVYf707ATly2r5UTE6SPvuf3Y7gnzpiTG9y3zVAyP5sMFs6VcOgaq4T46clm8fEfencic7Qrp4YCQfOoj9ajfuBTWEQAjusL9O/u2oePhSfrEp+924O4WPGcJ+vUe0IxT2yY5auaFcLhmtOD861ZkPp6fT+L46ufI4voC++O1e4a/Q//TpLoSI/BR6ahzfc1Kuw7JCzSAQgjs8USiCfOlXfaoLOKNnJyhFZ+Sbh1ER9MXTex0RAfTAyL7/2G9L4peGsP/3tUCjsLeOnpYfFov/SuXh/n1/kXnJfNhg9jtMH9UMAiForvCkXFcqHh2lBPv28RWmxbKrrOyZb0QrJg300t6TMrtCPnJZz9N0u8EZ/XoMP1Av15ahLu6d5/cLX4UeHdXH5qDKwmnpaL77hMy34U5EEwiEoLll34gQP3ro0n4Vtt+MU8qb5DtHURH3zvP7RZAv3d+P5qDq1iSePJhhTWGv1DTTu0fFguE8IqC/L/WTYTx6AHv+W9wJasLsgfCfReJHa+x6p8KbHWqQa0rFQ5fywT79ep30aDYxgj3/rcCcAeeVnZUrj4v7Uvub+USkMHrkMr69Ru6oxRfgrNcOijZBP7/MBdWsn0IPXso3VUjswasFswfC7xvk7hPSjttczfzlgPBT6IGR/eoaUi0dzYvOyNUl+Lac9fL3goge7HdzUPXTFB7iRy8eQP47pU3Qawcd18exlCDXHOJx7wgeYKGXvkP+u57ZA6GURETNnfob2gVtr5Eby2U1drnst1Ot9O4xcdewfs0U6HBjPB8exP6yHxWBU5rttOKwuCWBx7ro3PlAC/0sha8uEbZzaJT0bOVxUd1MD13qgltAVagf3ZnM3ysS6hG+4EKmD4RERHTuX52juZUy+UP75HX263PsMe+3377Zgd98f6w4LFrs9LAruoaIiDN6aCTfUSsLT+JL6dlHx8Wp1n5NFj3ffancIenNw8j/nr12UAwPYpkuPdPxv0bys+307jHcC7qY6QOh2iK0SyLKq5Q35NiD/Wh1hrJ1lmXpaL6uTIz7xL77BH72fSEkvXpQTI1mI4NdVhf8NIUP9KFXD6Ii6Nnrh8TIYHZNlCsr4uTBLDOGvXkII7U9ONggC6rl4hG92s+uZ2OHsAnh7I1DKP8uZvpASERE5xzU0EZ3bbGnBrNtsyy3JPLJkWzZeKXwZstAH5a50f7NKfzuey27QpY0yvtSXVnGBvvQncn8A/QO9eS7erm9Ri66+KF3fbZ4BC9vwo5rPVhxWPhy+ulwTfL/2zq5C1OWXMrsgVBdIHzOTn/81lHbQu9cowzqNL9uRDDbcoMS7MtmbXLUYsiwl944JKwBdHOCi8vY4hG8yU7voXeoW28fEb6cerWtq5NmxfPIAHoLmxtcXLugfxwTsxJcMzTexW1JPNBCbx1B/ruS2QOheltV10qvHhSzE/nYIV17MmID2dospa5Vzv/Cjnsw51U30/py8dMU7uPqIpYWxsYOYStQEVycWhHfmMDDNKiIfTj9ZBhfXyZOtLj+xb3DxnJR00wLNGgOEtEgH5ozlH9YLJqx7Mt1TB8IJRHR+8dE3cWnFVweyv58hZJTIdE177z3jgm7oLtTNClgiy7he09K9FdfzA8VsTaZT0QLUniboH8W4edwYX8/Jq0BND3WteOD//bTFH66jbDLjwuZPhASEdHK4yIusLtpBYtH8IwY9vhXDqypcNLfjopJEewSF62g6uKOZO6v0NtoFF7Eu8dkZABNc+l8xc4uC2Hjwti72OXnQupbaX2ZuD2ZWzSrXK+xsviByH9XQiAkImqy0y2JrJtqgxG9cqXS4qD/2Y0tjnr2zSm5v07O16ZriIhC/OimBP7PIpxHcQGn2zSviInormF8z0l5GCenn2flcdHqoJ9oMDrbgTO6M5ltqpTonXYV0wfCf/2Qb+ppTsfwIPbwpfxvR8W3dfjx9+Afx4Qvp1uTNCxddw3nJ1oouwKRsKvVJaLFQfOStf1p35bEFYbe0Qv4Z5EYEczSwrRqjqvmDePtgnAwlquYPhASEVFMt/2iHX41Rgn2pSf2oPB1R0j6oFheH8dD+3T6nZOyYli4P71fhJuSrj4oEsMGswnh2lbEUQPo2ij2AfL/P9nOyS+q5R0a34UQ0WUh7LIQhhsRV0EgpAEWWpupKE7UG8G+9MvLlXVlYg92Nrm4L6tlZZO8c5i2FbEPp7lJfF2paMLcuU5OtNDmKnlbkraZr7ojmR8+Lffit9DJyuNSSHJP/t+ezLfVyIom5L8LmD4QSvJTaJzT/RgPjuRD/Oh3X+NG7KI+KBKDfOiGOM2L1m1JvMlOOLa7s9Ulwi7oNi07pTvcksh9OX2E3rlOPj4uRodqNUesi1uHMiFp5XEEQhcwfSDsZRYM8qEHL+VrS8X3DSh/F2AXtKpE3JjAB/TjGFgnXRXJYgLZh8X4Iv7t42IxIpiNCnVHRRzqRxkx7GPk/7/YzsntNXKuW+5CiGh4EBs7hGGY0CVMHwgldTdb9EIeHKkEWOgFHEZzIZ9XyZMtdOtQd1TEnNHcoSy7QjS2u+HdPMCJFvqiWs51S+ar5g7lxY3oHf3B6hIpJM1xY/7PGcp31EocDNB/pg+ERL0ttmH+9NPh/B/HxEnMXT7Px8fFYB/KinVTubo1ibc4aB1WFhMR0aclwi5ozlD3/ahvTOA+HHMXf7DquLgsxE39oqrZiUxIWl2CQNhfCIS9bhES0UOX8hY7vYntFv+TQ9KaUnFDPPd32RFsPbgigsUFonfuB6tLxLDB7HK39IuqQv3o2iiGipiITrRQQbWcnei+zCeiEcHs0hC2Gjci/Wb6QCh73SIkotRgdl00e+0gDqP5D1urZW0zubMuYES3JLKcSswdpdNttNkmb3FvRUxEsxP54dMSQ+ZrS4VD0i2J7q5Rb0lkBTXyVKub39bbmD4Q9r5rVHVfKi89KzfhMJpOPikVARaaof180c5mJ/JmO20sN/tN8cZy0SZ0qIhvSuCc0aembxR+WiqSBrEx5+3ar7VbErhd0HqMDvSP6QNh7yfLqG5K4NYAeh3bcHeyplRmxvBA7eeLdnaVlUUE0CeoiEtl1ACaqPE6+vOpb/qpuRexnG2nvEp5U4K7M5+Ixoax+IEMNyL9ZPpASMT61Cb04fTTFL6hXGAbbtU3p2RJo7zZ7XWBwujGeL6hXLSZuCpuE7SxXMyK5y4+EN05NyXwPSdkpYlXdm+qFC0OutHVR286gxHdGM82VeJUpn4xeyAUfW0REtHCFG4X9A+cEEtERJ+WCoXRzHgdStRNCfx0G22pMm9FvKVKnmmnWXpkPhHdmMAk0doy8+b/ujIZ6kdXRepxG0J0YwI/Z6c8GyqivjN7IOzzGCERpQSxKyPZW4eFeSuATtaUyisjmRZHcvcoPZoFWmitiXvn1peJQAulR+tTEacGs+FBzLSLWISkz8rFjDhtj/voxjVRLMiX1pn4RqT/TB8I+zRrtMP9qfxgg8T05bKzct8pqUvXEBEFWCgzhq83cUWwrkxmxPAA947OdjYrnn1uk+acu7vrhKxtplnx+tyFEJEvp6wYvqFMmvcH0G+mD4R9WkfY4fZknhLE/mL6XWbWl0lJetYFM+NZ6VlpzhOy9tfJkkY5U7/MJ6KZ8bzFQXmVZvwhrC8TPpymu2sTiQuaGc9s5+TX2OKnrxAI+9UiVBjdM4Jvr5FHzH1C6YZykRLk1j01upgZzzkzae/QhnLJyB27nHfjqkgW7Esbyk2Z/2XyqkgW5KtnGmbEcYXRelPmv0uYPhD2Y7KMal4y54z+aeKD2c7Z6fMqeUOcni2SyAD6UTgz52qqDeUiLYxFDdAzDT6cpsWasXeuvEl+Wydv0GmaUodwf/pRONtgyvLvEqYPhP1rERJR1AC62mrqPeA322SznXSvC26I41+dkLUmW81S30o7a+UNuvaLqm6IZ7Zz8ptT5gqFG8ulJNL3LlB1Qzzfc9J05d9VTB8I+zdZRjVnKD9QLw+ZdZepz8rFIB+62qpzXXBDPBOSNlaY644kp0LYBc3QdYBKNT2Wc0afmax3bkO5TBrERgTrHwivj2NCUo4ph2n7T//fj776OVlGNTuRK4w+KDZpEdxYIdOjua/eRWnMEBYTyDaarCL+rFyG+dMEt28oc75wf5oQzj4z0153rQ7abBPTDdAcJKIxQ1jUANPdiLiK3rWX3iRR/zfjiBpAV1nZKlMeFX2wQZY0yhkGqAsY0YxYpraQTEJtAUyL1WdDmfNNj2W7amWdaTaA3lojz7YbojlORIxoeizfVIGTAPrCEF+hjlzSNUpEP040ae+o2gIzQiAkouvjWEMbba81y7ew95SsbabpsYbIfCKaEcsdkjaZpnc6u1z4KTRVp30MzjcjjtW10i7TlH8XMn0g7PdkGdWcoZwzWmm+RuHGCnFZCIsLNERdkB7DfbiJTqLIqZCc0TRjtEiIaHw4C/OnbNMcyZJdIadYmZt3me9GRjS3cMoxzY2ICxnlJ6QXl4wRElHUALoiwnR78DfZqaBaGqdFMtiHJkcyM1XEYtwQfba1uyCFUWYMz6kwxaaDFU3yQL00zl0IEYX40Y/CTVT+XchA36IuXNU1SkS3JPK9J2XpWROVws9tstVB03Vdyt3FjDi+75SsOqd3OrTX0EY7a6VBZmp0mB7LqptpnwkWUeRUSCID9UurpsfyPSdxTm+vGagK04WrukaJ6JYEJolMNWUmp0IMNMDCic6mxTJJpugd2mwTdqHzzl7ny4rl7F9BwrttqpSxgezSEAMVfiKaFsuEpFwTlH/XMtavyP36v7NMh+TBbOwQ9omZekdzKuW1UUz3hROdXR7KogbQpkrvr4hzKmSQrw4n8XbPGkCjhzCvvxFxSMqrFFkxxsp8IkoLY0P8KMcE5d+1jFSH6cGFLUIiujGB7agxS79EcaM8etpYYyRExIiyYnhupfD6caqcCpkerdvRP92YFsu21ciz7XqnQ0t7Tsi6VppmsH5RUodpY/mmCtPtdddPxvsZuVd/DuY938x47pCm6Jcjok0VkogMeFM8LZadbKFCr96J/8hpWXpWZhmvIiairBjeJuiLam/O/5xKqTDKiDFi/ZkVw2zn5Hf13pz/LmfEL9KdXNsiHDeERQaQSTY3ya2UiYNYin4nTlxMZgznzMt7R9VPZ8C7ECKaHMkCLV6+mjC3UqSFsVA/vdNxIZkxjP51n+qV2gW99J0449IuB9MHQtfNGiUizmh6LN9Y7v2bOzgkbbYZcYyEiML8adwQ5u0VsRw2mA0dZMT891NoShTL9d4bkTPttKvWoM1xIooNZCODWa73bjqaVyn/e4fDtTOTTR8IXbSOsMPMeHaqlXbUeG0toNp9Qja0/XDvaUBZsWxHrWz00mGqdkFbbMKwmU9EWTH8YIMsb/LOX8EWm2gXlGnIflFVViz7slq2OvROhzY2VYoBFhfvr2vc79I9XNs1SkRZsdyX0wZv39wkr1JyRtdFG7T8ZMXwdkFbqrzzW9hVK8+0G/cuhP7VO+etjcLcSjnQh66IMHL+83N22ualt+O5lfJqK/NXXPmaBq3I3MaFyydUg33oKitb7+1HpRt5jISIJkWygT5eO0ySZxMWTlONehdCRJeGsJhAr+0dzbPJa6zGWjXUxRQr8+Xklb2j6jwglzfHDfxluoUk6fL7ulnx/EC9N28xc7addtbKDMPsNXw+X07XWL22Is6tlBPCWLCv3unoVkY0y/fGRSzlTfJQg+srYtca6EOTIlmeN5Z/9UO5vDvE0F+nG7h2soxKPa7aiw8G+6JatgmDzh3vkBXLD5+WZV53O3K6jb46ITMM3C+qyohhJ1poX5235b9aEXtA/kfzvae88EisvEoZGUCjQhEIXcrlk2WIaHgQGx7kzSeU5lWKAAtdGWnouiDDS4eptlQJu+HvQogoI4Yzb8z/3EoZNYBGGmxntfNlxDAhabPNq2ohSZRnE+nRrj9/0+g/J6255GDe810fx/Jt8pzd9a9sBHmVcoqrB6tdbmSwdw5T5Rl+pobKGkCXhrA87xqmkkT5NpGhQUXscuPDWLCvt92IfFcvq85p0hzvORA+99xzLn9X49Cia5SIZsbxZjtttnlVKVRVnaPv6mW6gWdqdEiPZptt3jZMlWeTU4w9U6NDRgzbWiNbvGgS/7d1srbZA/pFiUidTuVlw4Tqx0nXYHZCz7+npUuXZsE8ccAAACAASURBVGZmPvfcc4WFhR0P1tfXuzwpunD58gnVlCg20IeyvXFNd75NSG3Kosupw1TfetEwVUWTPNTgGXchRJQRw5u9axK/pwwQqtKjWXGjLG70nvzPt4mUIBY/UI9AuGnTpoyMjLq6usWLF4eEhKhBcfHixS5Pii5cvnxC5ctpahT3yl2+8iplmD+NGeIBdUF6NGNEeV7ULs+3eVJFfI2V+XDK96Le0bxKMTKYRQ/wjPxX71a9plHYLuiLKqnRLXjPgTAzM3Px4sXjx4/Py8urr69/9tlniWjv3r1apMb9NGoRElFWLDt6Wh73otsxVb5NXhfNPWCQhCh6ABvpXcNU+ZUyQoMpcxpRxzK95kakTVBBtUz3kLsQIhoRzGIDWb635P9XJ2Rju1Z3gRZnnhQSEjJ37tzc3NzQ0NC0tLS0tLTg4GAtUuN+WswaVXVsrrF4hMf8cnp05LSsaPKYrjkiyohhbxwSrQ7yM/bUHiepdyEeVJ7So/n/+9pR30ohRt17wXk7a2WT3TMGBTqkR7MN5UJIxZMKzUXk26TC6NooTSqfXrxoZmZmUlLSxx9/XF9ff++992qRGvfTaLIMEV0SxBIGsmzv2txEu8FqjaRHs3N22l7rDd/C9w3Sdk6rriGNpEczh6TPvWKvu/xKoTC6RpuKWCMZMeykt6zmzKsU4zTbzcqpFmGHkJCQjIyMZ599NiMjIzMz05lLCgoKsrOzpZSxsbGLFy+2WHrxjt1f259X7qBd1ygRzYhj7x8T7ULx8aTfTnfybTJxEEse7DF18TVR3Ic78ivF1CiPbxLme9pdCBFNjGCDfCjfJmcn6p2Ufsu3yfHhRt/Qp4vrohkjyrfJsZ4wqN8NdTerR0dpVZP2/LqFhYXLly9fsmRJZmZmSEjI+PHji4uLnRwjPHDgQEFBwdNPP/373/9+9OjRL7/8svMp6/7a/rxyZ649mLeLrBh2pp12ekVzhIiEpC1VwrMq4sE+9KNwLxmmyrfJpEEGPXrpYnw4TbGyfM+fr9HYTl+d8LDmOBFFD2CpwcwL5isVVMt2LfeR6Pl1x48fv3fv3vHjx7/22mv19fVFRUUff/zxkiVLnHn1VatWLVy4UFEUIpo8eXJlZaXz6y66v7Y/r9yZpi3C66K5hXvPgfXfnJJ1rTQ1ysPqgvRotueEPN2mdzr6xy5oS5XwlPminaXH8MOnZYWHH8n0ZbVsF+RBo+Md0mNYQbVs8/BKKM8m/BW6UrN9JHr+Xh9//PFx48YVFxevXLlSHSAkotzcXGdevbm52Wq1dvyZlpZWVFTkZMq6v7Y/r9yZdmOERBTkS1dEeM8w4eYqSWTco5cuJjOGe8EwVeFJebrNw/pFVWqaPX3uYr4nbCt4QenRrMnu8f1Sm23yykgW0JfhL6f0/MJLly4NCQlR/11UVPTRRx81NDS8/vrrPQae9vZ2P7//GNm0Wq01NTXOJKv7a/vzyl1oN2tUNSOW/2+ho6aZIgM0fBf32GwTqcEsaoDe6eiliRFsoA/lVsqbE/ROSj/k2yRnhj566WJGhbKIAMqrlD8drndS+iHfJidHGn1bwQu6JoorzJFfKaZYPTD1RER0ooX2nZK/G69h+nsOhB1RkIiSk5OTk5OJqK6urscL7Xa7r+9/jCz7+/s3NDQ4k6zur+3+f4UQp0+f7tgHR1GU1NTULoGzg6Zdo0Q0PZb9eg/lVYp5wzyvCuusXVBBtVww3PM+hXcMU+XbxKgQFu6vdzp6jxFdF809ervB2mbaXyd/P8EjA0mwL40PZ3k2+ds0vZPSV59rv5tV13pt+fLlnbdSuxhnNiC1WCxtbf8xMtPa2urk3M7ur+3+fysqKvbt23fvvyxatKigoOBib6TRzjIdxgxh4f7kBb2ju2rl2Xa6zgO75ogoPdqzh6laHLS9xpOWcneRHs1s5+T3DZ6a/5s9Z1vBC0qPZrtPyMZ2vdPRV/k2GeRLaWFuDITjx4/PyMhgjM2dO7efG4r6+Pi0tLR0fqSqqioiIqL/13b/v/Hx8VOmTNnTSUZGxsXeSOsWIWc0LZZv8vwTSjVdzao1NYR4bqNkW41scXjkTA2VGkI8N//zbDLEj8ZpWRFrKj2atwv6stpT83+zTV4TxS1aFv8LvPbSpUvr6uo+/vjjjk7R5cuX9y0o+vv7dx66KywsHDZsWJfnNDY2lpaW9vZaZ17ZGZpOllFNi2W1zfTNKU8thap8mxgXxjx0f5DLQ1m4vwfP18ivFGoHr94J6aOhg1jSIA/und5sk9dGccVTs5/UaSYeuoiipFEeO6P5wpWugfCjjz5asmRJ53FBIrr33ntff/11Z7pMu5gzZ85bb70lhCCiHTt2REVFdXllh8OxcOHCRYsW7dy5s1fX9vjKTtJ6sgwRZXr+CaVNdtpV63mLqDqow1QeHAhtUp3y47nSY9iWKuHwwG+guFEeb/Tgwk9E/gpNjvTUTUfVZGud/11H7EJDQy/4vCVLlixfvjwtrXfjraNGjaqvr3/yySeJyGq1Pvjgg12eoChKSkpKUVFRZGRkr67t8ZWdpNHBvJ1FBtBloSzPJpaM9tSuLXUdksctnOgsPZp9WCwONcgRwR5WozW0UeFJ+cRYD858IkqPZm8coj0n5ETDHynchSdu6HO+9Gj+P7sdtc0U4WnT1/NtMmoAjQxxbyAsLi6+2FPvvffe5cuX93aX0SlTpkyZMqWbJyxbtqxv1/b4ys5wQ9coEWVEs9cOiRYHeeL0ayLKrxR+Cl3lgYuoOqjDhPk2zwuEX1QJh/TsuxAiui6ac+ZQm7Z6p6V38m0yJpB5XLHpIj2aSaLNNnF7sicVJDXNaqeaprpmijPrIryJ1pNlVOoJpVs9drA63yavjNBwNasbqJuTeeLZbPk2GWihKzwtfnQR7k+Xh7J8m4cNU0miz6vEdZ62m9L51AF+j+sd3V8na5rd0RzvGghvvfXWbpZGOLkK0INovXxCdW0U81Nok2cOVp9qpX110tNbJESUEcO+qPa8Yaq8Snm1lfl6fPZTejTbXiOb7Xqnoze+rZO1zR5zEnI31CnfHhcI1ZnGblg41PXnNXfu3Ly8vIvtoOZ97UVJxLRvEw6w0FWRzEPny3xuE0K6oyxqLSOa1bfSnhOe9C1UNsmDDVK7vYbdKT2atzhoW40n5b93DBCq0qPZ8UZZdMaT8j+vUqQEsbhAtwdCInrttdeysrLO31a7sLDQC1uE2s8aVWXG8H2nZE2zO97LtTbb5GAfmuCxi6g6XBfNOSPPOolC3d/VOyriKVHMl1OeR/WO5tnEiGAWo31F7AYZ/xom1zshzlLXPrqn8F8gECYnJ+/Zs+f1119Xl9U/99xz6hyZjIyMxx9/3A1pcif3TJYhoqxYJolyPbB3dLNNTolimq5mdY8wfxod6mFH0uRVSnV0Te+EuIA60ulBqwnVbQW94y6EiC4JYnGBnjRM/tUJ2djupn7pC1dvaWlpxcXFixcvXrly5dKlS++77z51ixZ1o1Fv4p7JMkQ0OpRFBFCOp+21VtkkD5+WUz1zQ5nzZcaw7bXynOcMU+Xb5NRorvmcOXdJj+F7T8m6Vr3T4ZydtfJsO2V6/qBAh/QYttnmMbtc5VW6bzeri75HSEjI8uXLpZTHjh2TUhYWFnpfFCSND+btjDPKiuG5lZ5SCH/w+Q9HL3lJXZAew1sdVOAh03cPNcjKJpnhLZlPRBnRTEja7CG9o7mVwsI9dVvBC8qIZqda6WsP2eVK3c0q1C27WfX8HXtl/OvgthYhEWXGsJpm2uchpVCVb5Nh3tI1R0RXRTI/hfI8pHc0311T5tzmR+FssI/HDFPl2+T4MBbk2/MzPUV6DGceMkx4tp121rrvLtB7bnb6xj3LJ1RZsZyRh51Esdkmp0Z5T9fcAAtdGcE8Zb5MXqVMGsSSBnlL7hNZOE2N5h4xTHWmnb46Ib1g4URnVnWXK0+4EfyiWrYLSnfXfGnTB0I3tgitATRmCNtU4QGlUHXktCw76211QUYM/7ZOnmjp+Zn6sgvaUiW8LPOJKCOGHTsjjzcaPRZusQm7oAzPXz7bRXo021ojWxx6p6MneZUiwEKT3bWblbd9zb3ltlmjKnWyRpOHTNZQFz56WV2cEeMZw1R7TsqGNm/LfCJSO7uM3yhUN/SZ5MnbCl5QZgxvtnvAas7cSjnFyty2J6XpA6G71hGqMj1qska+TQ71rq45IkoLY6F+HnAYSF6l5Mzjtxg934hgFhfoAb3TuZXymihv2NCnC/VDGbx31HZOfl8vM924j4TXfc+95M6uUSK6ysoCLJ6xmtAh6XOb8Ka54yqF0XWeMEyVZxPjhrAhnnkAZPcyYli+sY+qrvCiDX26UJu5Br8RzKuUkty6cMULv+lecedkGSLyV+jqSLbJE+bL7D7hnV1zRJQRw0rPyiOnjfstnG2nHTXeNjrbITPG6JP41TjhfXeBqswY/vUpedLAw+S5lTIygEa5cbK66QOhe1uERJQVyw/Uy4om49YCKrVrzmuW0nemVnCbDHxT/EW1bBOUFeuFmU9E6dGcM0Pnf26ljB7ALtX4DDy9ZMYwIcmwJ4FIorxKkaH90UudeecvzXluOJi3i2mxjDzhwPp8mxg7hIX5650ODSQNYsMGG7pdvqlCBFroSg8/euliIgJodCjLNer0aSHVitidXUVupQ6TG7b876+T1c3ubo6bPhC6d9YoEV0awqIHMCPfDhNRk522e2/XHBFlxbItVaLdoFUx5VbKKVHMzzOPcXZGVizbVmPQ6dNfn5InWijLewu/wigjhhu2CtpUKZnb+6VNHwjd3jXKiLJiWZ6xJwt8USXbvHERVYesGNbYTjtqjfgdlDfJgw1unTLnflkxvE3Qlioj5v+mSskZeXv+s4om+X2DIfO/QqitBXe+qTd/2c5w82QZ1bQYdrKFdhv4YLx8m/BX3Lea1f2mRnMfTsbc3EDtNvfiFgkRTY5kgRaD5v+mCqFuke/FsmIZkRF7R8/ZqaBaquNH7mT6QOj2FiERZcZyhRl6r7W8Sqmu9PBWg33oighmzMNAcipkTKDXztRQ+Sl0TZQRBwjOttP2Gpnl9orYzeICWWowyzHejciX1bLFocM0MQRCHVqEQ/xofLgRS6Gqppn210kv7hdVTYvle08Zbq81h6S8SuHdzUFVVgw/1CBLDLbX2udVok3QNC+dr9vZtFimRh1Dya4QARaaYkWL0L3cP1lGNSOWf3VCnjLkwWzqWVHeuoiqw7RYJqThNjfYfULWtZL7u4bcb3ocI6IcgzUKcyrkQB9vHhToMC2Wn7PTlwbb5SqnQl4b5b6d1TqYPhDq0TVKRDPimEMadIwkp0JGBNCYIV5eF4wbwsL9DXdUck6FVLx9pobqkiCWOIhllxsr/7Mr5NQo7n07q51P3cnTUP1SJY3yUIOcpkfhN8EX3i23HczbxfgwFu5vxGFCSZRbKTJjvOfopYtRZwZuqjDW7N2cCjEh3E2HkepueizLtxloEcvR07LojJxuguY4EQ2w0DVRbKORbkTU+lDtKnAzswdCvVqEai2cY7BamIi+OSVrmskkdcH0OFbdTF+fNMqXcKqVvjohp5tggEo1PZY1thvoJAQdK2JdTI/lBxtk6VkD5f/QQeySIARCt9Nl+YRqehyrMVItrMquUFezmqJgTIvhnNFnhrkpzq0QDmmWuxAiui6a+3LaWG6UJuHGCnFJkLcdt9KNGXGMiAzSKGwTlG8TM3S6CzFFfdcNSVKvUp8VY8QD67PLxdgwFunVi6g6RARQWhjLNswwycYKGeZPE8LNUhEP8qGrrcwgNyLNdtpSJfWqiHVxSRBLHmyU/N9aLc+20wydukNMHwh1mjVKRJEBNM5ItTARnWmnHbVmGSNRXR/Hdp2QdQaYviskZVeIabHePzrb2Yw4fqBelhtgD/rPq2SznWbEmatKvD6ObbaJVgMsothQLvwVui4aLUI96LKOsMOMOLajVtYboBZW5VWKdkHmGaMiouvjuF0YYvpu4UlZ20zXm6lFQkQ3xDEiQ/ROf1YuBvrQNW5fwaav6+N4k90Qe919Vi6vjWIDdNrEw0RV3gXpNVlGNTOO24WBZjBvLJfBvjTJSw89uKDxYSwiwCAVsVSYKZZydzYimCUPZhvK9M//DeUyI5p78UbnF6TGns/0HqYtOiMPNcjr9WuOm+tXdz5O5KNfHkwIZ+H+hqiFVdkVMiOGW8xUKDij6bF8Y4Vw6P0lbCgXV0R455H03bs+juXbRLOuJ1F8Vy9LGqXZmuNE5K9QejTfoHcVtL5MEtEN8brlv5nqvAt5b6rlF5fpdxvCaEYc/6xc/1qYiNTjgk01QKiaGc9OttBOXU+iqG6mwpN63hHraFY8P2enzbr2zq0vk0zXilhHM+NZ0RmdT6JYXy5GBus5X9eMP7zOrotmibrOlp4Vz0610g4DLKXaWC4ZmWjufoesGO7DaX2Znr1Dn5ULIWmmKSviKVY2yEfn/F9XJsaFufvoH4O4IY6xf7XJdHG6jb6skrMS9Mx8swdC3WXFcl9O6/XuoyeijeVi9BAWE2i6uiDIl6ZY2Tpdh6nWlcqEgezyUNNlPhH5KZQVy9eXSb2+gBMttLNWzoo3aWUYE8jGhrG1pbpVQTkVok2Qvvlv0u/eOAb70LVRbE2pzi3C0220tcaMYySqWfH8u3pZrNNJCM12yq0U5mwOqmbFs4omuVenzSU2lAmHpFkmzv8b4/nOWt1OYllbJsP96Qpd5+ghEOrvxgR+qEEeOa1nLMyuEO2CbjDlGBURqd0y63S6Hcm3ySY73Zhg0swnohviuIWTXo2StWUyfiAbG2beQHhTAnNIfXqn2wV9Vi5mxnNF1+w372/PONSmgM5dc2UyIoAmmmnhRGdJg9jloexT3SpiEeRL10aZNPOJKMyfJkfq0y/SbKdNFeLGeB2XE+tvzBCWOIh9qkf+f1kt61vpJl0HCAmB0AgSBrLRoWydfpMF7II2lovr43S+KdPXTQlsa40OJ0QKSetKxYw4Uxz9042bE/i+Oh16pzdViiY73Zxo7twnuimB5VaKJrcvYvm0RARaKEvvzY3N/vUbxI0JbJsetbBqa42sa6UbTTxGQkQ3J3C7oHVubxTuqJXVzXSz3nfEulNz4NMSdwfCT0pkqJ/pNpQ53y0JvNnu7g3QJdGnpXJaLA/QaUOZDgiEhnBjArcL3fZ3+LRUBFgoy2R7mnQxNowlDGSfuL136JMS4aeQOVcQdpY4iI0dwlaVuPUn0C5oXZmYFW+uTSQu6CorC/enT9x7I7KrVlY0yVsS9b8LMf33bwxpYSwukK0+rs8w4dpSmR7NAvW+KdMXI7olkW2qEI3tbn3f1SUyI5oN8nHrmxrTj4fynbXSds59v4ItVbKulWYboCLWncLo5kS+odytG3CvLhG+nGYaYOGK/ikAImJENyeyTXr00e+rk8cb5c0mnrLYYXYib3G4tV2+96Q83ihnD0XmExH9OJEJSavd2ChZeVwM8jF7X0iHHyfy022UW+mm/JdEK4/LzBgW7OueN+wOSoBRzE7k5+yU7fbe0U9KhMJMPXe/w+RIFj2ArXRju3xVifDhdBMyn4iIRgSzy0LYyuNu+gnYBX1SImbFc3+TbbR9MddFs1A/+qjYTflfeFIeb5RzjHEXaIhEABFdbWURAbRSj8kC6vAAcEazE9ln5e5rl39ULKdGmXGj7YuZm8QLqmXVOXe81+dV8kQLzU1Cv+gPfDjdksjXlokWt/SOflgkfA1zF2iIRAARKYxmJ/L1ZW7dhr/ojPy2Tt5ijLJoBLcm8XN2N80dLTwpj52RtyYh8//t1qFMSDc1Sj4sFoN9zHX6Zo9uTeKn28gNp4VLoo+Oy6xYFmKMu0AUAgOZM5SfbaeNbjyecHWJVIcn3faOBjc5ksUEsg+K3dEu/7BY+HKabfoVbJ2NCGZjhrAPtQ+EbYI+KRE3J6Jf9D9cF8UiA+ifRZqX/23VsuysvN0wd4FGSQcQ0bVRLDKAPnRLLaxaeVyMD2cJAxEIf8AZ3ZbEsitEQ5u2bySJPiyW02K5Qe6IjeOOZL6zVvOV9RvLRV0r3ZGMCvA/WDjdmsTXlWk+d/qfxSLQYpR+UUIgNBSF0Y+H8vVlbhqjKm6Uu0/IucYYrDaOO5J5q4NWaTxlY6t6R5yMW5Cu7khmjNH7x7QNhO8dkxEBlBGN/O/qzmTebNe2/LcL+qhY3JjABxpm1RAqQWO5LYmfs7tp91u16XkrJgv8p/Fh7JIg9o9j2n4F/zgmBvoY6I7YOOIC2RSrtvl/uo3WlYnbk7CO/gImRrBhg7XN/43l4mQL/WSYgXLfQEkBIroqksUGsg+076Mnog+KxKRI9ItewE+G8S+rZdlZrb6FFgd9fFzMTuQm38TgYuYP54dPy521WuX/R8WixUF3DUftdwGM6K7h/PMqDcv/O0elNYCyYgxU86AoGIs6RrWxQtRrvO/o/jr5bZ2chzGSC/nJMEZEfz+qVUWwtlTUt9JdRrojNpQ5Q3mghd45olWj5J2j4tIQNt7E5y51b76W5f9EC20oE/OGGas5bqS0ABERzRvGWx30scZjVO8XCR9Ocw0za8tQEgexa6zsb0eFRpHwnaMifiC7DgNUFzHIh+YM5R8Ui3MaDJYfbJDba+TdKSj5F5U4iE2NYm8f0aT8v3tUtAlaeImx8t9YqQEiGjuEXRbC/nZUw0AoJL13TGbFYB39RS28hB87I7+ocn1VUN4kN1XIBcMZRxy8uIWX8NNtmtwOvnlY+HKaj37Rbv3sEl7cKPM12G7tzcNiUgQbGWys0o/SYEQ/TeE7ajQ8s/7zKlneJFEXdOPHiTzEj9445PqK+K3DUhKhRdK9q61sRDB73dX53+qgvx8VNyVw3AJ2b3YiD/On5a7O/y+r5cEGuXiE4Qq/4RIERHTXMG7h9LZmYyR/PypC/LC/aHcCLHTXML6qRJxsceXL2gWtOCyyYljiIGPdERsNI7p3BN9eI7+tc+Xt4EfHxckWui8VJb8HfgrdncLXlArXHgby6kER6ke3GW9ExnAJAiKKDKDr4/jfjgq7BqGwsZ1WHRe3DsWeGj24N5W3OVx8O7KhXJQ3yXtRETvhp8P5AAv99XtX5v/L34vUYDYVo7NOuC+VOyS5sFFedY5WHRcLUvQ/hvd8+EEa1D0jeNU5Wq/BYRQfFIkmOy1A11xPRgaza6PYKweFw3X3xH/9XsQPZLMMcACb8YX40U+G8feOiVMumkG9q1buqpUPjMTgrFOSBrEb4vhrB122B/erBx1C0gMjjVj4jZgmIKLpsSwukL120PWBcPkhcXkouyICtUHPHrqUlzTKNS7ag/tAvcyvlP+VyhXkvXMevow328lVv4I/HxAhfvRTDI077eeX8Zpmes8Vi+vP2enVg2JWPE8y5KAAyoRBKYzuGcFzK+WxM67so99VKwtPyvvRNeecGxN40iD25/0uqoj3iwEWMuBMAcMaGcymx7GXvnP0v1FS3ChXHReLRxhoWy/juy6ajQtjf9ov+r+QYsVhcbKFHrvcoIXfoMkCIrpnBLcwetWljcKXvhdBvjQPS7mdozD6xSi+rUZure5vTVDRJN87JhZegl22e+fxy5WaZnrrcH9/BX/YJ3w4/fwyDIz3zpLL+cEGubqkX/nfJuj5b8XVVnZlpBGbg4RAaGTWAJqbxFccdtlO8FXn6ONisTCFD8JNsdMWpvCIAFr2TX+bJM9/KyTRo6Pwi+uda6PY5Ej23LeitR/fQHmTfOeouDuFWwNclzJz+PFQPiKYPf11vxqFbx8R5U3yibHGvQvBz9LQfn4ZP91GK/p9O6x6+XuHw6iD1YY1wEKPjlKyK+Sufmx9aTsn3zgs7hrGsbNrH/xmnFJ2Vr7Rj1/B//taENGvxqDk95rC6KmxfH+d7PNpyS0O+t3XYnIkM9Tmol2gZBja+DB2TRT7ywHR3u9Q2GSnVw+KmxJ48mDjFkdjemAkjwigX+/pe5Pk998Ih6AnxuLn1hcZMWxqFPvd146+dY0cbJBvHxH3pfK4QJT8vrg1iY8Zwp4oFG19qoVePCAqmuTvJxi3OUgIhMa3dLRSdlb2/1SUNw6JulZ63KiD1UYWaKEnxij5NplT0ZdG4ZHT8vVD4p4RfKgh58t5hD9MVE600O/71EH9y10O9Rt0eapMgjN6/kdK0Rn5l97PGqs6R7//xnFjAp9iNXThR7VodNNjWVoY+/03/Vpc3+KgP+0X10axiVg10Sf3pvLhQeyRnY4+NM0f2ekYYKEnDTxAYnzjw9j84fwvB8ThXu47+Gmp+KxcPjVOCcOeav2QEcNuSuC/+8bR27OZHt3laBP0p4lGDzRGTx8Q0W/GKcfOyP5scfLaQVHRJJ8ch7q4j3w5/eUK5fsG+ade3hR/UiI2lMunxikRmKbRP89NUAItdE+Bw/lZGw1t9NB2cXkoewjj4v32f5M4ES3e2ovtJdaWin8Wif8Zowwz/HAMyocHmBnProxkv/26j6fSNLTRsm8cWTFsapTRi6OR3RDH5gzlT3/tONTgbFVQ10oPbHeMHYKK2AUiAugvVygF1b24F3lwu6OmWb41RTHU0XceKn4ge/5HSk6FfOk7p/K/upkWb3WMHcKWjPaA3PeAJAIRPf8jxdYk//BtX8ZInt7rqG+lP0xEc7C//nqlMtBC87Y4nJnKL4kWFThOtRAqYleZP5zPHcp/vcfxpRPLOl87KN47Jp4ap6ThAF4XuTeV35TAH9vl6HFZbauD5ubbz7bTe1MVX08o/J6QRiC6MpLdnsz/8K0o6uVGM9/Vy79+LxZdwkeHojror8gAemuK5euT8v5tPUfCP+wTn5SI536kjBmCnHeZFVOUYYPZ7Fz7wW7b5RvL5X/vcMyMZ7/yhOaIp2BE71yjDB3Ebs6177/4qSB2QXdtcWyrlu9cneX1UwAAFGNJREFUo6Qa7NzBi0Ep8Rh/nMh9ee/66IWkewocwb60zNhzlz3IzHj21Djl7SPiiW5XU/ztqPifPY47kvnDl+En5kqDfGj9NMVXoes22L8+deGfwqelYnaefXQoe3+qBRtsu1awL22crgRY2NQN9gu2yxvb6cf5jo+Piz9docwZ6jGF32MSCtED2B8nKptt8v8OODtG8ucDYket/MsVyhBs6+U6T47ji0fwZd+Ih7ZfYBKpJPrTfrHwS0dGNHt7CrbXdr2kQWzz9RY/hU1eZ//Lgf9Y3NbQRr/Y6fhxnmPsEJYzw4IdlLQwdBD7cqYSHsDSP7M/ustR3fzD4w5JHx8Xo1fbPysXr0xWfuFRt4BMSq2OQdfLunXr3njjjbVr1+qdEE3cnOvIrhBbbrD0eHzEl9Uy4zP7jQl8ZTqagy4miR7f5fjjfjFmCPv9eGVaLFNbHjtr5ZOFjtxKOXco//u1Ck581E5tMy0qcKwrE9YAyorl1gAqbqScCtFkp/9K5c9PROZrq7GdfrnLoW56NTKEBfnS9/WyrpUuDWGvX6UYdk/Ri0Eg9DD1rTRxrf1Mm9w6y9LNpOSDDXLKenu4P9t5k2Uw7ou1saZU/HynKGmUwb6UNJiVn5UnWmiIH/1uvHJvKvrk3CHfJpcfFNtr5Zk2GebPMmLYQyP5KAyHu0vRGfmPY7LwpGxxyKGD2Mx4dkMc98Sij0DoeY6cllevt/tyljNDGXmhsehv6+T0bDsRFcy0YEM1TbUJWlsq8m3yVAsN9qXJkWzuUBz0A+BhLG54j4KCguzsbCllbGzs4sWLLZZevGk3165ZsyYnJycoKEj9MzU1df78+S5OuiGlBLH86y1ZG+2T1thfnKTMH/7vWzCHpLePiEd3OoJ82aYZCqKg1nw5zRnK5wzVOx0A0A+aB8IDBw4UFBQ8/fTTiqJs27bt5Zdffvjhh1117d133z1hwgQNUm10l4Ww3TdZ5m1x3P2lY9k34sYENnQQKz4jPy2VxxvlNVHsvWuVGGwxDADgBM0n9qxatWrhwoWKohDR5MmTKysr6+vr3XCt14sJZJ/fYFmVoQwdRK98Lx7a7njtkEgJok8ylc9vsCAKAgA4SfMWYXNzs9Vq7fgzLS2tqKho/PjxWl9rBoxodiKfncgdks600SAfwg4mAAC9pW0gbG9v9/P7jyVsVqu1pqbGVdeuWbNm9erVRCSlnDdv3qhRo/qdZI+kMArBSkEAgD7RNhDa7XZfX9/Oj/j7+zc0NLjk2kmTJo0cOXL48OFE1NTUtGzZsvDwcKvV2tjYWFRU9Nxzz6lPY4zddtttCQkJ/f0wAADgjfobCLOzs7/44osuD4aEhDz66KOKolgslra2ts7/1dra6uSs0R6vjYiIiIiIUP8dGBg4b968zZs333nnna2trW1tbZ1HE8+cOdOrDwUAAObR30A4ffr06dOnX+x/fXx8WlpaOj9SVVWVlJTkzCv39trQ0NC6ujoiCgsLS01NffbZZ515FwAAMDnNJ1f4+/t3HtgrLCwcNmxYl+c0NjaWlpb27doOhw8fRv8nAAD0luaBcM6cOW+99ZYQgoh27NgRFRUVEhLS+QkOh2PhwoWLFi3auXOn89eWlZU99dRTtbW16p8VFRXr1q3LyMjQ+uMAAICX0Xz5xKhRo+rr65988kkislqtDz74YJcnKIqSkpJSVFQUGRnp/LXx8fELFixYsWLF6dOnFUUJDAxcsmRJQECAxp8GAAC8DfYaBQAAU8MCbAAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDUEQgAAMDVTB0IpZU5Ojt6p8CTV1dXffPON3qnwJLt27aqvr9c7FZ4kOztb7yR4koaGhp07d+qdCo9n6kBYV1c3b948vVPhSTZu3PjSSy/pnQpP8uyzz3755Zd6p8KTzJw5Uwihdyo8xrZt25YtW6Z3KjyeqQMh9JaUUu8keB5kWq8gu3oF2eUSCIQAAGBqCIQAAGBqFr0T4Ho1NTWFhYW33nprj89sa2s7e/asM88EVUlJycmTJ5Fjztu9e/eJEyfef/99vRPiMaSUt912G2NM74R4hqqqquLiYvwku5GZmXnPPfd0/xzmfV3MtbW1H374odVqdebJJSUliYmJGqfIezQ1NZ07dy48PFzvhHiMqqqq0NBQPz8/vRPiMfCT7JXW1ta6urqoqCi9E2Jco0ePTklJ6f45XhgIAQAAnIcxQgAAMDUEQgAAMDUEQgAAMDUvnDXaoaCgIDs7W0oZGxu7ePFii6UXH7Y/13qo9vb2N998s6qqqr29PTExccGCBc5P8VizZk1OTk5QUJD6Z2pq6vz58zVLqSH08yObrYAVFRX95je/iY2N7Xikurr6oYceGjdunDOXm6eAORyOAwcOOByOC+YM6jStSC+1f//+ZcuW2e12KeXWrVtfeOEF91zruZ5++umvv/5a/ffOnTv/8Ic/OH/tp59++tVXX2mTLoPqz0c2YQGrr6/funVr50f+/Oc/l5eXO3m5SQrYyy+/vHTp0hdffHH58uXn/y/qNO14bdfoqlWrFi5cqCgKEU2ePLmystL5vY/7c62HOnXq1PDhw8eMGaP+OXHiRLvdfvbsWX1T5a1MWMCCg4MnT57c8aeUsqqqqnMDEYhowYIFzzzzzC233HLB/0Wdph2vDYTNzc2dlxKmpaUVFRW54VoPNWTIkNtvv73zIw6Ho6mpSa/0eDcTFrAuDh48mJqaqncqDGfAgAHd/C/qNO14Zzdxe3t7l/Etq9VaU1Oj9bVeo6SkxOFwREZGOn/JmjVrVq9eTURSynnz5o0aNUqz1BlF3z4yChgRbd++fcqUKb26xIQFrDPUaZryzkBot9t9fX07P+Lv79/Q0KD1td6hpqbmlVde+fWvf+38JZMmTRo5cuTw4cOJqKmpadmyZeHh4U5u7uOh+vyRUcCI6MiRI4sWLXL++SYsYF2gTtOUd3aNWiyWtra2zo+0trY6OUuqP9d6gerq6ueff/6Xv/xlxww9Z0RERKiVFBEFBgbOmzdv8+bN2iTQKPr8kU1ewIiorKwsPj6+V5eYsIB1gTpNU94ZCH18fFpaWjo/UlVVFRERofW1nq6ysvK555577LHH+vl5Q0ND6+rqXJUqj+D8RzZzAVNt3779qquu6s8rmLCAoU7TlHcGQiLy9/fv3AleWFg4bNiwLs9pbGwsLS3t27Xep6ys7Pnnn1+6dGk3Q4MXy7EuDh8+nJCQ4NLUGd0FPzIK2AXt37//YiN8KGDdQJ2mHa8NhHPmzHnrrbeEEES0Y8eOqKiokJCQzk9wOBwLFy5ctGjRzp07e3ut9ykpKXnppZeeeOKJjii4e/dum83W+TkXy7GysrKnnnqqtrZW/bOiomLdunUZGRnuSbkunPnIKGAXdOrUqZCQEHUefxcoYN1DnaYdr+0mHjVqVH19/ZNPPklEVqv1wQcf7PIERVFSUlKKiorObwD1eK332bRpU2tr6wsvvNDxSFVV1QMPPBAdHd3xyMVyLD4+fsGCBStWrDh9+rSiKIGBgUuWLAkICHBf6t3OmY+MAnZB/v7+d9xxxwX/CwXslVdesdlszc3NtbW1ZWVlRPTAAw90HLGEOk07OIYJAABMzWu7RgEAAJyBQAgAAKaGQAgAAKaGQAgAAKaGQAgAAKaGQAgAAKaGQAgAAKaGQAgAAKaGQAhgdKWlpc3Nzc4/v62tLTMzs6CgQLskuZn3fSIwFK/dYg28z/bt23Nyco4cOSKESEpKuuaaa6ZNm/buu+/Onz9f76Rp6913350xY0ZaWpreCXGBLVu2PPPMMx3H47W3t/P/3979hzTx/3EA39yc2soMtFlmZom5GBX1h0G/EXRJ4SYFofbDRrM0FV2UoVJJ9E+J+CPyt1T+4QzFWtaGzkk1MSsskzRRx2xOSxNZzrmdt33+uC/juLPa16Zt+nr8dXvf6873U2Gv3Q9vLi7WR48ajcbS0tJNmzb9s/mBZQkaIXACKIrm5eUNDg7Gx8eHhIS4ubkNDQ1JJJKmpqb+/v4l3wjNZjP2uGQbMRgMqVTq4uKg53siIyNTU1Ox5dLSUn9//yNHjmAvU1JS5tzEwRMBZweNEDiBx48fz8zMFBYWWg8dgoKC0tLS6urq+vr6/u3cHNOcX+/gCPDHf2Q0Gu1X3c5hE4ElABohcHQ/fvyQSCTFxcXkt8Jjx47Ned2oqalJLpcPDAwwGIwtW7bweLxdu3bhC1pbW3Nzc318fMrKympra5VKpUajYbFYfD4/IiKCSqViZSqVSiQS6fV6Go3GYDCys7Ox85P19fVVVVWzs7MWi8XLy6uqqsr6ZQhTU1M1NTUfPnzQaDQeHh7BwcF8Pn/nzp1zRuvq6qqrqxscHJyamvLz8wsNDY2MjHz16hWPx8MKEhIStFqtyWRqb2/Hxw8MDCwoKCDv8OrVq58/f6ZQKAiCpKenh4eHEwoWOtEfhYaGcjicX63NyMjw8fH5vxLdu3evsbExMjIyMDCwtraWTqfHx8fv3bv3wYMHMpnM3d09OTmZ8Ne3byKwFFgAcGwKheLOnTs2FptMpmvXrmVkZHR3dxsMBp1O9+bNm/PnzxcVFREqx8bG4uLicnNzm5ubtVqt2WxWqVQXLlyoqakhVFZWVpaXl5N/1q1bt16+fIkf6evrO3XqVHV19cjICIqiOp2ura0tMTGxsrKSvHlpaWlCQkJHR4dOp5udnf369WtFRQWfz09OTiZU3rx5s6Ojw8bfAKawsFAmk/1q7QIlmoeSkpLnz5/bUvmbRAqFIi4u7saNG1qtVqvVxsTE5OTkFBQUTExMtLe38/n8qampRUsEnBE0QuDoysrK6uvrbSwuKSnJy8sjDCIIkpqaKpfL8YNjY2NcLrenpwc/ODo6evz4ccLmY2NjJ06cMBqN+MGJiYm4uDjsEAqj1+vPnTv36dMnwuZGozEtLa21tRU/qFQqk5OT8Ztj6uvrF6ERLkSi+bFXI7x8+bJ15vn5+dnZ2da1IpGoq6sLW16ERMAZwcVn4OgQBHF3d7el0mAwNDc3X7x4kTBOp9NFItGjR48I4+vWrQsJCcGPsFgsKpWq1+vxg97e3tu3b29pacEPNjY2crlc/OnKzs5ONptNPu/HYDCEQqFYLMYPisXipKQk8sneiIiIo0eP/iHnX1uIRP9WQECAdeZeXl74O2w9PT0RBMGWnSgRWExwjRA4Og8Pj58/f9pS2d/fv3XrVjc3N/Iqf39/g8Gg1+uZTObvdzLnTRk8Hq+oqIjL5WIvURSVyWSEq3T9/f0KheL169dz7hZFUeuy2WzWaDRBQUHkshUrVpAvgy0E+yZyFksvEbALaITA0bHZbJlMZmOx9T4XMhqNNjs7O785cDgcKpXa3d2NHUy0tbVxOJw1a9bga3x9faOiooRC4R/3ZjabLRbLb6a6COybyFksvUTALuDUKHB0HA6nt7d3eHh4zrX4T/FBQUG9vb0mk4lcNjIyQqPRVq9ePe9p8Pn8hoYGbPnJkydRUVGEAjabrVQqbTmqoNPpLBZLpVLNezJ2YcdEzmLpJQJ2AY0QODomk5mYmHj79m2dTkdYNTo6KhAIRkdHsZceHh6HDx8uLi4mlKEoevfu3ZiYmL+ZxqFDh7q7u8fHx9Vq9czMDOHiIoVC2bhx4+7du8vKysjbIghCaHtRUVFFRUXkd2SDwVBeXj4yMoIfXLVq1eTk5N9Mfk72TeQUll4iYBfQCIET2LdvX3h4eFJSklQq/f79u9lsVqvVDQ0NmZmZQqHQ19fXWikQCIaHh7Oysr58+WIymaanp9+/f5+UlBQQEGC9HjY/DAYjIiLi2bNnT58+JR88YYRCoVqtzsrK6unpMRqNCIJg8zxz5oxUKsVXcrlcPz+/lJSUzs7O6elpFEXVavWLFy8EAoFer1+7di2++MCBA9XV1dgNrgiCDA8PSySSS5cuvXv3znESOYullwj8ParFYvnXcwDAJlqttra2tre399u3b+vXr+dwOLGxsZ6enuRKqVTa0tKiUqlcXV03b94cHR1N+JfqgoICuVxuMBiYTGZ6evr+/fspFMrQ0JBIJJqcnGQymRkZGXv27CHsdnx8/PTp0ytXrqyurrY+LZNMLpe3tLQMDAzMzMx4e3vv2LEjLCxs27Zt5Mq2tjaJRKJSqUwmE4vFYrPZ0dHRGzZsIFcqlUqxWKzRaMxms4+PD4fDCQsLI9z9eP369Y8fP2LLRqORRqPR6f+7CYDH4509e5a8W7snspFEIqmoqKBQKCaTiUqlurq6uri4ZGZmEp6nakui+/fvNzY2oigaHBycn59PoVAePnwoFosPHjx45coVCoWSk5Pz9u3bkydPxsbGLlwi4NSgEQIAAFjW4NQoAACAZQ0aIQAAgGUNGiEAAIBlDRohAACAZQ0aIQAAgGXtP7IqLaC1TOSjAAAAAElFTkSuQmCC", + "image/png": "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", "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", "0.0\n", "\n", - "\n", + "\n", "2.5\n", "\n", - "\n", + "\n", "5.0\n", "\n", - "\n", + "\n", "7.5\n", "\n", - "\n", + "\n", "10.0\n", "\n", - "\n", + "\n", "Convective Time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−0.05\n", "\n", - "\n", + "\n", "0.00\n", "\n", - "\n", + "\n", "0.05\n", "\n", - "\n", + "\n", "0.10\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0.0\n", "\n", - "\n", + "\n", "2.5\n", "\n", - "\n", + "\n", "5.0\n", "\n", - "\n", + "\n", "7.5\n", "\n", - "\n", + "\n", "10.0\n", "\n", - "\n", + "\n", "Convective Time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−0.05\n", "\n", - "\n", + "\n", "0.00\n", "\n", - "\n", + "\n", "0.05\n", "\n", - "\n", + "\n", "0.10\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 38, + "execution_count": 140, "metadata": {}, "output_type": "execute_result" } @@ -1364,58 +1381,6 @@ "#plot!(Δt:Δt:tf, 2momtheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Calculate error and number of elements" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "ename": "LoadError", - "evalue": "UndefVarError: `forces_tmin1em1` not defined\n\nSome of the types have been truncated in the stacktrace for improved reading. To emit complete information\nin the stack trace, evaluate `TruncatedStacktraces.VERBOSE[] = true` and re-run the code.\n", - "output_type": "error", - "traceback": [ - "UndefVarError: `forces_tmin1em1` not defined\n\nSome of the types have been truncated in the stacktrace for improved reading. To emit complete information\nin the stack trace, evaluate `TruncatedStacktraces.VERBOSE[] = true` and re-run the code.\n", - "", - "Stacktrace:", - " [1] top-level scope", - " @ In[39]:1" - ] - } - ], - "source": [ - "println(\"Error from reference = \",norm(forces_tmin1em1-forces_ref)/norm(forces_ref))\n", - "println(\"Total number of vortex elements at tf = \",sum(length(states_tmin1em1[end][2][j][i]) for i = 1:2, j = 2))\n", - "println(\"Total number of vortex elements in ref at tf = \",sum(length(states_ref[end][2][j][i]) for i = 1:2, j = 2))" - ] - }, - { - "cell_type": "code", - "execution_count": 235, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Error from reference = 0.004194867745700374\n", - "Total number of vortex elements at tf = 386\n", - "Total number of vortex elements in ref at tf = 2208\n" - ] - } - ], - "source": [ - "println(\"Error from reference = \",norm(forces_tmin4em1-forces_ref)/norm(forces_ref))\n", - "println(\"Total number of vortex elements at tf = \",sum(length(states_tmin4em1[end][2][j][i]) for i = 1:2, j = 2))\n", - "println(\"Total number of vortex elements in ref at tf = \",sum(length(states_ref[end][2][j][i]) for i = 1:2, j = 2))" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -1425,7 +1390,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 149, "metadata": {}, "outputs": [ { @@ -1478,7 +1443,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 146, "metadata": {}, "outputs": [ { @@ -1488,176 +1453,176 @@ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0\n", "\n", - "\n", + "\n", "5\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "15\n", "\n", - "\n", + "\n", "20\n", "\n", - "\n", + "\n", "25\n", "\n", - "\n", + "\n", "Convective time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−30\n", "\n", - "\n", + "\n", "−20\n", "\n", - "\n", + "\n", "−10\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "20\n", "\n", - "\n", + "\n", "30\n", "\n", - "\n", + "\n", "Effective angle (deg)\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0\n", "\n", - "\n", + "\n", "5\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "15\n", "\n", - "\n", + "\n", "20\n", "\n", - "\n", + "\n", "25\n", "\n", - "\n", + "\n", "Convective time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−30\n", "\n", - "\n", + "\n", "−20\n", "\n", - "\n", + "\n", "−10\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "20\n", "\n", - "\n", + "\n", "30\n", "\n", - "\n", + "\n", "Effective angle (deg)\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 50, + "execution_count": 146, "metadata": {}, "output_type": "execute_result" } @@ -1673,7 +1638,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 147, "metadata": {}, "outputs": [ { @@ -1793,126 +1758,126 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 148, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, - "execution_count": 62, + "execution_count": 148, "metadata": {}, "output_type": "execute_result" } From 366ca5fe6726197ac2c67abf18bcdbd46f741415 Mon Sep 17 00:00:00 2001 From: Jeff Eldredge Date: Tue, 22 Aug 2023 08:09:03 -0700 Subject: [PATCH 05/11] Some further refinements --- Project.toml | 1 + ...brid Model Force Compare Oscil Heave.ipynb | 1602 +++++++++++++---- 2 files changed, 1220 insertions(+), 383 deletions(-) diff --git a/Project.toml b/Project.toml index eed8da0..7429ff5 100644 --- a/Project.toml +++ b/Project.toml @@ -18,6 +18,7 @@ PlotUtils = "995b91a9-d308-5afd-9ec6-746e21dbc043" RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" Reexport = "189a3867-3050-52da-a836-e630ba90ab69" SchwarzChristoffel = "6e93f119-a087-51f0-a155-b73ce4943121" +SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" UnPack = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" [compat] diff --git a/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb b/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb index be46b17..7342d4e 100644 --- a/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb +++ b/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb @@ -282,16 +282,16 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 107, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "new_element" + "counter_min (generic function with 1 method)" ] }, - "execution_count": 7, + "execution_count": 107, "metadata": {}, "output_type": "execute_result" } @@ -314,7 +314,7 @@ "function new_vortex(blobs::Vector{T}, edge, α, δ, plate, motion) where T <: Vortex.Blob\n", " Δz = (blobs[end].z - edge)/2 \n", " #Vortex.Sheet([0.5, 1.5] .* Δz .+ edge, [0.0, 1.0], δ)\n", - " Vortex.Sheet([1.5, 0.5] .* Δz .+ edge, [0.0, 1.0], δ)\n", + " Vortex.Sheet([1.5, 0.5] .* Δz .+ edge, [1.0, 0.0], δ)\n", "end\n", "\n", "\"\"\"\n", @@ -384,21 +384,6 @@ " blobs, sheet\n", "end\n", "\n", - "#=\n", - "function new_vortex(sys::Tuple{Vector{T}}, edge, α, δ) where T <: Vortex.Blob\n", - " Δz = (sys[1][end].z - edge)/2 \n", - "\n", - " Vortex.Sheet([0.5, 1.5] .* Δz + edge, [0.0, 1.0], δ)\n", - "end\n", - "\n", - "function new_vortex(sys::Tuple{Vector{T}, Vortex.Sheet}, edge, α, δ) where T <: Vortex.Blob\n", - " _, sheet = sys\n", - "\n", - " z = (edge + 2sheet.zs[end])/3\n", - "\n", - " Vortex.Blob.([sheet.zs[end], z], [0.5, 0.5], δ)\n", - "end\n", - "=#\n", "\n", "\"\"\"\n", " new_element() -> ()\n", @@ -421,7 +406,9 @@ "\"\"\"\n", "function new_element(blobs::Vector{T}, sheet::Vortex.Sheet) where T <: Vortex.Blob\n", " (sheet.blobs[end],)\n", - "end" + "end\n", + "\n", + "counter_min(Tmin,Δt) = isinf(Tmin) ? Inf : round(Int,Tmin/Δt)" ] }, { @@ -440,7 +427,16 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "using SpecialFunctions" + ] + }, + { + "cell_type": "code", + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -472,7 +468,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 99, "metadata": {}, "outputs": [ { @@ -480,9 +476,9 @@ "output_type": "stream", "text": [ "f* = 0.3183098861837907\n", - "Δα = 2.0\n", - "α(1/4) = 2.0\n", - "A/c = 0.0\n", + "Δα = 5.0\n", + "α(1/4) = 0.7105931374996435\n", + "A/c = 0.05\n", "K = 1.0\n" ] } @@ -493,16 +489,16 @@ "N = 128 # number of plate control points\n", "\n", "Δt = 1e-2; # time step\n", - "δ = 0.1 #0.01\n", + "δ = 0.05 #0.1 #0.01\n", "lesp = 10 #0.1\n", "tesp = 0.0\n", "\n", - "a = 0.25 # location of pitch axis, a = 0.5 is leading edge\n", + "a = 0.25 #0.25 # location of pitch axis, a = 0.5 is leading edge\n", "ϕ = -π/2 # phase lag of pitch to heave\n", - "A = 0.0 # amplitude/chord\n", + "A = 0.05 #0.0 # amplitude/chord\n", "fstar = 1/π # fc/U\n", "α₀ = 0 # mean angle of attack\n", - "Δα = 2π/180 # amplitude of pitching\n", + "Δα = 5π/180 #2π/180 # amplitude of pitching\n", "\n", "K = π*fstar # reduced frequency, K = πfc/U\n", "println(\"f* = \",fstar)\n", @@ -511,192 +507,186 @@ "println(\"A/c = \",A)\n", "println(\"K = \",K)\n", "\n", - "oscil = RigidBodyMotions.PitchHeave(1.0,a,K,ϕ,α₀,Δα,A);" + "oscil = RigidBodyMotions.PitchHeave(1.0,a,K,ϕ,α₀,Δα,A);\n", + "motion = Plates.RigidBodyMotion(oscil);" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 87, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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", "0\n", "\n", - "\n", + "\n", "2\n", "\n", - "\n", + "\n", "4\n", "\n", - "\n", + "\n", "6\n", "\n", - "\n", + "\n", "8\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "12\n", "\n", - "\n", + "\n", "Convective time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−10\n", "\n", - "\n", + "\n", "−5\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "5\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "Effective angle (deg)\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0\n", "\n", - "\n", + "\n", "2\n", "\n", - "\n", + "\n", "4\n", "\n", - "\n", + "\n", "6\n", "\n", - "\n", + "\n", "8\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "12\n", "\n", - "\n", + "\n", "Convective time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−10\n", "\n", - "\n", + "\n", "−5\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "5\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "Effective angle (deg)\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 10, + "execution_count": 87, "metadata": {}, "output_type": "execute_result" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GKS: could not find font CMU Serif.ttf\n" - ] } ], "source": [ @@ -717,20 +707,46 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "ename": "LoadError", + "evalue": "InexactError: trunc(Int64, Inf)\n\nSome of the types have been truncated in the stacktrace for improved reading. To emit complete information\nin the stack trace, evaluate `TruncatedStacktraces.VERBOSE[] = true` and re-run the code.\n", + "output_type": "error", + "traceback": [ + "InexactError: trunc(Int64, Inf)\n\nSome of the types have been truncated in the stacktrace for improved reading. To emit complete information\nin the stack trace, evaluate `TruncatedStacktraces.VERBOSE[] = true` and re-run the code.\n", + "", + "Stacktrace:", + " [1] trunc", + " @ ./float.jl:893 [inlined]", + " [2] round(#unused#::Type{Int64}, x::Float64)", + " @ Base ./float.jl:384", + " [3] top-level scope", + " @ In[101]:1" + ] + } + ], + "source": [ + "round(Int,Inf/Δt)" + ] + }, + { + "cell_type": "code", + "execution_count": 92, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:02\u001b[39m\n" + "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:03\u001b[39m\n" ] } ], "source": [ - "plate = Plate(N, L, 0, oscil.α(0.0))\n", - "motion = Plates.RigidBodyMotion(oscil);\n", + "plate = Plate(N, L, 0, motion.kin.α(0.0))\n", + "\n", "Plates.enforce_no_flow_through!(plate, motion, (), 0.0)\n", "\n", "sys = (plate, ((), ()))\n", @@ -743,29 +759,32 @@ "# sys[2][i][2] is the vortex sheet associated with edge i. Its first entry is the \n", "# sys[2][i][1][1] is the current active vortex for edge i\n", "\n", - "sys = shed_new_vorticity!(sys, motion, δ, 0.0, lesp, 0.0)\n", + "sys = shed_new_vorticity!(sys, motion, δ, 0.0, lesp, tesp)\n", + "\n", "states = Tuple[];\n", "forces = [];\n", "moments = [];\n", "\n", - "tf = 12\n", + "tf = 25\n", "T = Δt:Δt:tf\n", "\n", "# Set up Theodorsen solution results\n", - "#theo = Theodorsen(oscil,L)\n", - "#fytheo = map(x -> x[1], theo.(Δt:Δt:tf))\n", - "#momtheo = map(x -> x[2], theo.(Δt:Δt:tf))\n", + "theo = Theodorsen(oscil,L)\n", + "fytheo = map(x -> x[1], theo.(Δt:Δt:tf))\n", + "momtheo = map(x -> x[2], theo.(Δt:Δt:tf))\n", "\n", "counter = [0, 0]\n", - "ϵ = 1e-3 #1.75e-4 #1e-3\n", - "countermin = [Inf,20] #[Inf,20] #[Inf,Inf]\n", + "ϵ = 1.75e-4 #1.75e-4 #1e-3\n", + "Tmin = [Inf,4e-1] #[Inf,2e-1] # [Inf,Inf]\n", + "\n", + "\n", + "countmin = counter_min.(Tmin.)\n", + "\n", "@showprogress for t in T\n", " push!(states, deepcopy(sys))\n", - "\n", - " # Perform the impulse matching correction on the active vortex position, but only if there is a sheet and vortex\n", - " #Δzs = [length(sys[2][i]) == 2 ? [impulse_matching_correction(sblob, sys[2][i][1][1], sys[1]) for sblob in sys[2][i][2].blobs] : [] for i in 1:2]\n", - " \n", + " \n", " ẋs = (motion, allocate_velocity(sys[2]))\n", + "\n", " compute_ẋ!(ẋs, sys, t)\n", " \n", " lesys, tesys = sys[2]\n", @@ -782,6 +801,7 @@ " edge_blobs, edge_sheet = sys[2][i]\n", " active_blob = edge_blobs[1]\n", " \n", + " # Calculate the impulse matching correction on the active vortex position\n", " Δzs = [impulse_matching_correction(sblob, edge_blobs[1], plate) for sblob in edge_sheet.blobs] \n", " \n", " point = transfer_circulation!(edge_sheet, edge_blobs[1], Δzs, plate, ϵ)\n", @@ -824,7 +844,7 @@ " end\n", " \n", " Plates.enforce_no_flow_through!(plate, motion, sys[2], t)\n", - " sys = shed_new_vorticity!(sys, motion, δ, t, lesp, 0.0)\n", + " sys = shed_new_vorticity!(sys, motion, δ, t, lesp, tesp)\n", " \n", "\n", "end" @@ -832,106 +852,874 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 93, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\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/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, - "execution_count": 12, + "execution_count": 93, "metadata": {}, "output_type": "execute_result" } @@ -949,78 +1737,90 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 90, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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", - "0.0\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "10\n", "\n", - "\n", - "2.5\n", + "\n", + "20\n", "\n", - "\n", - "5.0\n", + "\n", + "30\n", "\n", - "\n", - "7.5\n", + "\n", + "40\n", "\n", - "\n", - "10.0\n", + "\n", + "50\n", "\n", - "\n", - "Convective Time\n", + "\n", + "Convective Time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−0.50\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−1.5\n", "\n", - "\n", - "−0.25\n", + "\n", + "−1.0\n", "\n", - "\n", - "0.00\n", + "\n", + "−0.5\n", "\n", - "\n", - "0.25\n", + "\n", + "0.0\n", "\n", - "\n", - "0.50\n", + "\n", + "0.5\n", "\n", - "\n", + "\n", + "1.0\n", + "\n", + "\n", + "1.5\n", + "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "0.0\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "20\n", "\n", - "\n", - "2.5\n", + "\n", + "30\n", "\n", - "\n", - "5.0\n", + "\n", + "40\n", "\n", - "\n", - "7.5\n", + "\n", + "50\n", "\n", - "\n", - "10.0\n", + "\n", + "Convective Time\n", "\n", - "\n", - "Convective Time\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−1.5\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−0.50\n", + "\n", + "−1.0\n", "\n", - "\n", - "−0.25\n", + "\n", + "−0.5\n", "\n", - "\n", - "0.00\n", + "\n", + "0.0\n", "\n", - "\n", - "0.25\n", + "\n", + "0.5\n", "\n", - "\n", - "0.50\n", + "\n", + "1.0\n", "\n", - "\n", + "\n", + "1.5\n", + "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 13, + "execution_count": 90, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "plt = plot(ylabel = \"\\$C_y\\$\", ylim = (-0.5,0.5), \n", + "plt = plot(ylabel = \"\\$C_y\\$\", ylim = (-1.5,1.5), \n", " xlabel = \"Convective Time\")\n", "#plot!(Δt:Δt:tf, 2imag.(forces_tmin1em1), linewidth = 1.5, linestyle = :solid, label = \"\\$T_{min}=0.1\\$\")\n", "#plot!(Δt:Δt:tf, 2imag.(forces_tmin4em1), linewidth = 1.5, linestyle = :solid, label = \"\\$T_{min}=0.4\\$\")\n", "plot!(Δt:Δt:tf, 2imag.(forces), linewidth = 1.5, linestyle = :solid, label = \"sheet\")\n", - "#plot!(Δt:Δt:tf, 2fytheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")\n", + "plot!(Δt:Δt:tf, 2fytheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")\n", "#savefig(\"oscil-forces.pdf\")\n", "plt" ] }, { "cell_type": "code", - "execution_count": 140, + "execution_count": 91, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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", - "0.0\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "10\n", + "\n", + "\n", + "20\n", "\n", - "\n", - "2.5\n", + "\n", + "30\n", "\n", - "\n", - "5.0\n", + "\n", + "40\n", "\n", - "\n", - "7.5\n", + "\n", + "50\n", "\n", - "\n", - "10.0\n", + "\n", + "Convective Time\n", "\n", - "\n", - "Convective Time\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−1.0\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−0.05\n", + "\n", + "−0.5\n", "\n", - "\n", - "0.00\n", + "\n", + "0.0\n", "\n", - "\n", - "0.05\n", + "\n", + "0.5\n", "\n", - "\n", - "0.10\n", + "\n", + "1.0\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "0.0\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0\n", "\n", - "\n", - "2.5\n", + "\n", + "10\n", "\n", - "\n", - "5.0\n", + "\n", + "20\n", "\n", - "\n", - "7.5\n", + "\n", + "30\n", "\n", - "\n", - "10.0\n", + "\n", + "40\n", "\n", - "\n", - "Convective Time\n", + "\n", + "50\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−0.05\n", + "\n", + "Convective Time\n", "\n", - "\n", - "0.00\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−1.0\n", "\n", - "\n", - "0.05\n", + "\n", + "−0.5\n", "\n", - "\n", - "0.10\n", + "\n", + "0.0\n", "\n", - "\n", + "\n", + "0.5\n", + "\n", + "\n", + "1.0\n", + "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 140, + "execution_count": 91, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "plt = plot(ylabel = \"\\$C_M\\$\", ylim = (-0.1,0.1), \n", + "plt = plot(ylabel = \"\\$C_M\\$\", ylim = (-1,1), \n", " xlabel = \"Convective Time\")\n", "#plot!(Δt:Δt:tf, 2moments_tmin1em1, linewidth = 1.5, linestyle = :solid, label = \"\\$T_{min}=0.1\\$\")\n", "#plot!(Δt:Δt:tf, 2moments_tmin4em1, linewidth = 1.5, linestyle = :solid, label = \"\\$T_{min}=0.4\\$\")\n", "plot!(Δt:Δt:tf, 2moments, linewidth = 1.5, linestyle = :solid, label = \"sheet\")\n", - "#plot!(Δt:Δt:tf, 2momtheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")" + "plot!(Δt:Δt:tf, 2momtheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")" ] }, { From 185fe04e2f76206544702fa9661b971f2612103d Mon Sep 17 00:00:00 2001 From: Jeff Eldredge Date: Tue, 22 Aug 2023 08:57:17 -0700 Subject: [PATCH 06/11] Last commit before moving things to PotentialFlow module --- ...brid Model Force Compare Oscil Heave.ipynb | 1662 +++++------------ 1 file changed, 453 insertions(+), 1209 deletions(-) diff --git a/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb b/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb index 7342d4e..a265b3d 100644 --- a/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb +++ b/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb @@ -17,7 +17,8 @@ "\n", "using Plots\n", "using ProgressMeter\n", - "using UnPack" + "using UnPack\n", + "using SpecialFunctions" ] }, { @@ -48,12 +49,12 @@ " width=\"25mm\" height=\"25mm\" viewBox=\"0 0 1 1\" stroke=\"none\"\n", " preserveAspectRatio=\"none\" shape-rendering=\"crispEdges\">\n", "\n", - " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", "\n", "" @@ -129,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -138,7 +139,7 @@ "transfer_circulation!" ] }, - "execution_count": 5, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -179,7 +180,7 @@ " ΣΔz = zero(ComplexF64)\n", " ΣΓ = 0.0\n", "\n", - " Σp = total_impulse(Vortex.Point(z₀, Γ₀), plate)\n", + " Σp = Plates.vortex_impulse(plate,Vortex.Point(z₀, Γ₀)) #total_impulse(Vortex.Point(z₀, Γ₀), plate)\n", "\n", " segments = 0\n", " \n", @@ -201,8 +202,12 @@ " ΣΔz += Δz[n]\n", " ΣΓ += circulation(sheet.blobs[n])\n", "\n", - " p₊ = total_impulse(Vortex.Point(z₀ + ΣΔz, Γ₀ + ΣΓ), plate) # impulse of active vortex with this segment transferred\n", - " Σp += total_impulse(sheet.blobs[n], plate) # impulse of the sheet if this segment is not transferred\n", + " #p₊ = total_impulse(Vortex.Point(z₀ + ΣΔz, Γ₀ + ΣΓ), plate) # impulse of active vortex with this segment transferred\n", + " #Σp += total_impulse(sheet.blobs[n], plate) # impulse of the sheet if this segment is not transferred\n", + " \n", + " p₊ = Plates.vortex_impulse(plate,Vortex.Point(z₀ + ΣΔz, Γ₀ + ΣΓ)) # impulse of active vortex with this segment transferred\n", + " Σp += Plates.vortex_impulse(plate,sheet.blobs[n]) # impulse of the sheet if this segment is not transferred\n", + "\n", "\n", " if abs2(p₊ - Σp) > ϵ^2\n", " if n ≤ 2\n", @@ -247,7 +252,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -256,7 +261,7 @@ "compute_ẋ! (generic function with 1 method)" ] }, - "execution_count": 6, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -282,7 +287,7 @@ }, { "cell_type": "code", - "execution_count": 107, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -291,7 +296,7 @@ "counter_min (generic function with 1 method)" ] }, - "execution_count": 107, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -412,31 +417,62 @@ ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 17, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "sheettip_to_blob!" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "## Comparison with Theodorsen " + "\"\"\"\n", + " sheettip_to_blob!(blobs,sheet)\n", + "\n", + "Transform the tip of a vortex sheet into a vortex blob. Add it to the beginning of the list\n", + "of blobs (and remove it from the sheet).\n", + "\"\"\"\n", + "function sheettip_to_blob!(blobs::Vector{T},sheet::Vortex.Sheet) where T <: Vortex.Blob\n", + " tips = sheet.blobs[1:2]\n", + " \n", + " # factor of 2 in circulation is due to the trapezoidal weight on blob strength of first blob\n", + " new_blob = Vortex.Blob(0.5*(tips[1].z + tips[2].z), 2circulation(tips[1]), tips[1].δ)\n", + " \n", + " # remove the first entry from the sheet, since this has been transferred to the active blob\n", + " splice!(sheet.blobs, 1)\n", + " splice!(sheet.Ss, 1)\n", + " \n", + " # now the second sheet element is the first element and needs to have its strength adjusted for trapezoidal weight\n", + " sheet.blobs[1] = Vortex.Blob(tips[2].z, 0.5*(sheet.Ss[2] - sheet.Ss[1]), tips[2].δ)\n", + " pushfirst!(blobs, new_blob)\n", + " nothing\n", + "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "First, let's set up the exact solution" + "## Comparison with Theodorsen " ] }, { - "cell_type": "code", - "execution_count": 33, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "using SpecialFunctions" + "First, let's set up the exact solution" ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -468,18 +504,19 @@ }, { "cell_type": "code", - "execution_count": 99, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "f* = 0.3183098861837907\n", - "Δα = 5.0\n", - "α(1/4) = 0.7105931374996435\n", - "A/c = 0.05\n", - "K = 1.0\n" + "f* = 0.14\n", + "Δα = 59.99999999999999\n", + "α(1/4) = 18.66365736885437\n", + "A/c = 1.0\n", + "K = 0.4398229715025711\n", + "χ = 1.451507225382632\n" ] } ], @@ -493,19 +530,31 @@ "lesp = 10 #0.1\n", "tesp = 0.0\n", "\n", + "#=\n", "a = 0.25 #0.25 # location of pitch axis, a = 0.5 is leading edge\n", "ϕ = -π/2 # phase lag of pitch to heave\n", "A = 0.05 #0.0 # amplitude/chord\n", "fstar = 1/π # fc/U\n", "α₀ = 0 # mean angle of attack\n", "Δα = 5π/180 #2π/180 # amplitude of pitching\n", + "=#\n", "\n", + "# Kinsey-Dumas case\n", + "a = 0.2 #0.2 # location of pitch axis, a = 0.5 is leading edge\n", + "ϕ = -π/2 # phase lag of pitch to heave\n", + "A = 1.0 #1.0 # amplitude/chord\n", + "fstar = 0.14 # fc/U\n", + "α₀ = 0π/180 # mean angle of attack\n", + "Δα = 60π/180 #20π/180 # amplitude of pitching\n", + "\n", + "χ = Δα/atan(2π*A*fstar)\n", "K = π*fstar # reduced frequency, K = πfc/U\n", "println(\"f* = \",fstar)\n", "println(\"Δα = \",Δα*180/π)\n", "println(\"α(1/4) = \",abs(atan(2*K*A)-Δα)*180/π)\n", "println(\"A/c = \",A)\n", "println(\"K = \",K)\n", + "println(\"χ = \",χ)\n", "\n", "oscil = RigidBodyMotions.PitchHeave(1.0,a,K,ϕ,α₀,Δα,A);\n", "motion = Plates.RigidBodyMotion(oscil);" @@ -513,188 +562,178 @@ }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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", "0\n", "\n", - "\n", - "2\n", - "\n", - "\n", - "4\n", + "\n", + "5\n", "\n", - "\n", - "6\n", + "\n", + "10\n", "\n", - "\n", - "8\n", + "\n", + "15\n", "\n", - "\n", - "10\n", + "\n", + "20\n", "\n", - "\n", - "12\n", + "\n", + "25\n", "\n", - "\n", + "\n", "Convective time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−10\n", "\n", - "\n", + "\n", "−5\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "5\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "Effective angle (deg)\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0\n", "\n", - "\n", - "2\n", - "\n", - "\n", - "4\n", + "\n", + "5\n", "\n", - "\n", - "6\n", + "\n", + "10\n", "\n", - "\n", - "8\n", + "\n", + "15\n", "\n", - "\n", - "10\n", + "\n", + "20\n", "\n", - "\n", - "12\n", + "\n", + "25\n", "\n", - "\n", + "\n", "Convective time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−10\n", "\n", - "\n", + "\n", "−5\n", "\n", - "\n", + "\n", "0\n", "\n", - "\n", + "\n", "5\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "Effective angle (deg)\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 87, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t = 0:0.01:(4.0./fstar)\n", - "#plot(t,oscil.Ẏ.(t))\n", - "#plot!(t,oscil.α̇.(t))\n", - "Vy = map(x -> imag(x[1]),oscil.(t))\n", - "αeff = atan.(-Vy)+oscil.α.(t)\n", + "Vy = map(x -> imag(x[1]),motion.kin.(t))\n", + "αeff = atan.(-Vy)+motion.kin.α.(t)\n", "plot(t,αeff*180/π,ylim=(-10,10),ylabel=\"Effective angle (deg)\",xlabel=\"Convective time\")" ] }, @@ -707,40 +746,14 @@ }, { "cell_type": "code", - "execution_count": 101, - "metadata": {}, - "outputs": [ - { - "ename": "LoadError", - "evalue": "InexactError: trunc(Int64, Inf)\n\nSome of the types have been truncated in the stacktrace for improved reading. To emit complete information\nin the stack trace, evaluate `TruncatedStacktraces.VERBOSE[] = true` and re-run the code.\n", - "output_type": "error", - "traceback": [ - "InexactError: trunc(Int64, Inf)\n\nSome of the types have been truncated in the stacktrace for improved reading. To emit complete information\nin the stack trace, evaluate `TruncatedStacktraces.VERBOSE[] = true` and re-run the code.\n", - "", - "Stacktrace:", - " [1] trunc", - " @ ./float.jl:893 [inlined]", - " [2] round(#unused#::Type{Int64}, x::Float64)", - " @ Base ./float.jl:384", - " [3] top-level scope", - " @ In[101]:1" - ] - } - ], - "source": [ - "round(Int,Inf/Δt)" - ] - }, - { - "cell_type": "code", - "execution_count": 92, + "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:03\u001b[39m\n" + "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:01\u001b[39m\n" ] } ], @@ -765,7 +778,12 @@ "forces = [];\n", "moments = [];\n", "\n", - "tf = 25\n", + "\n", + "Bf = 1e-1 #1.75e-2 #1e-1\n", + "Tmin = [Inf,2e-1] #[Inf,2e-1] # [Inf,Inf]\n", + "\n", + "\n", + "tf = 50\n", "T = Δt:Δt:tf\n", "\n", "# Set up Theodorsen solution results\n", @@ -774,11 +792,10 @@ "momtheo = map(x -> x[2], theo.(Δt:Δt:tf))\n", "\n", "counter = [0, 0]\n", - "ϵ = 1.75e-4 #1.75e-4 #1e-3\n", - "Tmin = [Inf,4e-1] #[Inf,2e-1] # [Inf,Inf]\n", "\n", "\n", - "countmin = counter_min.(Tmin.)\n", + "countermin = counter_min.(Tmin,Δt)\n", + "ϵ = Bf*Δt \n", "\n", "@showprogress for t in T\n", " push!(states, deepcopy(sys))\n", @@ -799,35 +816,23 @@ " length(sys[2][i]) == 2 || continue\n", " \n", " edge_blobs, edge_sheet = sys[2][i]\n", - " active_blob = edge_blobs[1]\n", " \n", " # Calculate the impulse matching correction on the active vortex position\n", " Δzs = [impulse_matching_correction(sblob, edge_blobs[1], plate) for sblob in edge_sheet.blobs] \n", " \n", - " point = transfer_circulation!(edge_sheet, edge_blobs[1], Δzs, plate, ϵ)\n", + " new_blob = transfer_circulation!(edge_sheet, edge_blobs[1], Δzs, plate, ϵ)\n", "\n", - " if point == edge_blobs[1]\n", + " if new_blob == edge_blobs[1]\n", " counter[i] += 1\n", " else\n", " counter[i] = 0\n", - " edge_blobs[1] = point\n", + " edge_blobs[1] = new_blob\n", " end\n", " \n", " # if we have waited long enough, and sheet is sufficiently long, then\n", " # convert current active vortex into an inactive one, and release tip of sheet as new active vortex\n", " if length(edge_sheet) > 2 && counter[i] > countermin[i]\n", - " tips = edge_sheet.blobs[1:2]\n", - " \n", - " # factor of 2 in circulation is due to the trapezoidal weight on blob strength of first blob\n", - " new_active = Vortex.Blob(0.5*(tips[1].z + tips[2].z), 2circulation(tips[1]), tips[1].δ)\n", - " \n", - " # remove the first entry from the sheet, since this has been transferred to the active blob\n", - " splice!(edge_sheet.blobs, 1)\n", - " splice!(edge_sheet.Ss, 1)\n", - " \n", - " # now the second sheet element is the first element and needs to have its strength adjusted for trapezoidal weight\n", - " edge_sheet.blobs[1] = Vortex.Blob(tips[2].z, 0.5*(edge_sheet.Ss[2] - edge_sheet.Ss[1]), tips[2].δ)\n", - " pushfirst!(edge_blobs, new_active)\n", + " sheettip_to_blob!(edge_blobs,edge_sheet)\n", " counter[i] = 0\n", " end\n", " end\n", @@ -852,884 +857,128 @@ }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\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/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, - "execution_count": 93, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "plt = plot(states[end],color = cgrad(:RdBu,rev=true), ratio=1,legend=:none,markersize=4,markerstrokealpha=1,\n", + "plt = plot(states[end],color = cgrad(:RdBu,rev=true), ratio=1,legend=:none,markersize=3,markerstrokealpha=1,\n", " markerstrokewidth=0.5,linewidth=1.5,ticks=nothing,border=nothing,framestyle=false,\n", - " clim=(-0.5,0.5),ylim=(-2,2))\n", + " clim=(-0.5,0.5),ylim=(-3,3))\n", "zc = map(x -> 0.5x[1].zs[64] + 0.5x[1].zs[65],states[1:end]) \n", - "plot!(real.(zc),imag.(zc))\n", + "plot!(real.(zc),imag.(zc),linestyle=:dash)\n", "#savefig(\"oscil-alf05A05-sheet.pdf\")\n", "#savefig(\"oscil-alf05A05-eps175em3tmin1em1.pdf\")\n", "plt" @@ -1737,90 +986,90 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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", - "0\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0\n", "\n", - "\n", - "10\n", + "\n", + "10\n", "\n", - "\n", - "20\n", + "\n", + "20\n", "\n", - "\n", - "30\n", + "\n", + "30\n", "\n", - "\n", - "40\n", + "\n", + "40\n", "\n", - "\n", - "50\n", + "\n", + "50\n", "\n", - "\n", - "Convective Time\n", + "\n", + "Convective Time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−1.5\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−3\n", "\n", - "\n", - "−1.0\n", + "\n", + "−2\n", "\n", - "\n", - "−0.5\n", + "\n", + "−1\n", "\n", - "\n", - "0.0\n", + "\n", + "0\n", "\n", - "\n", - "0.5\n", + "\n", + "1\n", "\n", - "\n", - "1.0\n", + "\n", + "2\n", "\n", - "\n", - "1.5\n", + "\n", + "3\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "0\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "0\n", "\n", - "\n", - "10\n", + "\n", + "10\n", "\n", - "\n", - "20\n", + "\n", + "20\n", "\n", - "\n", - "30\n", + "\n", + "30\n", "\n", - "\n", - "40\n", + "\n", + "40\n", "\n", - "\n", - "50\n", + "\n", + "50\n", "\n", - "\n", - "Convective Time\n", + "\n", + "Convective Time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−1.5\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "−3\n", "\n", - "\n", - "−1.0\n", + "\n", + "−2\n", "\n", - "\n", - "−0.5\n", + "\n", + "−1\n", "\n", - "\n", - "0.0\n", + "\n", + "0\n", "\n", - "\n", - "0.5\n", + "\n", + "1\n", "\n", - "\n", - "1.0\n", + "\n", + "2\n", "\n", - "\n", - "1.5\n", + "\n", + "3\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 90, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "plt = plot(ylabel = \"\\$C_y\\$\", ylim = (-1.5,1.5), \n", + "plt = plot(ylabel = \"\\$C_y\\$\", ylim = (-3.5,3.5), \n", " xlabel = \"Convective Time\")\n", - "#plot!(Δt:Δt:tf, 2imag.(forces_tmin1em1), linewidth = 1.5, linestyle = :solid, label = \"\\$T_{min}=0.1\\$\")\n", - "#plot!(Δt:Δt:tf, 2imag.(forces_tmin4em1), linewidth = 1.5, linestyle = :solid, label = \"\\$T_{min}=0.4\\$\")\n", "plot!(Δt:Δt:tf, 2imag.(forces), linewidth = 1.5, linestyle = :solid, label = \"sheet\")\n", "plot!(Δt:Δt:tf, 2fytheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")\n", - "#savefig(\"oscil-forces.pdf\")\n", "plt" ] }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 158, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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", "0\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "20\n", "\n", - "\n", + "\n", "30\n", "\n", - "\n", + "\n", "40\n", "\n", - "\n", + "\n", "50\n", "\n", - "\n", + "\n", "Convective Time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−1.0\n", "\n", - "\n", + "\n", "−0.5\n", "\n", - "\n", + "\n", "0.0\n", "\n", - "\n", + "\n", "0.5\n", "\n", - "\n", + "\n", "1.0\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "0\n", "\n", - "\n", + "\n", "10\n", "\n", - "\n", + "\n", "20\n", "\n", - "\n", + "\n", "30\n", "\n", - "\n", + "\n", "40\n", "\n", - "\n", + "\n", "50\n", "\n", - "\n", + "\n", "Convective Time\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "−1.0\n", "\n", - "\n", + "\n", "−0.5\n", "\n", - "\n", + "\n", "0.0\n", "\n", - "\n", + "\n", "0.5\n", "\n", - "\n", + "\n", "1.0\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 91, + "execution_count": 158, "metadata": {}, "output_type": "execute_result" } @@ -2211,10 +1457,8 @@ "source": [ "plt = plot(ylabel = \"\\$C_M\\$\", ylim = (-1,1), \n", " xlabel = \"Convective Time\")\n", - "#plot!(Δt:Δt:tf, 2moments_tmin1em1, linewidth = 1.5, linestyle = :solid, label = \"\\$T_{min}=0.1\\$\")\n", - "#plot!(Δt:Δt:tf, 2moments_tmin4em1, linewidth = 1.5, linestyle = :solid, label = \"\\$T_{min}=0.4\\$\")\n", - "plot!(Δt:Δt:tf, 2moments, linewidth = 1.5, linestyle = :solid, label = \"sheet\")\n", - "plot!(Δt:Δt:tf, 2momtheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")" + "plot!(plt,Δt:Δt:tf, 2moments, linewidth = 1.5, linestyle = :solid, label = \"sheet\")\n", + "plot!(plt,Δt:Δt:tf, 2momtheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")" ] }, { From 1c39a4ed28bbcd7ef9adf31461a318a7e89ca734 Mon Sep 17 00:00:00 2001 From: Jeff Eldredge Date: Tue, 22 Aug 2023 10:14:18 -0700 Subject: [PATCH 07/11] Added routines into PotentialFlow --- ...brid Model Force Compare Oscil Heave.ipynb | 3488 +++++++---------- src/PotentialFlow.jl | 3 + src/elements/Plates.jl | 1 + src/vorticity_transfer.jl | 241 ++ 4 files changed, 1593 insertions(+), 2140 deletions(-) create mode 100644 src/vorticity_transfer.jl diff --git a/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb b/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb index a265b3d..6b6109c 100644 --- a/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb +++ b/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Circulation Transfer" + "# Hybrid vortex sheet-point vortex model" ] }, { @@ -13,12 +13,7 @@ "metadata": {}, "outputs": [], "source": [ - "using PotentialFlow\n", - "\n", - "using Plots\n", - "using ProgressMeter\n", - "using UnPack\n", - "using SpecialFunctions" + "using PotentialFlow" ] }, { @@ -27,232 +22,22 @@ "metadata": {}, "outputs": [], "source": [ - "#pyplot()\n", - "default(tickfont = font(\"CMU Serif\", 9), \n", - " titlefont = font(\"CMU Serif\", 14), \n", - " guidefont = font(\"CMU Serif\", 12), \n", - " grid = false)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "RGBA{Float64}(0.30196078431372547,0.6862745098039216,0.2901960784313726,1.0)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "myred = RGBA(228/255,26/255,28/255,1.0)\n", - "myblue = RGBA(55/255,126/255,184/255,1.0)\n", - "mygreen = RGBA(77/255,175/255,74/255,1.0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Impulse matching correction" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "impulse_matching_correction" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\"\"\"\n", - " impulse_matching_correction(vs, vt, plate) -> ComplexF64\n", - "\n", - "Compute the impulse matching position correction for a target vortex `vt` when the circulation\n", - "of a source vortex `vs` is to be fully transferred to it. Equation (A26) of Darakananda and Eldredge JFM 2019\n", - "with Γ̇ = ΓₛΔt. Assumes a flat plate body.\n", - "\"\"\"\n", - "function impulse_matching_correction(vs, vt, plate::Plate)\n", - " @unpack c, α, L = plate\n", - " \n", - " c⁺ = plate.zs[end]\n", - " c⁻ = plate.zs[1]\n", - "\n", - " z̃t = 2(vt.z - c)*exp(-im*α)/L\n", - " z̃s = 2(vs.z - c)*exp(-im*α)/L\n", - " \n", - " pt = Plates.unit_impulse(z̃t)\n", - " ps = Plates.unit_impulse(z̃s)\n", - "\n", - " η = z̃t/(√(z̃t + 1)*√(z̃t - 1))\n", - "\n", - " Δp = ps - pt\n", - " Δz = im*0.5L*exp(im*α)*(Δp*(1 + η') + Δp'*(η' - 1))/(η + η')*(circulation(vs)/circulation(vt))\n", - "# if isnan(Δz) || isinf(Δz)\n", - "# error(\"Δz is $Δz\")\n", - "# end\n", - " return Δz\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "transfer_circulation!" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\"\"\"\n", - " total_impulse(point,plate) -> ComplexF64\n", - "\n", - "Return the total linear impulse of vortex `point` and its modification due to the presence of plate `plate`.\n", - "\"\"\"\n", - "function total_impulse(point, plate)\n", - " @unpack c, α, L = plate\n", - " \n", - " z = Elements.position(point)\n", - " Γ = circulation(point)\n", - "\n", - " z̃ = 2exp(-im*α)*(z - c)/L\n", - " exp(im*α)*0.5L*Γ*(imag(z) - im*real(√(z - 1)*√(z + 1)))\n", - "end\n", - "\n", - "\"\"\"\n", - " transfer_circulation!(sheet,point,Δz,plate,ϵ=1e-3;[max_segments=10]) -> Vortex.Blob\n", - "\n", - "Return a vortex blob that is initially identical to `point` and, where appropriate,\n", - "accrues the circulation of the last several segments of the vortex sheet `sheet`.\n", - "In these cases, it also removes the last several segments of `sheet`. The position\n", - "correction `Δz`, which accounts for the impulse matching correction due to the\n", - "transfer of circulation from each segment, is added to the position of `point`\n", - "to create the output vortex blob. `ϵ` is the maximum allowable discrepancy in\n", - "the impulse due to the circulation transfer (compared to the impulse if no circulation\n", - "is transferred). `max_segments` is the maximum number of sheet segments that can be considered\n", - "for transfer; it defaults to 10.\n", - "\"\"\"\n", - "function transfer_circulation!(sheet, point, Δz, plate, ϵ = 1e-3; max_segments=10)\n", - " z₀ = Elements.position(point)\n", - " Γ₀ = circulation(point)\n", - "\n", - " ΣΔz = zero(ComplexF64)\n", - " ΣΓ = 0.0\n", - "\n", - " Σp = Plates.vortex_impulse(plate,Vortex.Point(z₀, Γ₀)) #total_impulse(Vortex.Point(z₀, Γ₀), plate)\n", - "\n", - " segments = 0\n", - " \n", - " # If the sheet isn't long enough to transfer, then return with no transfer\n", - " if length(sheet) < max_segments+2\n", - " return point\n", - " end\n", - "\n", - " for n in 1:length(sheet)-max_segments # Don't eat into the last `max_segments` segments\n", - " if isnan(Δz[n]) || isinf(Δz[n])\n", - " if n ≤ 2\n", - " return point\n", - " else\n", - " segments = n-1\n", - " break;\n", - " end\n", - " end\n", - "\n", - " ΣΔz += Δz[n]\n", - " ΣΓ += circulation(sheet.blobs[n])\n", - "\n", - " #p₊ = total_impulse(Vortex.Point(z₀ + ΣΔz, Γ₀ + ΣΓ), plate) # impulse of active vortex with this segment transferred\n", - " #Σp += total_impulse(sheet.blobs[n], plate) # impulse of the sheet if this segment is not transferred\n", - " \n", - " p₊ = Plates.vortex_impulse(plate,Vortex.Point(z₀ + ΣΔz, Γ₀ + ΣΓ)) # impulse of active vortex with this segment transferred\n", - " Σp += Plates.vortex_impulse(plate,sheet.blobs[n]) # impulse of the sheet if this segment is not transferred\n", - "\n", - "\n", - " if abs2(p₊ - Σp) > ϵ^2\n", - " if n ≤ 2\n", - " return point\n", - " else\n", - " segments = n-1\n", - " break\n", - " end\n", - " end\n", - " segments += 1\n", - " end\n", - " \n", - " # Change the position and strength of `point`, using the impulse correction\n", - " # and strength of each segment\n", - " z = z₀ + sum(Δz[1:segments-1]) + 0.5Δz[segments]\n", - " Γ = Γ₀ + sum(circulation(sheet.blobs[1:segments-1])) +\n", - " 0.5(sheet.Ss[segments] -sheet.Ss[segments-1])\n", - " point₊ = Vortex.Blob(z, Γ, point.δ)\n", - "\n", - " # Remove the transferred segments from the sheet\n", - " splice!(sheet.blobs, 1:segments-1)\n", - " splice!(sheet.Ss, 1:segments-1)\n", - " sheet.blobs[1] = sheet.blobs[1](Γ = 0.5(sheet.Ss[2] - sheet.Ss[1]))\n", - "\n", - " return point₊\n", - "end" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Motion Parameters" + "using Plots\n", + "using ProgressMeter\n", + "using SpecialFunctions\n", + "using UnPack" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Time Marching Deatils" + "### Time Marching" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -261,7 +46,7 @@ "compute_ẋ! (generic function with 1 method)" ] }, - "execution_count": 15, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -278,16 +63,9 @@ "end" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The centers of new vortex sheet segments are placed a third of the distance between the edges of the plate to last segment of sheet:" - ] - }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -296,166 +74,15 @@ "counter_min (generic function with 1 method)" ] }, - "execution_count": 16, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "\"\"\"\n", - " new_vortex(edge,angle,δ,plate,motion) -> Vortex.Blob\n", - "\n", - "Create a new vortex blob near the edge `edge` of the plate, with unit strength\n", - "\"\"\"\n", - "new_vortex(edge, α, δ, plate, motion) = Vortex.Blob(edge - 1e-2im*exp(im*α)*sign(Plates.normal(motion.ċ+im*motion.α̇*(edge-plate.c),α)), 1.0, δ)\n", - "\n", - "\n", - "\"\"\"\n", - " new_vortex(blobs::Vector{Vortex.Blob},edge,angle,δ,plate,motion) -> Vortex.Sheet\n", - "\n", - "Create a new vortex sheet near the edge `edge` of the plate with unit strength, using the vortex blobs in `blobs`\n", - "to place the sheet segments. (The blobs are placed at the sheet segment centroids.)\n", - "\"\"\"\n", - "function new_vortex(blobs::Vector{T}, edge, α, δ, plate, motion) where T <: Vortex.Blob\n", - " Δz = (blobs[end].z - edge)/2 \n", - " #Vortex.Sheet([0.5, 1.5] .* Δz .+ edge, [0.0, 1.0], δ)\n", - " Vortex.Sheet([1.5, 0.5] .* Δz .+ edge, [1.0, 0.0], δ)\n", - "end\n", - "\n", - "\"\"\"\n", - " new_vortex(blobs::Vector{Vortex.Blob},sheet::Vortex.Sheet,edge,angle,δ,plate,motion) -> Vortex.Blob\n", - "\n", - "Create vortex blobs near the edge `edge` of the plate with unit strength, using the last vortex sheet segment in `sheet`\n", - "to place the blobs.\n", - "\"\"\"\n", - "function new_vortex(::Vector{T}, sheet::Vortex.Sheet, edge, α, δ, plate, motion) where T <: Vortex.Blob\n", - " z = (edge + 2sheet.zs[end])/3\n", - " Vortex.Blob.([sheet.zs[end], z], [0.5, 0.5], δ)\n", - "end\n", - "\n", - "\n", - "\"\"\"\n", - " shed_new_vorticity!(sys,motion,δ,t,lesp=0.0,tesp=0.0) \n", - "\n", - "Returns the plate/vortex system after adding new vortices of the appropriate type\n", - "at the plate edges, in order to satisfy the respective regularization conditions at those edges.\n", - "\"\"\"\n", - "function shed_new_vorticity!(sys, motion, δ, t, lesp = 0.0, tesp = 0.0)\n", - " plate, ambient_sys = sys\n", - " le_sys, te_sys = ambient_sys\n", - "\n", - "\n", - " nlev = new_vortex(le_sys..., plate.zs[end], plate.α, δ, plate, motion)\n", - " ntev = new_vortex(te_sys..., plate.zs[1], plate.α, δ, plate, motion)\n", - "\n", - " Γ₊, Γ₋, _, _ = Plates.vorticity_flux!(plate, nlev, ntev, t, lesp, tesp)\n", - "\n", - " plate, (add_new_vortex!(le_sys..., nlev, Γ₊), add_new_vortex!(te_sys..., ntev, Γ₋))\n", - "\n", - "end\n", - "\n", - "\"\"\"\n", - " add_new_vortex!(blob::Vortex.Blob,Γ) -> (blob,)\n", - "\n", - "Create a new vortex blob with the position and radius of `blob`, but with strength `Γ`,\n", - "unless `Γ` is zero, in which case it returns an empty tuple.\n", - "\"\"\"\n", - "function add_new_vortex!(b::Vortex.Blob, Γ)\n", - " if Γ != 0\n", - " ([Vortex.Blob(b.z, Γ, b.δ)],)\n", - " else\n", - " ()\n", - " end\n", - "end\n", - "\n", - "\"\"\"\n", - " add_new_vortex!(blobs::Vector{Vortex.Blob},sheet,Γ) -> (blob,)\n", - "\n", - "Return blobs and a sheet with the same positions and radii as `sheet`, but with the strengths\n", - "set to 0 and `Γ`. This is meant for cases in which the sheet is initially created.\n", - "\"\"\"\n", - "function add_new_vortex!(blobs::Vector{T}, sheet::Vortex.Sheet, Γ) where T <: Vortex.Blob\n", - " blobs, Vortex.Sheet(sheet.zs, [0.0, Γ], sheet.blobs[1].δ)\n", - "end\n", - "\n", - "\"\"\"\n", - " add_new_vortex!(blobs::Vector{Vortex.Blob},sheet,segment::Vector{Vortex.Blob},Γ) -> (blob,)\n", - "\n", - "Return blobs and a sheet that appends the last vortex in `segment` to the end of `sheet`, with strength `Γ`.\n", - "This is the newly-created entry from the edge.\n", - "\"\"\"\n", - "function add_new_vortex!(blobs::Vector{T}, sheet::Vortex.Sheet, segment::Vector{T}, Γ) where T <: Vortex.Blob\n", - " Vortex.Sheets.append_segment!(sheet, segment[2].z, Γ)\n", - " blobs, sheet\n", - "end\n", - "\n", - "\n", - "\"\"\"\n", - " new_element() -> ()\n", - "\n", - "Returns an empty tuple\n", - "\"\"\"\n", - "new_element() = ()\n", - "\n", - "\"\"\"\n", - " new_element(blobs::Vector{Vortex.Blob}) -> (Vortex.Blob,)\n", - "\n", - "Returns the most recently added vortex in `blobs`\n", - "\"\"\"\n", - "new_element(blobs::Vector{T}) where T <: Vortex.Blob = (blobs[1],) \n", - "\n", - "\"\"\"\n", - " new_element(blobs::Vector{Vortex.Blob},sheet::Vortex.Sheet) -> (Vortex.Blob,) \n", - "\n", - "Returns the most recently added vortex in `sheet`\n", - "\"\"\"\n", - "function new_element(blobs::Vector{T}, sheet::Vortex.Sheet) where T <: Vortex.Blob\n", - " (sheet.blobs[end],)\n", - "end\n", - "\n", "counter_min(Tmin,Δt) = isinf(Tmin) ? Inf : round(Int,Tmin/Δt)" ] }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "sheettip_to_blob!" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\"\"\"\n", - " sheettip_to_blob!(blobs,sheet)\n", - "\n", - "Transform the tip of a vortex sheet into a vortex blob. Add it to the beginning of the list\n", - "of blobs (and remove it from the sheet).\n", - "\"\"\"\n", - "function sheettip_to_blob!(blobs::Vector{T},sheet::Vortex.Sheet) where T <: Vortex.Blob\n", - " tips = sheet.blobs[1:2]\n", - " \n", - " # factor of 2 in circulation is due to the trapezoidal weight on blob strength of first blob\n", - " new_blob = Vortex.Blob(0.5*(tips[1].z + tips[2].z), 2circulation(tips[1]), tips[1].δ)\n", - " \n", - " # remove the first entry from the sheet, since this has been transferred to the active blob\n", - " splice!(sheet.blobs, 1)\n", - " splice!(sheet.Ss, 1)\n", - " \n", - " # now the second sheet element is the first element and needs to have its strength adjusted for trapezoidal weight\n", - " sheet.blobs[1] = Vortex.Blob(tips[2].z, 0.5*(sheet.Ss[2] - sheet.Ss[1]), tips[2].δ)\n", - " pushfirst!(blobs, new_blob)\n", - " nothing\n", - "end" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -467,12 +94,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "First, let's set up the exact solution" + "Set up the Theodorsen solution" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -504,41 +131,34 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "f* = 0.14\n", - "Δα = 59.99999999999999\n", - "α(1/4) = 18.66365736885437\n", - "A/c = 1.0\n", - "K = 0.4398229715025711\n", - "χ = 1.451507225382632\n" + "f* = 0.3183098861837907\n", + "Δα = 5.0\n", + "α(1/4) = 5.0\n", + "A/c = 0.0\n", + "K = 1.0\n", + "χ = Inf\n" ] } ], "source": [ "L = 1.0 # chord length\n", "\n", - "N = 128 # number of plate control points\n", - "\n", - "Δt = 1e-2; # time step\n", - "δ = 0.05 #0.1 #0.01\n", - "lesp = 10 #0.1\n", - "tesp = 0.0\n", - "\n", - "#=\n", - "a = 0.25 #0.25 # location of pitch axis, a = 0.5 is leading edge\n", + "a = 0.5 #0.25 # location of pitch axis, a = 0.5 is leading edge\n", "ϕ = -π/2 # phase lag of pitch to heave\n", - "A = 0.05 #0.0 # amplitude/chord\n", + "A = 0.0 #0.0 # amplitude/chord\n", "fstar = 1/π # fc/U\n", "α₀ = 0 # mean angle of attack\n", "Δα = 5π/180 #2π/180 # amplitude of pitching\n", - "=#\n", "\n", + "\n", + "#=\n", "# Kinsey-Dumas case\n", "a = 0.2 #0.2 # location of pitch axis, a = 0.5 is leading edge\n", "ϕ = -π/2 # phase lag of pitch to heave\n", @@ -546,6 +166,7 @@ "fstar = 0.14 # fc/U\n", "α₀ = 0π/180 # mean angle of attack\n", "Δα = 60π/180 #20π/180 # amplitude of pitching\n", + "=#\n", "\n", "χ = Δα/atan(2π*A*fstar)\n", "K = π*fstar # reduced frequency, K = πfc/U\n", @@ -560,172 +181,129 @@ "motion = Plates.RigidBodyMotion(oscil);" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot the effective angle of attack" + ] + }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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", - "0\n", - "\n", - "\n", - "5\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "15\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "25\n", - "\n", - "\n", - "Convective time\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−10\n", - "\n", - "\n", - "−5\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "5\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "Effective angle (deg)\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\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/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "5\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "15\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "25\n", - "\n", - "\n", - "Convective time\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−10\n", - "\n", - "\n", - "−5\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "5\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "Effective angle (deg)\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 13, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -734,7 +312,66 @@ "t = 0:0.01:(4.0./fstar)\n", "Vy = map(x -> imag(x[1]),motion.kin.(t))\n", "αeff = atan.(-Vy)+motion.kin.α.(t)\n", - "plot(t,αeff*180/π,ylim=(-10,10),ylabel=\"Effective angle (deg)\",xlabel=\"Convective time\")" + "plot(t,αeff*180/π,xlim=(0,Inf),ylim=(-30,30),legend=false,ylabel=\"Effective angle (deg)\",xlabel=\"Convective time\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Select the metaparameters for the hybrid vortex model\n", + "\n", + "* $N$ is the number of plate control points\n", + "\n", + "* $\\Delta t$ is the time step size.\n", + "\n", + "* $\\delta$ is the blob radius. It is best to set this to around 0.05 times the chord length.\n", + "\n", + "* `lesp` and `tesp` are the critical edge suction parameters at the leading and trailing edge, respectively\n", + " - Setting this to 0 leads to the Kutta condition at that edge\n", + " - Setting this to a large positive value ($\\sim 10$) suppresses vortex shedding from that edge\n", + "\n", + "* $B_f$ sets the tolerance for force error in the hybrid model.\n", + " - Setting this to zero turns off variable-strength point vortices and generates a traditional vortex model. \n", + " - It is generally advisable to set this to around 0.05 or 0.1 \n", + "\n", + "* $T^*_{min}$ sets the minimum time interval between the release of a new active vortex from the tip of each vortex sheet.\n", + " - Setting this to infinity (and setting $B_f$ to 0) generates a pure vortex sheet model.\n", + " - Setting this to 0 generates a discrete vortex model\n", + " - For a hybrid model, it is generally best to set this between 0.1 and 0.3\n", + " \n", + "* $t_f$ is the final time " + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "N = 128 \n", + "\n", + "Δt = 1e-2\n", + "δ = 0.05 #0.1 #0.01\n", + "\n", + "lesp = 10 #0.1\n", + "tesp = 0.0\n", + "\n", + "Bf = 1.75e-2 #1e-1\n", + "Tmin = [Inf,4e-1]; #2e-1];\n", + "\n", + "tf = 10" ] }, { @@ -746,7 +383,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 45, "metadata": {}, "outputs": [ { @@ -763,27 +400,19 @@ "Plates.enforce_no_flow_through!(plate, motion, (), 0.0)\n", "\n", "sys = (plate, ((), ()))\n", - "#sys = (plate, ())\n", - "\n", "\n", "# sys[1] is the plate, sys[2] is the vortex system\n", "# sys[2][i] corresponds to edge i (i = 1 is leading edge, i = 2 is trailing edge)\n", "# sys[2][i][1] is the set of blobs associated with edge i\n", - "# sys[2][i][2] is the vortex sheet associated with edge i. Its first entry is the \n", "# sys[2][i][1][1] is the current active vortex for edge i\n", + "# sys[2][i][2] is the vortex sheet associated with edge i. Its first entry will be turned into a blob.\n", "\n", - "sys = shed_new_vorticity!(sys, motion, δ, 0.0, lesp, tesp)\n", + "sys = PotentialFlow.shed_new_vorticity!(sys, motion, δ, 0.0, lesp, tesp)\n", "\n", "states = Tuple[];\n", "forces = [];\n", "moments = [];\n", "\n", - "\n", - "Bf = 1e-1 #1.75e-2 #1e-1\n", - "Tmin = [Inf,2e-1] #[Inf,2e-1] # [Inf,Inf]\n", - "\n", - "\n", - "tf = 50\n", "T = Δt:Δt:tf\n", "\n", "# Set up Theodorsen solution results\n", @@ -793,9 +422,8 @@ "\n", "counter = [0, 0]\n", "\n", - "\n", "countermin = counter_min.(Tmin,Δt)\n", - "ϵ = Bf*Δt \n", + "ϵf = Bf*Δt \n", "\n", "@showprogress for t in T\n", " push!(states, deepcopy(sys))\n", @@ -805,8 +433,8 @@ " compute_ẋ!(ẋs, sys, t)\n", " \n", " lesys, tesys = sys[2]\n", - " push!(forces, Plates.force(plate, motion, sys[2], ẋs[2], (new_element(lesys...)..., new_element(tesys...)...), Δt)) \n", - " push!(moments, Plates.moment(plate, motion, sys[2], ẋs[2], (new_element(lesys...)..., new_element(tesys...)...), Δt)) \n", + " push!(forces, Plates.force(plate, motion, sys[2], ẋs[2], (newest_element(lesys...)..., newest_element(tesys...)...), Δt)) \n", + " push!(moments, Plates.moment(plate, motion, sys[2], ẋs[2], (newest_element(lesys...)..., newest_element(tesys...)...), Δt)) \n", "\n", " advect!(sys, sys, ẋs, Δt)\n", " \n", @@ -817,11 +445,16 @@ " \n", " edge_blobs, edge_sheet = sys[2][i]\n", " \n", - " # Calculate the impulse matching correction on the active vortex position\n", + " # Calculate the impulse matching corrections to the active vortex position\n", " Δzs = [impulse_matching_correction(sblob, edge_blobs[1], plate) for sblob in edge_sheet.blobs] \n", " \n", - " new_blob = transfer_circulation!(edge_sheet, edge_blobs[1], Δzs, plate, ϵ)\n", + " # Circulation is only transferred from the sheet to the active blob if\n", + " # - the sheet is long enough, and\n", + " # - more than one sheet segment can be transferred without surpassing the error tolerance\n", + " new_blob = transfer_circulation!(edge_sheet, edge_blobs[1], Δzs, plate, ϵf)\n", "\n", + " # If the active blob has been modified, then set the counter to zero. Otherwise, increment\n", + " # the counter.\n", " if new_blob == edge_blobs[1]\n", " counter[i] += 1\n", " else\n", @@ -829,14 +462,15 @@ " edge_blobs[1] = new_blob\n", " end\n", " \n", - " # if we have waited long enough, and sheet is sufficiently long, then\n", - " # convert current active vortex into an inactive one, and release tip of sheet as new active vortex\n", + " # if we have waited long enough between active blob releases, and the sheet is sufficiently long,\n", + " # then convert current active vortex into an inactive one, and release tip of sheet as new active vortex\n", " if length(edge_sheet) > 2 && counter[i] > countermin[i]\n", " sheettip_to_blob!(edge_blobs,edge_sheet)\n", " counter[i] = 0\n", " end\n", " end\n", " \n", + " # Fix up the vortex sheet with filtering or remeshing\n", " for i in 1:2\n", " length(sys[2][i]) == 2 || continue\n", " edge_blobs, edge_sheet = sys[2][i]\n", @@ -857,118 +491,1034 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 46, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nO3dZ3wc1aGw8TO7q23qvXdZluVuqhPAlAChxwZMx7TrC0movwAhJDe8ySWXJG9uwEBIwHRwbFpopgVDsAEbAw6SjVxk9a6VVtJqV9tmZ+4HO8YBd20T5/l/k73aPbJX+8ycOTOj6LouAACQlSHWAwAAIJYIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKRGCAEAUiOEAACpEUIAgNQIIQBAaoQQACA1QggAkBohBABIjRACAKS2/xBed911q1evjsJQAACIPtN+H9Hb2+t0OqMwlAPh8/ke/J/f925vzSjKv/4XP01KSor1iAAAE9v+Qxg/QqHQ4jPPM62qNwvDkNCvWb32yX+8YbFYYj0uAMAENpGOEX6ydq3/gzqzMAghTEJJWLft1edfjPWgAAAT20QKYWdLm1n96kurMHS3dcRuOACAb4OJFMJ5p3zPW5S+68vhLNupC86J4XgAAN8CEymEubm5F/z6VufU/IF08+DknNN+fn3NlJqDfZKBgYGtW7eqqrr/hwIAJDCRFssIIc6/4rJzL7+kt7c3NzfXaDQe1Pdqmnbrr3/X6rcqiWkJzhU/PO/UY+ceFaFxAgAmigkWQiGEwWAoKCg4hG98+KllAwVHZKdlCSGEmP3Q8y8RQgDARJoaHaembodtZwWFECKQmN3f3x/D8QAA4oFEIbQnGHVd++prrys9PX3vDwcASEGiEC6+5Lz+1S9oIVUI4e5unl2UlpCQEOtBAQBiTKIQFhYUPHzXzSU96zKb319Ybb/zph/GekQAgNibeItlxiM7K+vnN/8o1qMAAMQRifYIAQD4JkIIAJAaIQQASI0QAgCkJtdimQnB4/G43e7c3NxYDyScgsHg3T+5o3ntBkVRqo876o7f/rfB8G3YCOvr7b3n5p8Obm83J9lPWXTBwisui/WIwuPtV1579rdLPL2OxNysC2/98ekLfhDrEYXHc0889cbSZ/3Do6llBbf87tfVtVNiPaLweHn5c+8++4IaCFYcPvPmu+7kxLCDpei6vu9HzJ8/f9GiRT/4QfR+EwY3uQxGxZZtsWaahRK1l42ekF8b3OTSVd1kN1rSE+x5VoNJEUKEQqHbrrq2ZdU6gy9onVx855//OGX6tFgP9hBpAW20wxtwqSFfyGQzLnvykYa/PCG8biGEzyhqb190293/L9ZjDINrTl2QU+dKTM622FLdVv2EGy896vtHWTPNsR7XuPT39//o6FMzW4Z2fDlYknrfx2+mm7O8Dr/qCemabko0JhZYrRkT7Mdc//G6//3BlWkO744vR44sf3btqq9tkAVH1bE+f8ClhvyhtMlJE+JnfP3Fvz1zze1pwwEhhF/R8q4+638eeXDf36IFNE+vPzASTK9JMiR8GzZJxynGe4RaUBuocw1uclXOzzenJgghhC6Gt7h9zoC3P6B6Q2nViVkzUzOmpexIxcTlGwzs+nwMuNThrW7FqKiekM8Z8A4EkottGdOSX/ng6cFn3snRFCGE+Ljxdzfe/vh7K2M56HHoWz/k+OeIJS3BaDWq3lCRe/L0Kx8b8zi7Wj7d9Mnyxo8+i/UAw6Dh2ZZLJ9/pyunyuPr93pFck8W53r2xqUUIcfjPqxXDRH3H/v31N+wtA0IYhRD5JbPm1p7YeG9fYqrblmtJSDQqBiXoUa2Z5oof5Md6pAfnredf2lVBIYS6qXXrli1TamuFEN5+f9/64cFNruComlhgNaeajBajNdO8K4Qj2z0JiUZ7vjU2Q9+n9557eUcFhRAW3dD84We6rivKHt5+qjfU/9nwYL3L3eG15VismebkEps5dWcINz7YYs00Z81MSZucNHHfvYcmZiHUglr3GmfXBwNJRbbcI9MTkv81EkVUnrfzmtqBUXVoy2jvJ0NNL/XkzU0vPD7LZDu4O07EA2fDaPubfboQs2+p2rGDa8s2V19ctOsBWkAbaR4bqBupcR7jLP+ks2ndjj8fberw+/0WiyUmwz5Y3n7/SJMnb27Gji/zj8nMPyZz19/+7uFrLB83pmeXF5TNMSZYlYO8c0h8yvpu8q9uX5DWNfTVn5ScPf+/lmgBbdfniKbquqYbzRNpozs9M1NVhNCFEKJq+qkdnfUpFxbMW3Te3h7f87HT3e4tOinLlh3X71Wj6d8+7nSjwWK1hgLa1qc73O3enCPTJ19WnFRg3eMslNfh37bMYc00F52YlT4lOUojPjChf7+pnBZUNU372s151LFQxypH3ydD6TXJRSdmpVYlfnNHsPriosFNrvZ3+re/0F04Lyvv6HTDhHrfjkdsQji0ebTpxZ6kIuv0H5bbc/f6y2NONuUekZ57RLpvMND5/sDAFyO7PmcnBJ8z0PRCt384WHZGXkZt8t6meQ1mQ3pNUnpN0uNv3TPc+vmuPzcm2s3mCTAzowW19nccfZ8MlZySs7fH1Bx31Jfrtuj9Tc7+Jo9JP/LEhUKIoFv1OYPJJbYoDnZcBr4YcXf6ys7cefg2pywrcVqZ1uU0CEUIMZxtu+zC84QQu398DG0e3f5Cd/H3svO/mzFRtrJPPPXkpw6r0D5rMwixeuVvh2cX33D+H/bx+OzZqepYqP7+lszpKaWn5SQkxenKgwuuueKO51Zmto8IITSh2w+fXF5eLjSRc1hazaKSfc855c3NyD0qfbDe1bqyr+NdR8U5+Ulx876dMe87H6xca/drQghNiOzpk75WQf9Q8It7mzKnp8y5bZI5Za//O5b0hIJjMwuOzXR3ejtXOTrfHyg9LSf3iPRv5fGprzHedddd+37EihUrZs2aVVNz0LfA3SMtoDW92N3zkbNqYUHRSdkH+DtjshszapOTiuPlnXcg+j4Z2vp0Z/ZhadUXF9lzLQfyZsouzX995euJLr8QQmTnzTt/8ZyT58T5u9DT5fvyL62KUZl6dWnqpMS9PWzuCfNaNI9DBPSKvNlXnXv9z25TFMU/GNj8eLuny5dauYft07ii+kLblnUNfDFSdFK2Je2rlQjHnn7Kp32tLpvBWFty7s9vOvmM0772jfZcS8aU5O41g92rB5NLbOaU+F7FoIvuNYODG9zn/HRh3XB3MD819diZdy29PyNjXxughgRDakVi3tHpo63e7S90JyQakwrj8Vc1Iyuz5PDpXw73BvNSM0864tePPGC32xWDYs+zHsg2iqIo9jxr/twMxaA0PtflcwZSKxLj4ZDNnKOObPQ6O9zDnnRb+olzfvWXJTa7ffcHmKzG7NmpOXPSjJYD+i0zpyRkzUpNrUzseNfRv34oc1rKt37XMNqLZbYt61QUpWJB/gH+l+yR1+EfqHMVnZClGGP/LvwmLahtf77b0+2bfFnxPvZ392jb5i1P3vug6vMfPe97lWNHKIqovqRo90/euNK7bqjtzb7K+flZs1IP7RlCAa3tjb6BOlf1hYVpk5PCO7xw8XT5Nj/RnjE1uezMvEP+4Ov/fLjl1d6CYzKLTsqKz13DkE/btqwz6FarLy065EUinm5f4/Iuc4pp0oWFcbtr2PWPAXend/KlxYf8DKo31PJq78h2z4zrK/axjzXh6WKg3pU+OcloJYThXTWqi/Hv4qi+UONfu/wjwSmLSizpcReJ5pd7VE+oamHBePdydNH5j4HuDwaqFhZm1MbXYQld05v/1jOy3TPlqpLxHxka2e7Z9tfOnMPSSr6fE2+RGKgbaXqxp3LBocd+l4BL3basU9f0msuKvzooHh+8jkDDo21p1UkV5+SNc/tSD+ntb/f3fzY886bKeIuEpuqNK7q8Dv+UK0rGv3052uZNLLDE52RG77oh5yZX7TWlsR7IxBCPp08cEF10rxnsXOWovrQobVKc7kmExWjr2JanOnKPSi85JSd+pkk73nW4WsZqLisO16ai6gltebpDCFFzebHJHi9LaTpXOXo+dtZeXZpYEKblgrpof6e/75Oh2bdVmazx8mO6mj1bnuwoOS037+iw3aFzrM9vyzLH1ZxN0K1ufqzdkp4w6cLC+KxXeOii9fXewU2jtdeU2rLDucig7Y2+7Nmp8bl0dpwi/27QRdsbfb3rhvb/yIOiiILjMidfXrzt2c6ej5xhfvJ4klxmn3Vz5fA295an2rWAtv9viIqiE7KmXlMaxgkTU6Jx6uLSpEJr3X1Nemg/G2fR0f/58MAXIzNvrAxbBYUQiig5NWfq4jKTJV4qOFDn2vxER/UlRWGsoBDCnmuJqwr6BgP19zenViVOvrQ4EhVseaXXPxQM+9MeLE3Vtz7T4WrzzryxIrwVFEIkFlg3PtTqbBgN79MelLq6uu7u7rA/bWRDqGv6tuWdw9s9WdNTIvH8qZWJM26o6PlwsOWVHhHTD0/HhuHO9wYi9OQJyaZp15UbEgybHm6L0EscLMWohH33VDEoZWfl1SwqiZMP0KyZqTNujMjknj3vgBZPRYGrZazllZ5p15alVUdqWkXX9NbX+1RfKELPfyDcnd76+5sLj88qPT03Qv/y1syEuiXN7g7v/h8aMSGf1vBIq67p064ti8S0Stas1NprSrc/393z4WDYn/xA9Pb2HnfccX/4w77WMB+aCIZQC2ibH2tXPaHp15aZEiO1/WvNMM+4ocLT7Wt8ritCL7Ff3asHW1f2ZUyN4GE8g0mpvqio/MxYXnfN3e5te6s/0q8Szt2v8TGYlEivCVR9oY53HboWs4245BLb7NuqIvpvrhgUPaTVL2nxD8dmh8k/HPzy4bbKcwsievJV/jGZVecVfPlI29Dm2OwwBUfVjX9qseVaai7fz6kg45FcYpt5Q0XPR86W13qjv+9xxx13+Hy+a6+9NuzPHKkQqmOhTX9uNSUap1xVEumltyabceristwj0iL6Knumi9aVfb1rnTOurzjYBaIHTRHJZfb9Pywyhre6v1zaFs1z/gIutf+z4ai93K4XbX874rHfxZhgcLWMbX4sZpPeilGJwqHK8nPyc49Mq7+/eazPH+nX+iZzimnG9RWZkZmU2l3G1OTaq0sbl3f1fRruI0H7o6l6/QPNGdOSKxcURHqywZKeMOOGitE279ZlndE8irFhw4annnrqlltumTRpUtifPCKJ8g8H6+9vTim3V19YFJ1FgIpRSanY60lsEaJreuOKrpHtnhk/rojyGQ6+gYCr2RO1l3NsGN66rHPKlSXRXLyqGJXOVY7W1/uituHpdfjrlzRH85QpxajUXl1iSjRu+nOrOhalyUNN1Tvfi/ZuaOHxWWWn5276U8to61g0X1cIoRiUsB8t25vkUtv0H5V3vO2I3IGSPTIYleqLivZxRYvwMtmM0/6zVAtoDY+2ReeNpOv6TTfdlJ2dfccdd0Ti+cP/O+9zBurvb849Or3srLyYHAgZ6/P7BgORfpWQX2t4tD3oVqdfF8GJ372+elDb/GSHY8NIFF6r6/2B1pV9068rTymP6v5oQqJxxo8rRpo8jSu6ovDLNto2tvHBluJTs4tOyIr0a+1OMSjVFxallNvrH2iOwuShOhba9FDLWI8/+qepZB+WNumioobH2qMxeaiL3rXOkD8G+9m2HMuMGyr6Pxtufb03eq8a9ekiQ4KhZlFxek1ydHYKly1btmbNmnvuuSclJSJ79hHZ+K06r6BwXlQ/TXbnGwjU3x/Zo9aqN7TxwRZLqikKE797lJhvnX5tWevrvd2rI3jUWtf0phe7+z8fnnlDhT0vBpeRNCUap11XFhhVNz8e2cnDgXpXw6Ptky4syj0inCsnD5Qiys7Kyz0yPdKTh77BQN2S5pRy++6Xuo2m9JqkHZOH/Z9HcNJbU/Wtyzr7Px1WYnSKhDnFNOP6csUU8Zcf3OQKutX9Py4yFINScFxmFE5E8Xq9P/vZz+bMmXP55ZdH6CXC/zNYM8yxvShtxtTkqvMLI3rUWg/p+d/NqFpYGMOzv+351hnXV/SujdRRaz2kNyxt8w0GZvy4YueNQWLBaDbUXlVishk3/rk16InA5KEuOt51tLzcM+0/y9JrYnlC6o41jRv/1OJqicjk4UiTp35Jc+G8zLIzYzNVs8OOyUNvf6R6HxxVN/2pRQ/p035YHsOTBU02Y+n3IzhRqWt662u9ra/17u888CjRQ3pgJCLzGcONnj/+5r6Ojo777rsvcjcxnbAn1O/PaNvY5sfbS07JyfvORLpO98FSx0INj7Wbk03VF4f5HOGQX+v7ZCj/mPi4VLQu2t7sc3wxMvU/SsN5iwNdbHm6wz8UmHJlaZxcA2V4m3u0zVt8cnZ4n7bnw8GOv3/7rz7hbvdufrI998j4uvqEpuohv5YQvgMo6lho6zMdekjULIqXq094+/31D7RUX1QYzr0gXXS86+j60LFo6blHnHDYM888E7Zn/oZvbQiFEL7BQMPStrTqpPKzx3vVKCGEFtScDaNZM8d7na2w01R9+4quMYe/9sqSGO66RUHf+iEtoO1+d6dx0lS958PB/GMy4+HSyZGii63Pdnr7fDVXlMThHYNDAU3X9DCsXNVF94eDHe86qs4vyJwW8QWiB2WkybP1mc6aRcUp4TiMN9o2tvXpzsyZKWVn5MbFRuq/7Nj3KDw+ayjH8fATyzVNu+jcs74798hDe7agW932166QL3Tv2t8sf3nZli1bSkpKwjvg3UX77hPRZLIbsw9P61s/1Lt2KL0meTyX+XZ3eL98uE0L6FFYhH2wFIOSOT0l5NMCI2pS0bhOb1A9ob71w3F7X6SkQltySThXBCgGJaXMHlefJrtTvSFN1ce5o6/renBUrTwvTi+BPbzF3fBoW0qZfTzrrnVN3/xY+2j72NTFZSmlMTvFaG+sGWZ7rmXrM50Gk5JcYj/kXVU9pHf83dH6am/l+QUFx2Tu8da7MWRJS8ialbpxRdM/Xt304KcN65qGXn3z3dwkZeaMqQf7VM6G0Yal7emTkzxNj5U1byi/4NKzzzknEmPe5dscQiGEwWTInp2m+kIhb8iedyhnDYf8WtvKvraVfaVn5IV9wipsFJFSbh9XBXXR//nw5ifarRnmyF1kJIwCLlX1hva2JzE8PPzayrccA/0lxcVf+7xwd/m6Vw9OiJ/Rudnd8Gi7PdeyazbY5/M1NjZaLJYDv12zoijJJfEbe1uOxZZtaXiita6uwV5oSkk9lA1NRSiKSSk/My8hMY5iHwqFnnxm+XMvvWZOMNYcVpU1M6X9rX7nl6OpVUmHsFGuqXrdvU1aQKv9j7Jxbu9GjslqvHnp3eZgwXVV87aP9rf5ggOd26646CBmEwMudfsL3X3rhqovLsqu0Tvu+W1Ghv3s3y8xJUR2riuO3jeRoohDW8KqqXrfOmfHu470Kcmzb5sUxin+SBvr8/udgf1O1t/+X3e/81G9P6ieNvnwiycvMJlMtVeXTpSbPro7vY1/7SyYl1U47+vr1l57451bf/OXpiGjUahHlz/02l8fTk5OFkL4BgMd7ziGtoyWnZUXo1EfnKwZKQl2Y+OKrqTi4bIzc5e/8bffP/xc22AoK0lcfPrc3/zy9j1+V8iv9XzkdHd6ay4/9NsMRdPtD/36/U96r62Z79q6zVn0/o9/cdkBfZsuVF/IZDMKIYQi4u2YRTAYPO28K9e0qLrR/vCrG64+6/3f/erOGddXdPzd8c//v33njZoP5niNwaRMuqAw/n89hz2eJa3vzc2q+PnUM9Y7W992vHLg36uOhf75+8bcozMm3VplMBs8n39qSTXbyqqstoj/1N/yPcJvcnd621b2m5NN+56K6XxvYOvTHVpQn3RBUd7cDOOEui9lwKU2vdjT/+mQ0WK0ZVv2uDfwxwcevv/5uumph19ZfmaxofQfjg8uufuMCXSI0ZZtyZqV6vhspOXVXj2kW7Mtu7ayr7jhFw1DSYrRrButHSOG0a6Go4uPaFvZ2/ZGX9rkpMmXFsft3O83WTPMeXPTvY7AthWdGz9r2ziiO0LaaMhWt6X1sEnZlRXluz94rNff+f5A4/IuY4JS+v2cuNo92pvX3nj7rkffc+q2Vf3bBgPe4xOm+hr9liSzLdu8t6m/oCfUv36ocUWXp8cXh4cqdrj/oUceXdWuG61CiICwNDdtv+K8U+2J9tSqxIza5N61zrY3+7Jn7+tOuXpIH9rsDrjUXfeGnBC/nqs//Ki+3d3pHX6je1OGxZ6SNXbBgjMO8HsNCYaCYzPTa5J3bCKYC8ry5p+b+f2zIznenSbAr0p42XMt9nxL44quUEBLq05KKrSa0xKMZkMooKWU2e9ect+bqzf4Auq5k49bfMv5eZOidKWG8EossM7+SdXgJlfPR86mF7pTKxOTS22WDLM5xZRakbjjEMX6z7Y+PvdH9cOdjzV//KmztTxx+G79JkOsTrw6JNYMc82iYk+Pr2fN4IZ7Gu15lpTyxKQKS69zTAirEKLInr644tjDA8Xtb/fnHJE26cKi8RwnjhVDgqHk1JxtoYbtdSN3TT1LE/rS5g8/6N/2zvsfnnzSCV6Hf2iL29PtG2ny6CE9e07azBsr4nBRzN58/MlnAePOqYs1jsaPuutemLXYvMZsshtTK3deK8rd5QuMBIOj6lif39U65u31p09NrlxQkFoV7YtJHbjmtm7d+NX/gsNjaNy+/agjjxRC2HMttdeUeh3+hKSdk0yaqjs3uYxWo6KIoFv1DQZGO7yu5rHEAmtxtC4WEy7/e/edHVfesKHJGQqJHm3k6d/8dsefu5o9ji9GEvOt5pQEQ4IS8mm+oYCn2+dqHis/J2/X+qavze4oligd8ZUuhIYEQ+HxWYXHZ431+UeaPGPdvqGtbj2kG0yGV9578w/PfepX7EJY/nvtp1/8atNLTz8U6/EeKkVkTk/JnJ4SdKsj2z3uDq+7yxXya0lFtp0xSNDmf/jVT2c2GSN3jk5EJeZbqxYWViwocDV7Rtu8/j41M8XaNSCEEGNq4P3+LT3pdffd+MtYD3O8yqqL/tZ27zOddZVJ2b5QUIQCRfm5Qgh3h9fr8CcV2wqOy0zMs8bPOQMHaFptteGles20M2lJRt+U75VWVv7bnm7vx87gqGqyGW055rLTc5PL7PG/ynfm1GrTO42qYefcQ2GqXjtlyu4P2P0sIC2gOTePBlyq0EVCksmSnpBzePqkC+J0fdO+paamvvPSk+3t7aqqlpeX79qtt2VbrJlmd4c34BrVVN1oMVjSElLKE4tOzI74VZoPwMT7hw4Xe67la/8Bv7zqD37lXxsgiuHL5j5VVU2mif1PlJBkypqV+s27qy88+5R3P390RE8RQoiQ/5jZVTEYXPgYTEpaddKOJTA/6jznF0te6A8mO71D/bauJ+74U6xHFwZVVVWnHlb0yueDTW6H0IKH5/sXX3WZECJ7Tlr2nFhcbj5MLjr/3OUvvbVqs1s1Jtp01/kn1lZWVn7tMVXnF8RkbONx1aJLVq1Zv3J9x5huzrMHbrj8zB0HqvfIZDdWXxSba/1EyDdPdUhINsXwcmP7NbE/5cPLZPq35TAmo8FonDALZA7W/LNO07TQsy+95fOrR8+a/rOfXB/rEYXNlZdd9J2jDl/2/MtZGWlXL7rEbo+79fSHZtmjS/689MkvGhoLczNvvfE6W+RXEESBwWB4dfnS5c+/VLdp80nzvnvySSfEekThoSjKskeX1G/c+OXmbScc9928vImxPkta3+YT6g/WS6+sXHzXYy6RKoQQocDlx+UvfeD3sR4UACCy2CP8yoJzzvD7A8teficQVGfX1v7qzp/EekQAgIgjhP/mooXzL1o4P9ajAABEz4RcKAgAQLgQQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAALnp+zNjxoxYjxEAgENxyy237Ddziq7rsR4nAAAxw9QoAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGnen4iMAAAL5SURBVCEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBSI4QAAKkRQgCA1AghAEBqhBAAIDVCCACQGiEEAEiNEAIApEYIAQBS+z9JEFCIPSURtAAAAABJRU5ErkJggg==", + "image/png": "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", "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", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\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/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, - "execution_count": 22, + "execution_count": 46, "metadata": {}, "output_type": "execute_result" } @@ -976,1615 +1526,273 @@ "source": [ "plt = plot(states[end],color = cgrad(:RdBu,rev=true), ratio=1,legend=:none,markersize=3,markerstrokealpha=1,\n", " markerstrokewidth=0.5,linewidth=1.5,ticks=nothing,border=nothing,framestyle=false,\n", - " clim=(-0.5,0.5),ylim=(-3,3))\n", - "zc = map(x -> 0.5x[1].zs[64] + 0.5x[1].zs[65],states[1:end]) \n", + " clim=(-0.5,0.5)) #,ylim=(-3,3))\n", + "\n", + "# Plot the trajectory\n", + "zc = map(x -> x[1].c,states[1:end]) \n", "plot!(real.(zc),imag.(zc),linestyle=:dash)\n", - "#savefig(\"oscil-alf05A05-sheet.pdf\")\n", - "#savefig(\"oscil-alf05A05-eps175em3tmin1em1.pdf\")\n", "plt" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 47, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeVxN+f8H8M85595WaVNJFBUhZStkS1pkrFHR2LfBGIOxDMYyGN8x9n2rLGPJTpSijchSJIoSKVvaF6XbXc7n8/vjzq8xiNZ77u2+n394dG/nnvN2T/e87vl8zvl8KEIIAgAAAJQVzXUBAAAAAJcgCAEAACg1CEIAAABKDYIQAACAUoMgBAAAoNQgCAEAACg1CEIAAABKDYIQAACAUoMgBAAAoNQgCAEAACg1uQ5CX1/fx48fc12FAsMYwxB6tUEIgTewNuANrCVCCMaY6yoUW1X+AuU6CK9evQpBWBtCoZBlWa6rUGAikUgsFnNdhQKTSCQikYjrKhQYxlgoFHJdhQLDGEskkm8uJtdBCAAAANQ3CEIAAABKDYIQAACAUoMgBAAAoNQgCAEAACg1CEIAAABKDYIQAACAUoMgBAAAoNQgCAEAACg1HtcFAACA/MIYJyQkcDVQHMZYLBarqqpysnV5o6+v37Jly/pYMwQhAABUKj4+vl+/fm3btuW6EGVXXl6OEEpKSqqPlUMQAgBApViW7dChw507d7guRNmlpKR4eHjU08qhjxAAAIBSgyAEAACg1CAIAQAAKDUIQgAAAEoNghAAAIBSgyAEAACg1DgLwsLCQolEwtXWAQBAEWGMCwsLMcYfP1leXl5SUsJVSTWQmZnp5+f3lQWCgoISExNlVg8HQbhu3Tptbe02bdpoa2v7+PiUlZXJvgYAAFBQHTt2vHTp0sfPTJkyZfny5VV57cyZMx88eFA/dVXDq1evNm3a9JUFDh8+LMt7NzkIQk9Pz8zMzNzc3Ddv3jx9+nTr1q2yrwEAABQRTdNjx449dOhQxTPv37+/cOHCxIkTpQ8FAsEXX1hUVIQQunv3bkFBwSe/quwlX/fhwweWZaU/i0QisVj8yQLl5eWfD00nEAgqXlX7GuoKB0FoaWmpqamJENLV1bWzs8vNzZV9DQAAoKAmTZoUHByclZUlfXjixIm2bdt26tTpxo0bbdu2bdeuXfPmzf/++2/pb318fBYuXGhlZWVlZTV//vwnT56MGzfOwsJC2jIZGBjYpk0bW1vbVq1aBQYGIoQiIiLat28vDcuoqKj27dvn5+d/vPWgoCB3d/dRo0a1bdu2adOmERERS5cutbKyatKkib+/v3SZZ8+e9ezZs02bNsbGxitWrJDG4fv374cNG2ZpadmuXbsLFy5UrPD+/ftdu3a1sbFp3rz55s2b6/3t+xJuhlh79uxZVFRUampqXFzc2bNnK1tMIpFkZ2e/ePFC+lBLS8vAwEBWNQIAwBc8f08OPP1vH129YSg01JTubkh9/GTr1q179OgREBAwb948hNChQ4cmTZpUUlLi6em5Z8+eESNGJCUlOTg42NnZtW/fvrS0NCQkJCYmpkmTJhjjqKioDRs2ODs7I4SePn06Y8aMa9euWVlZpaSk9OvXr0ePHs7OzgMGDBg/fry/v7/0X319/Y+3LhKJwsPDIyIiTp48uXfvXk9Pz9WrV6enp8fFxbm4uEyYMIHH440bN87d3f3333/Pzs52cHCwtbX19PT8448/aJp+9eqVRCJxd3eXrq20tNTDw8PPz8/NzS0/P79nz57du3fv1auXTN7df3EThKWlpSkpKU+ePFFTU8OV/0U9ffo0Jiam4jtCo0aNYmJiaBqudK0qgUDA5/N5PBhRtoaEQiFFUSoqKlwXoqjEYrF0/gSuC6k5gUDwSfteTDZZ9xDLbDYKTFB3Q+aTJydNmrR58+Z58+alpqbGx8dfvHjxzp07Ojo6I0aMQAh16NBhwIABly9fbt++vXThJk2aIIQ+OXiePXvWxsbm9evXr1+/Rgg1b9781q1bHh4ef/31V+/eve3s7MaPH+/m5vZ5SR07dnR0dEQI9e/fv7S0dObMmQghe3t7jPG7d+9UVFRiY2MjIyMRQkZGRhMnTrx48aKnp2dQUNCuXbsYhmEYZtasWdJOzevXr6uoqNA0HR4ejhDq1KlTeHh4ZUFICCktLa3eu4cxn8/n8/lfX4ybQ2Tnzp07d+6MEFq4cOHChQvPnz//xcWsra29vLy8vb1lW13DwTAMBGFt8Pl8CMLakAahQs8ipK6uTlH/OSGb0Jqe0Jrjr+Pe3t5z5sx58ODByZMnhw8f3qRJk4KCgo9P3QwMDCqaNCtrSMvOzs7Ozj59+rT0YdeuXaV5qaKiYmdnt2fPniFDhnzxhY0bN5b+oKKioqGhUXGEUVFREQqFpaWlGhoaGhoaFVu/e/cuQqigoEBPT0/6ZEWp2dnZ5eXlFTXo6Oi0adOmsv81RVGNGjX66hvzKYzxF7skP8HxIdLS0hKGdQcAgGrR1NT08vLy9/cPDAyU9vZZWFg8e/ZMKBRKv3Y8evRo0qRJn7+Qz+dXBIOVlVVSUtK+ffs+WSYoKCg4OHjv3r1jx469f/++trZ2tWozNTUVCoUvXrwwNzeXVmJpaYkQMjc3f/z4cceOHdFHsylZWVlhjLdv387ttyUOgnDLli3dunUzMjJKTk5et27dnDlzZF8DAAAotMmTJzs6OhobG7u4uCCE7OzsrK2tp02b9sMPP1y5cuXly5ejR4/+/FXW1ta+vr5FRUUdO3acMGHC1q1b586d6+XlJRAIIiMjf/zxR0LI1KlTz50717Nnz4SEhKlTp1acrlWRpqbmzJkzJ06cuHr16uTk5BMnTkjPdubMmbN48WJdXV2hULh7927pwr169ercufOoUaN+/vlnPp9/586dHj169OnTp9ZvT/VwEIQCgWDx4sV5eXkmJibLli2bPHmy7GsAAACF1rNnz+XLl3fo0IFh/ulBDA4O3rRp05YtW1q2bBkXFydtRRw5cmSHDh0qXrVp06ZDhw7Fx8c3bdrUysrq3r1727Zt27Rpk4aGRrdu3fT09C5fvrx9+/aePXsihLZs2bJ27dqMjIyP54Vv06aNj4+P9Gdtbe25c+dW/GrOnDm6uroIoa1bt+7Zs2f37t36+vrR0dFWVlYIoVGjRlEU5e/vb2RkdOjQoZs3b0pfFRgYuG/fPl9fX5ZlbW1tW7dujRAaPHiw9FWyQX1+n4f88PLygj7C2oCLZWoJLpappQbQR3j37t05c+ZADw7npBPzJicnV+tV0j7Cb14sA1dgAgAAUGoQhAAAAJQaNJoBAIDCYFn2zZs3nz/frFmzEydO9OzZ08LCok42FB8f//bt28ruoGhgIAgBAEBhvHv3TjouDMY4PT3dzMxMehFAcHDwnj179PT06ioIb9++fevWLQhCAAAA8qV58+bPnz9HCBUXF+vo6Ny4caNFixYfLyAWi4uKij6/iT43N/fzJ/Py8vT19T8ZMSAvL09HR+eTJTHGRUVFFXfEVygvL3///r2hoaG0JKFQ2KRJk4+HsCkuLlZXV//kijOMcV5enoGBwSeb5gr0EQIAQAMRGRlpY2PTrVu3Tp06VcxnsG/fvhYtWjg7O7ds2TIkJET6ZGhoqKmpad++fZs2bVoxWPbTp0/bt2/fp0+fTp063b9/v2K1mzdvbtq0aa9evSwtLStuezA1NV22bJmVldXIkSOLior69u1rb2/v6upqZmaWl5eHEEpKSrKzs3NwcDA3N58zZ470DoU5c+bMmjXLzs6ud+/epqamFXfWcwvOCAEAoBqEQuHly5e/OK94u3btKm7ay83NvXbt2hfX0LNnTxMTE+nPqampDx8+/HwZmqYHDBhQ3RHFEhMTExISVFVVPTw8fH19ly5devPmzfXr19+7d8/IyOjhw4fu7u5Pnz5lWfb7778/efKkq6trcnJyt27devToYW1t/cMPP4wbN27JkiX5+fn29vYODg4IoZiYmP/973/x8fGmpqbHjx8fPXr0s2fP1NXVi4qKMjMz09PTaZrev3+/oaFhdHQ0Quj9+/fq6upisdjT03Pt2rUjR44sLy93dXU9ceKEdALa6OjoW7du6evrL1my5M8//zx27Fi1/o/1AYIQAACqISsrKyAg4Iu/6t27d0UQPn78uLIxWdTV1SuC8ObNm6GhoV9crF27dtJRs6tu8uTJampqCCEnJ6f4+HiE0JkzZ+zt7RMTExMTEwUCgbq6ekJCQmlpqYmJiaurq3Qrrq6uV65cadmy5Y0bN4KCghBC+vr6Pj4+GRkZCKGQkJCRI0eampoihHx8fObPn//w4cMePXoghH766SdpK6iZmVlMTMyWLVsGDx4svSP+/v37ubm52tra4eHhGGMLC4vIyEjpnfje3t7SsUb79++/dOnSav0H6wkEIQAAVIOZmdmpU6e+uVi/fv369ev3zcUmT55ch6NraWlpSX/g8/nSST/y8vKysrKkczsghLy9vfX09N68eSMdAkZKT0+vsLCwqKiIx+NVnIPq6upKg7CoqKhiYYqidHV1CwsLpQ8rxs4eMGDAwYMHAwIC/vjjDysrq6CgoLy8PIqiKrbbtGlTa2vrT4pUUVERiUR19X+vDQhCAABosNq1aycQCNatW/fxk2VlZSkpKRUjdD948MDR0bFp06aqqqrJycnS09CKBltLS8uKc9bCwsKMjAzpOd8n3N3d3d3dRSJR//79z5075+rqWlZWtmDBAumMFnIOghAAABqsWbNmderUacGCBe7u7qWlpaGhoevXr+/WrZuNjc348eOnTJkSHBxcXFzs5eXFMMzcuXMnT568atWqx48fR0REODk5IYQmTpy4fv365cuX9+7de+vWrYMGDZLOJvGxI0eOFBQUdO7cOTc3Nz093cbGxszMbPLkyUOGDFm0aFGjRo0SEhIsLS09PDy4eA++DYIQAAAUj5qa2m+//fbxHEljx46tuImwS5cu0vZMHR2dhw8f7tmz59ChQ5qamr169ZLOFBgcHLxz586jR4+am5vfvXtX2rO4evXq5s2b//333zY2NgEBAe/evZOu4d69e7t27Tp27NigQYOmT58u3cS8efMqtt6pU6fjx4/v3btXW1v7+PHj3bt3Rwjt3Lnz9OnTV65cKSsra9u2rb29PULI3d294hzR1NT0i3NFyR4Mut2QwaDbtQSDbtcSDLoN6goMug0AAADUFwhCAAAASg2CEAAAgFKDIAQAAKDUIAgBAAAoNQhCAAAASg0urAcAgK8pKCiobNRQIDNv376tv5VDEAIAQKVatmzZtWtXroKQEIIxZhiGk63Lm/Hjx9fTmiEIAQCgUkZGRpXNNSEDLMuKRCJ1dXWuClAS0EcIAABAqUEQAgAAUGoQhAAAAJQaBCEAAAClBkEIAABAqUEQAgAAUGoQhAAAAJQaBCEAAAClBkEIAABAqUEQAgAAUGoQhAAAAJQaBCEAAAClBkEIAABAqUEQAgAAUGoQhAAAAJQaBCEAAAClBkEIAABAqXEQhCEhIW5ubsbGxpaWlgsXLhQKhbKvAQAAAJDiyX6Tr1+/nj59es+ePQsKCnx8fNTU1NasWSP7MgAAAADESRD+8MMP0h+MjY0nTpwYEhIi+xoAAAAAKY77CKOiorp06cJtDQAAAJQZRQjhatu7d+/esGFDQkKCtrb2FxewsrJKTU2teGhkZPT06VOahgt8qkogEPD5fB6Pg/P+hkEoFFIUpaKiwnUhikosFmOMVVVVuS5EUbEsKxKJ1NXVuS5EUWGM+Xy+hobG1xfj7BB59OjR//3vf1FRUZWlIELI1tZ2zZo13t7esiysIeHxeBCEtaGiogJBWBsQhLUEQVhLGGOWZb+5GDeHyLNnzy5atCgsLKx169acFAAAAABIcRCEgYGBkyZNOnLkiLq6+osXL1RUVJo3by77MgAAAADESRBGRkYaGBj88ssv0oetW7cODQ2VfRkAAAAA4iQIt23btm3bNtlvFwAAAPgcXIEJAABAqUEQAgAAUGoQhAAAAJQaBCEAAAClBkEIAABAqUEQAgAAUGoQhAAAAJQaBCEAAAClBkEIAABAqUEQAgAAUGoQhAAAAJQaBCEAAAClBkEIAABAqUEQAgAAUGoQhAAAAJQaBCEAAAClBkEIAABAqUEQAgAAUGoQhAAAAJQaBCEAAAClBkEIAABAqUEQAgAAUGoQhAAAAJQaBCEAAAClBkEIAABAqUEQAgAAUGoQhAAAAJQaBCEAAAClBkEIAABAqUEQAgAAUGoQhAAAAJQaBCEAAAClBkEIAABAqUEQAgAAUGoQhAAAAJQaBCEAAAClBkEIAABAqUEQAgAAUGoQhAAAAJQaT/abzMnJOX/+/P3791mW9ff3l30BAAAAQAUOzgiTk5OjoqIQQhcvXpT91gEAAICPcRCEjo6OJ06cGD9+vOw3DQAAAHwC+ggBAAAoNYoQwsmGb9686eHhkZub+5VlOnTokJOTo6mpKX2ora19/fp1mobwriqBQMDn83k8DnqCGwahUEhRlIqKCteFKCqxWIwxVlVV5boQRcWyrEgkUldX57oQRYUx5vP5GhoaX19Mrg+RlpaW06dPHzRokPShioqKtrY2tyUpFh6PB0FYGyoqKhCEtQFBWEsQhLWEMWZZ9puLyfUhks/nGxkZmZubc10IAACABguaGQEAACg1Ds4Inz171qZNG+nPFEVZW1snJSXJvgwAAAAAcRKErVu35uoKHQAAAOAT0DQKAABAqUEQAgAAUGoQhAAAAJQaBCEAAAClBkEIAABAqUEQAgAAUGpyPbIM4FyBEBWJCEJIW4XSh3GyGrRiEbqRReJycXIReicgAglCCKnQyEidstJBXfQpR2PaCIb6anCSCkn4W3I3lyQXkrdlJK8cIYRUGWSoRrXWRp30qT5NKedmtBaf60LrEwQh+I8CIQp5ja+9I/fzSHIRKf9olD5VBllpU12aUP2bUQOb003UuKsS1J0yCTr1Ah9Lw9feEQlGPBqZa1EmGqipFkUh9F5Mnr0nIW+IkEUUYu0MqDEW9NjWNHwrUnSZZcTvKTn6HD8rJgghs0aUjR7qa0zrqCA1hioWkSwBSi0me5Px5kSkxrADW9BTrWj35hRNcV16PYAgBAghRBAKeU32peDQ11iEkb4q6mZIOTejTRtRqgxCCJWz6M0H8qSQBL/Ch1IRQ7FuzanpbekhpnSD/GAog3wh2pLI7knGBULUWptaZEu7mdDdDCj1z44KEowSCkj4W3I2Hc+9wy65x05oTS/uSJs1gn2veDJKyJoH+OhzLCHIyZhaaMMMbEE11/zyrhRjdCubXHiJT6Th8xm4rQ61tBM9xqKhfeo5m4apKry8vLy8vLy9vbkuRFFVZRomgtCpF3h1PH5SRIw10DhL2suc7qJf6fc+gtCDPHIuAx9+Rt58IG11qOWd6dHmDe2DIdVQp2ESsmhrEv7zIVsiRiNa0j9b032aVnX/JRWSnY/x4WcYEzSrPb2iC6NT+dsDs0/UUt3OPlEiRqvj2e2PMY9GU63oOR1oc62q7ncxRucy8F8P8YN8YqtHbXNg+hkrwGdeOvsEn/+Nhl0Iwobsm0F4P4/MusXezSG2etTijrRnK5pPI4RQamrqnTt30tLS3r17V1RUhBDS0NAwNDS0traeMGGC9LUsQecz8NoEnJBPujShdjgwPY0U4INRLQ0yCG9kkWk32KfFZJgZ/T97ur3Ov3vt2bNnDx48SE1NfffuXX5+PsZ4xowZ/fv3/3wlbz+QVQ/wgafYQA3t6Ml4tvryZXcQhLVUh0EY9IrMjGEzy8jkNvSqrnQzjX/3e2Zm5r1791JSUsRi8W+//SZ9sri42N/f38LCws7OzsTERPokQehsOv41FqeXkIlt6M09vvY1SB5UMQihaVRJCSRo2X12WxI2UqcOOzJjLf9zSrdy5UqKoqysrOzs7HR1dRFCHz58yM7OTk5OJoRQFIUQIqykt3pevEfTE2l4cRzuEySZ2Y7+qxujCX9T8kqE0bJ77KZE3EqLujqQ52ryzy5/8+bNihUrQkND+Xy+nZ1d27Ztra2t9fX1aZq2tLSsePm0adPu3bs3ePDgUaNGdejQYX9vZmY7+ocbrFcE62NB9vRitOX7mKi0yiRo7h3WNwV31KPOufDsDSiEECHk1q1bp0+fvnz5cmFhob29ffv27Tt27PjxC7OzsyMiIn744YdGjRoNGjTIy8urd+/enq3oQS3otQnsX49w+Fty1InpW+XmBPlF5Jinp+fJkye5rkKBlZWVicXiz59/mI/bnRZTvqKZNyXFIpKcnDxjxozAwMBqrTw+Pr5JkyYDBw68cuVKqZjMuy2h/UStT4nv5eI6Kp975eXlQqGQ6yrqRkYJtr/wz04v/e8fRUZGxt69e9PS0r6+BrFYHBMTs2jRohYtWnTr1u3vv/8WiUQSTP54wPL9ReYnxA/yPt31IpGovLy8bv8jSkUikZSVldVmDU+LcIczYtpPtCRWImT/efLMmTNWVlbt27dfs2ZNQkICxt/4zCYmJq5du9bGxsbS0nLjxo0fPnwghMTl4janxDx/0boEVm4/89JT6m8uBkHYkH0xCA+lsuoHRc2OicPf4qdPn44aNcrIyGjVqlX5+fnVXb9AIDh06JCtra2dnV1ISMj1d9g0QKx6QLQvmf32ixVBgwnCa5m4yRGRzmHRhQyWEJKTk7NixYqcnJyarY1l2aCgIBcXFzMzM39/f4lEcisbtzguVj8oCnj+n10PQVhLtQzCkNdY+7DI4Igo/O1/oio0NDQmJqYGK7x79+6ECROuX78ufVgiIqMjJchXNCpCUvaFr9zcgyAEnwahBJO5tyXIV+RyWZyWXTx37lwDA4N169aVlpbWZisY43PnzrVr187Nze3uo5SBoWLkK/oxRiJW/DRsGEF4OJVV8Re1Py1+VozFYvGmTZsMDAzmzJlTy1MNQsitW7f69eu3bNkyQkiOgDgGiSlf0er4f3c8BGEt1SYI9zxhef6izufEL0swISQpKalOS/vX+ocs7SfqESjOEdTTFmquikEII8soizIJ8ghjtybhuR3o2ZJQx67WpaWljx8//vXXXzU1NWuzZoqiPDw8Hj16NHDgwMHOfQY93/9rR3r3Ezw0TFIqrqvyQQ39+RBPvM72NaZuDeWVpCXY29tfvXo1JiZm69attb8Ew8HBISoqas2aNQghAzV0dSBvQht6xX12xk2Wld+L8JTCyvvszBh2YHP6xhAeXfR20KBBY8eOxRjX7VYiIiKGDRvmrf36rAvzqID0viR5WaqQOx6CUCkUCpFriOTya7y7F9Pz9blf5s09duyYr6+vgYFBXW2Cx+PNnTs3Pj6+bVurdfaMXx8m7C3pf1kiHagCyB5BaOFddmkcO8aSDnKld2/6093dff78+aGhoa1bt66PLZa9L5qjnfRbJ3pfCh57jRXX8VEXVAlBaM5tdvUDPNWKPu/KBJ092bVrVwcHh9jYWJqu4wO+o6Njz5497e3tS6KPhX/HyysnfS6xqcUKmIUyODmtMWgarSVp02iOgHQ8K1Y7IDqXzhJCxGJxVdoKau/SS6x+UGR9Rvyuti1wnFHcplFMyKwYCfIV/RQjyc3Lc3FxcXJyev36db1uNCUlpVmzZmvWrNmQIKZ8RR5hktJyaBqtleo2jWJCZt6UIF/R/DuSMoFg2rRpVlZW9+/fr78KCSGPHj2S3lgV+6bU6KjI+JgopUherp6BplGAEEI5AtQ/WPLsPbnkxvNoSSOEeDzeN++qqRMtCh95J/3x8r3EKViSJZDBBsE/pOcEu57ghbb0jp7Mg/j4vn37hoWFNW/evF63a2Vlde/evbCwsOvLPDbYfriQgcdeRxI4L5QVgtDsW+yeZLykIz2nWWaf3r1LSkru3bvXpUuXet2ujY1NbGwsIWTaoF5HOrwmBPUPZp+/V6TzQgjChqxARLlfJenvsXfS2kvr58p46+bm5llJd62PDH+TV+wcLMmFNlJZ+TWW3fEYL7Sl13djEEKurq7Lly9nGEYGmzY2Ng4PDzczMzswqdeKFi8vvEJTb9FYkQ6JCmxx7D/ffiZqpzk4OPj4+AQEBDRq1EgGm9bQ0Dh8+PDUqVMnDOy9Qf+OGBOXy+zrDwqz4yEIG6wSMRoWST8vEve6PC35ZujSpUtlXICWllZwcLC9dWvD7U4Zr9+4hUiKRDIuQRmte4g3PMI/tqd/tSjipAA+n79z585Zs2b5Tnb8Ue3eiXQ0+zb77ZeB2vnrIV7/CM9qT6/vxqipqR05cmT+/PkyruGnn346fPjwvrVLrwzkFYvIgBA2XyjjEmoIgrBhErJoeJjkUVZZuyMj1MXFUVFRRkZGsi+DYZgdO3bMnDxea3O/J8kpQ69KpJP7gHpyIBUvjWPHWlDMyV/Gjx/PYSU//vjjvn37zswf7vkhbPcTvOYBtJDWo4OpeEkcO8aS3u7AIIRMTU2dnJw4qcTV1fXGjRud9alLbryMUjL4iqRMET7yEIQNECZo/HX22ouiln7f2bRseubMmboatLdmFixYsH7tas1tbjFxD76Pggvr60vIazL9JuvWDFOHpj5MSDh+/Di39QwePPj06dPm76IntqFX3mcPpkIW1osrb8j0m6yrCfVzo4fyM/Z976ZUgBMTl0sU4iMP40I2QL/GsqeS8lvsH+Tq2G3r1q1fn31CNsaPH9+4cePxU4dcIBfnanbd0VMW/VVKJSGfeEdKbLRZzYMTckqKQ0JCNDQ0uC4KOTg4dO/eneYzmR/I9JusaSPKuZncHKobhMQC4h0h6aBL2d/9c9LpE4mJiXV+j0SNsfcvuCckBpKlC+6iLT3k+iMvL28ZqCv7UvDGBwLDPQO93R03btwoHSBbHgwfPvzM8b9HaL/b+QRvTYKTg7qUWUaGXGX1eGzz4+PLy0oDAwPlIQUr8Gl0xoXXTofyDJekFMn92YHiyBagwVfZxiqUc/za86dPREZGyk8KIoT69u379uaFbjdXbE3Ce5Ll+iMvR+8aqL3wt2T2LXaQKbPxt182btzIdTmfcnNzO/3LMM9W9IK7bNArOCDWDYEEeYSxxS2CkjkAACAASURBVOUS6/OT2fIP586dk8Npj7T4qEvYL+T+uSFX2QIFuYBCzglZ5BEmyS8nHk/WXz53iqvrAL6iSZMm4eHh5Qkhba6tnnObjcyU3488BGHDkVpMvCMl7XSoAFf1cWPHcF3Ol9EUOuzIdNKnxkRJHhfK7wdDgUy7yd7LI47RC8XFuWfPnpXDFJSaN3Mq78Tcl7eCRkdK4ObC2psRw97NJaMzdoeePBQeHm5oaMh1RV+gr68fHhZGx5/Tj9rkHSF5USKnH3kIwgbivRgNC2P5NLroxmjJ4nb5mtPgobNOpPyPPt8dS4OTg1ramIiPPcd/2DGzRg26cOGCmpoa1xVVytbWNiToovrR6WFR13+NgxsqamX7Y3woFQ97eyz80Jbw8HBjY2OuK6qUgYFBRHiYSoxfeZSvRxj7QS4vIoUgbAgwQWOjxKkbx456scuskbx0Cn6FmTZ/ztRxr/8YOPJcpvxfUSa3wt+SxbGstzm9uCPt7u5ey8HTZcDe3v7C6RPqft9vvvwgIA3OCmvo+jsy/y7bu+j6nb1Lr1y5YmpqynVF39CsWbOo8KsaoX8mhZ2ZEi2P34EgCBuCPxLwpfW/WOCs9QtncF1LVa3/ddZQ7zHXlgxZGM3Nfd+K7mUp8YmStNOhDvRlFOC7z/9zcnI67LtHddfwqeeePyqAL0HV9vYDGRUpad2Y2jawRVhYmJWVFdcVVYm5uXl4aLBR1LqTaewW+btWDoJQ4V15Q37/33rdjOtxYYHy3DL2uQvbf2/fseuWn0affg5DzlSPkEWe4awgIZT3Vx9N7u+OqR6vkSNWrfhNtGXw8PM5xbDnq0OMkXckWyZB51yYLtZW1tbWXFdUDba2tm9TEka0Yn6NZW9kydd3IAhCxZZRQjzXneBf2xMXEaKtrc11OdUWd3q3rjpvzJQZCjl1C3fm3mHvx8fzDk3dvW0z17XUxK8/zxwzetTLs5smRUPTeDUsjGVvZ5MDfZm2OgrUCvAvCqGDjkwrLWp0JJsjTwPxQxAqMBFG3+268eHI3PMXL1mYmXBdTk1oqPBuB50grx/1nfmHQgzFJA+OPcd7Y1412jfyoO9eBwcHrsupoUOb12xav+58Bt6SKHcNZfLpTDre9uCDyW4X88IErmupucZ8dMaZyU+IGHW5SH5GY4cgVGA/nEtNXjd6+c7D3znYcl1LzVkZNjp27lJ22IHxZ55zXYsCSC4i0yOKGu0dvmLRPA8PD67LqZU5HeiRrejFceztHLk5Isqr5+/JlOti/aOT+3Vo2blzZ67LqRUbPcoxJ+Ta6rGr7stLyzgEoaI6l4EP79riMmPFqnHuXNdSW96djFcEJ58tNTsAw1F+VZkEeYWJJHvHjXDuuWD+L1yXU1sUQv59mBaqohF+sXAjzVeUs8g7ghWfXWFJ5fr7+crPcFE1Fuy3sRm/fM3ShRHycZd9VYMwIyNj1qxZp06dys7OrteCPnFLbCJv3aryIL2ETIlmu8/bEfw/hblM9OtW2qu5mlCzb7FJcJd95X6+zT7xW2zdWOy/ZwfXtdQNbRW0p/P77L+GDd11HXZ8ZRbcZROCjugknQsOPKeiosJ1OXWAx+PFhZ5ReXJ1xPK92XLQWVjVIDQzM5s6dWpmZub06dN79+79008/PXjwoF4rkzolbP/nQ3m874RDIoxGR7IIoRNOjEpDOaWnKXSkH09bBXmcSMsrkYNPhvw5nob9IxP1UkPDL5yUh4HU64pbe+OZm/6OWe2z4koa17XIo8DX1K5LMeoXlkSGXNLX1+e6nDrTrInO+cCLJWdXD94ewXlnYVWPoxRFde7cee7cuRcuXAgPD2/RosXx48fPnj1br8UhhDCiU+A2s/+acvhuXJboQF+mpZbCt5B8zEgdHXPipQUf6Droe0K4/mTImefvyYybbJ+uHbJfJOvq6nJdTh3bNdWt47jFa6cOv5Hxnuta5EtGCfkh6K3Kfp9Txw63bduW63Lq2MCurX/Zfuzen2N/DX7GbSVVDcKnT5+OHDlyzpw5N27cYFnWzMxsw4YNQqEQ4/rt1JGUFb8sJTCba4UNZ64dnTd8smmJR8uGcjL4ESdjaumy5a+y8kbMXsF1LXJEhJFPJKtCo+NOjCLdPF8dkRt/1rRyGOg1rlgI/cT/kGA09joRHP5p0aIFg9wHcF1Ovdg4vr/d5OWbpg+LfMHld6CqHkwFAsGWLVu+//77S5cujRkzRltb++DBg+Xl5UJhTfq4L1y4MGHChNmzZ6ekpHxlMYlEUrDUDr969BimbkEIIRSXkrF42vfm8w7vdJOvYebr0Kru6g4rT108eWT74VNc1yIvFsZ8uJ/27kBfprlmA41BhPRUUdChnWUlRb2nLue6FnmxMp69k4t2+R1c8+s8rmupR+HrftTt+/348y+LOLyGlFRZVFTU06dPKx6mpqbevHmz6i+vcPLkSSMjo6NHj/7+++/6+vpZWVmVLenp6akx4zDSN1sTXekyyqP4fYlWKxuVMVseF+IqvqSsrEwsFtdrVfXhdSnW/iOOp20Ye/8Bt5VIv+pxW0PwSxZ1HWE/8Tduy6gZkUhUXl5e9eWXRGahJi1nbT1RfyUpioi3mPYTTY0Wl5WVcV1LvbuTjfn+Iu8ISZ2vmWVZkUj0zcWqEYR1xc7O7sCBA9Kfhw4dunbt2sqW9PT01PIrRYOWNrHtW5X/TAOGMbZxGYH6TPZNYav+KgUNQkLIxZcsNT2gsXHLnJwcDsvgPAjflRFNz5WaVg5FH6oRJ/KjukHIYmK/4z6/39TUoqp+22uQcgXE2C+//Wnx+3KJMgQhIeSvhyzyFVXr+FYVVQzCf5tGs7Kyfv3114sXLxYUFNTfCahYLI6Pj3d0dJQ+7Nev3507d76yPIsoNGxFIdP4p5/n1l9V8m/m0jVJGVkjf9s51aoBdg1+bogpPXuC1/su3zsP9RKLxVyXww1M0MB158oi/UMuntXWkNNZBusWTaHzkzprT9ntE8WKlLWvkCDkdSQx65d2ft3KNBrO1cHfsMCGdjOhftoXdPF2ouy3/u/b3LRpUycnp2HDhmlqarq7uy9durRDhw51vr2cnByMccVFwAYGBu/evats4RcvXpSLJLplrwsnHTryu/WD+3Hh4eE0rRRJ8LGzF4P9/fyMV8dstcelpaVVf6FAIODz+Qp6qf2K9ujaxOVPN44LuHR1hJsjJzUIhUKKori6c2vp5dSELTMX7jvbuZlWtfa7/BCLxRjjan2V0UZodzd6VDR/fkz5n52V8TK5LfdKri3z8Fn0p40eXVpaKhKJWFYpbiHbbU91uSL0GjYk8fa1ZkZN6mSdGGM+n8/nf2OO1v8cIh8+fHj69OmhQ4d+/OSZM2eKioomTZrEMEzty1JXV0cIiUT/9IqWl5draGhUtrCBgQHF8PoaSu6KGY2F556vH/zw4cNevXrVvgzFsubvYDzj1PFhzZpVc6RdiqIUNwg1EDrhTOxLjx9WRd+rMzQXl4kwDMNVEEY8y98527vbrPXrRvWU/dbrijQIVVWrdzo70hLNysO7kohOStiqKcPqqTb5lJAr+f2nCeZ9hh5ZMpFCiGVZHo8nPWw2eK00UMAvIwc9T+jvNSHt9tVvpldVYIxJVe7FqmgkzczM3L59+xfbT9+8ebN8+fKSkpLat9hijDU0NO7duyd9uHz5ch8fn8oW9vT0ZPyEy+5JtiayyFe05URI9+7da1+DYjmZxiJf0fJ7NelGVtw+wgoHnrLIV/RnQh33HFQRV32EhQKJhq1L48G/FHJ8pU5tVbePsIJAQmxPfuCZtNuwc1+dVyW3PoiJ3uC5qrauWaX/fN4lEmXpI6wwN0aEOg4eOG5Gnayt2n2ET548qawt1MTEZMmSJfv37699PlMUNWLEiCNHjiCEBALB6dOnR44c+ZXlMaEYCk1tSxuqoyAtl693KDY8L0vJ9JusgyG1onMdnI4roklt6NEW9Ir77Om7z2Q8vB+HvHdHChj1oH1/6TSE4bRqQo1BJ9zU+T+f+23ZiugbN7kuR0a+W3moIC7o1MkTRppK+nlHCK3rzu+46PDVyOvrd+6T2Ub/DUI9Pb3Xr19Xtpy6unrHjh1jY2Nrv8mVK1eeO3euf//+nTt3bt269bBhlTZ9EIohCPEoSpOHfuvERGSSy6+V6IbCi0HB30eICELHnBie0nWM/mtfb8a0EfXjwWsDBn5XVlbGdTn17shzHNa43yr/C32aKWSbdl1pp0PtGNZGNPHAkJGjXr16xXU59e5/525f3/Hr9B3nh7bV47oWLqky6NQgXdWfzy1fvvJ69A0ZbbXi3FAoFH6llZIQgjFet25dHZysElJWVhYdHf3gwTfuEhvh7VPRLCZiSdvT4tanxAIJIYSkp6fXSSVy68CBA/pmbdCekoDnNW8VbABNo1KxOVjFX2TmNt7b21va6C8bsm8afVaMtQ6JHIPEkgZx+0CNm0YrjIqQMKM2tLHpXFpaWldVyaEX7zHTyq7d8gvi/37clbBpVOpQKovmXdZqYvzq1avarKfaTaMqKiomJiZfGT6UoqgPHz7USfqqq6v36dOnU6dOX18MUzRCSHoyxKfRzp7M82LyvwQWY+zo6Hjx4sU6KUYO3bp1a/6ixUXTzk1opz7aQolPBv+fvQG11p556bEr7umrtWvXcl1OfcnMyRt5KkOFRkf7Ndih1KprX2/G1GPuO33bsRMmkQY6Aq0Yo++jWK1l10IWDVXmtp+PTWhNjxnqVjbir7CUHBls7j/v+m+//bZ48eLz589/cdG8vDyBQKbTAhCKQQhVHBGcm1HjW9N/PcSJRdSZM2emTZuWmMjBHSf17dWrVyM9vfhTD5i3sdrZU3m7Cj4x34Ye2Eotc+Kp3ft8K/sTVWhlZWWd+7ol3gxv2EOpVZe2CgpwYsp9dt5IebN69Wquy6kXy+6xd3KIr5O6WSPY7//a04sxd/H5Pa+jDOaq/E8Q6ujonDhxYuLEiaNGjfqkO1AkEs2cOXPIkCH1XtFHCM0ghHgf/W1s7sHoq6EJ19iOXe23bds2bNiwnBxZfF+QmdLS0qFDhxoNn1/U2i3AiWlUB9cPNxAUQocdefqGxmqzz0yfMSMhIYHriuoSIcTNa0KOvs1P0ycPNYOTgv/obkit7aGRP/lUZHKl9xwrriN3MjYm4hntaM9WsN//Q4uPTjgxOeVkUjRb300Bn771Xbt2vXXrVnJycvfu3S0tLX18fBYtWjRz5szWrVsbGBj07du3nuv5D4z+bRqV0lNF+3vzHhWQFffZ0aNHjxs3bsSIETUb+FsOYYzHjBmj1cb+YZfZf9ozXZvA18P/MFBDx5yYV/qd2v+0c9iwYV8ZikHhzF2y4u7zd53n7t7QDdoAvmCBLf2dddPYATseFjSo1tF9R05OGta/gy61pQfs9y/o0oTa0I25+BLP3H/lzJkz9bilL/YcisXiw4cPu7i4GBoaamho2Nvb+/v7y/IiBalBY6YiX9H+5E+vFpl+Q0L7iSIzMcZ41KhRY8aMkX1t9WH+/Pnd+vRX8/3wXai4Tv4/DeZimY+tjmeRr2j00s0BAQH1vS3ZXCxz8PDfak3NtXa8bXgDbNb+YpkKuQLS/Li4zSnx+4Yy6vDtO3f52gYaa+4lVz6MvtJeLFMBEzIiTML/I1HPwCg6Orq6L5ffQber7rux05Gv6MDTT4OwVEzanhabHBfnCkhZWVmPHj1WrFjBSYV1a9qMH1sfyml2TJwjqJsVNsggZDFxuSzWOCh6lF/vsSGDILx27ZqmnhFa/ag2lwfLrToMQkLIjXeY5y8aFSFZt25dcXFxXa2WE+np6VoGzdDsC0eefW2/QxASQgqFxPyE2HBpqKFR09TU1Gq9ttpXjcohaR/h55fPafJQgBOTX04mXpeoqasHBgZGRUWVl5dzUGKdEo7e/kKic8yJMVDjuhQ5RlPoWD+ejgrlFcGWKPhw3CkpKcM9R5VN+ntG//ZwefA39W5KrbVjTr7AoY8zPT09FXc09qKiIke3QaWui6Z6DR5rCfv9G3RU0Clnptiyv5HPqkGDBuXl5dX5JuR6H5DP+ggrdNKnNnZngl+TTYnY0NAwOjpaTU2x0+NAKv77GV7RhelnDF2D32Cojk70Z9JKyORoNj0j49QpRZ3C92JkjMRrQ+fe/aGLqIoW2tJDzehbff8qp9V/+OEHooA3VAiFwoFDPXIs3Dp6ztruAPu9Sro2obb2YBKtJzXr6zV06NA6v39BroPwn/sIK8mFWe1pb3N6aRx7M0vxPgwV0tLS1q1bl1hAfrrFuppQyzrJ9R6RH32aUn/aM2fS8eEX/AULFihiFpaz6HSzCXyH0aedGTU4HlYNhdBhR6ZFY96L0UcePU5esWIF1xVVD8Z43PgJqdhAbfS6086MulKPHVQ9M9rRYy3pmz1WajSz9PHxqdsZOeT6sPvJfYSf8+3DtNKiRkWyWf///SAwMDA9PV0m1dWB7Oxsd3d3TR19zwhWT5U62o/HyRwLCmq+DT2yFb02w/D3Q0GzZ8+OiIjguqLqmRXDxueTvx155lqw16tBRwWdcWYKkbrGvAunTp/euXMn1xVVQ2ZmZnwBVTj2wOF+fMvGsN+rZ19vxlqPThi8t7C0fOnSpXW4ZvkOQul9hJXX2JiPzjgzxSIyKkIixgghVFhY6OrqqhAX1hcXF7u7u48dNy7KcnJ6CTnhxBgqxVwrdYZC6GBfpk1jasm7druOnPr+++/j4uK4LurbWJb9/ffft8TmH0jFv3WiB5vC0bDaOulT+3ozNz/o9/4zeP369QEBAVxXVFUhpc3SRv39m7063C1aAxo8dM6FIQy/eMrJYZ6j6nDNcr0zpGeEXz9LstGjfPsw0VlkwV0WITRx4sSpU6e6ubnl5+fLqMoa+fDhw6BBgxwdHdWHLzufgf/qxvRuCgfEatPio3OujJBFf5X12rPff+jQoY8fP+a6qK8hhPzwww8h128vfqTxXQvq9y7QJFpDYy3puR3oA/mmM/cG//LLLwoxL01MNvnpFjuwBbUK9ntNWTSmjjnxkso0dpZ2rMMuMTkPwq/1EVbwsaAX2NDbH+ODqRghtHjx4qFDh7q5uRUVFcmgyBooLy8fPny4lZXVoAWbl8axoy3oeR3kekfIMytt6pgTLz6fnG08cNPmzQMGDEhNTeW6qC8jhPz888+Jyakvx5000+Yfc4KW8FrZ0I1xbkatzm67/dw1CwsLrsv5miNHjgQEhXmGS1pqUcdhv9eOe3Pqf/ZMQBpe9xAjhAoKCmq/Trk+/kpHlqnK6MPrujFuJtTMGPZWNkEIrV271tHRccCAAcXFxfVdZHWVl5d7eHgYGRkt3bTPJ4ptr0v59oavh7UyqAW11o45noZftB21Zs0aFxcXGQ+KW0W//PLL3dg40U+BAkYz0JVR2rkG6wqPRqeceSaa1M8vzMs1mnBdTqUOHjy49Lff1r5pJWAR7Pc6sciWHmtJL7vHns/Azs7Oe/bsqeUK5ToIv9lHWIGh0In+PLNGlEe4JKOEIIQ2bdrUo0cPV1fXwsLC+q6zWpYtW6arq7vL7/CISEQQOu8CA4rWgV870uMs6RX3WU3HCcHBwfJ2Lw0hZM6cOTExMU2XBCcJtAL689rpwElBHdBTRZfcmHIWDbnClogRxvjly5dcF/Uffn5+K1eubLv6agrf7ER/XlvY73XEtw/T3YAad41d5X92/fr1tbxmSr6DkPp00O2v0FVFl9wYCUaDr7LFIkRR1NatW/v06ePj41O/VVbTihUr/j5ydMIN9KSInOzPs4Arx+oChZBvH6ZPU2rCdbbEsANFydG7ijGeMWNGXFycw58hl/Iab+zOfNdCjspTdO10qNPOvCdFxDtCkpmV061bt6CgIK6L+seOHTv++OMP501XwyUW2xwY9+aw3+uMGoMuuPIM1akZKS2OBkdt3bp1w4YNNV6bnAdhpTfUf1EbbeqMC+9ZMRkZLhFhRFHUpk2b/P3967HE6mvcuPGSeyTwJd7ag3ExgQ9GnVFl0DlXnmkjaliYJLWYIISysrKSkpK4rgudOXMmLS3Na3vo9vTGs9rTc6E/uK65mFB7ezOhb8iK5waXgoKmTZt29OhRrotCq1at2rFjx4T9UYeKLeZ2oGe1h/1exwzVUfAARsiiaU+aXwi7fujQoSVLltRsjAW53je4mkGIEHIypvz6MpGZZPL/z9xhYmJSL8VVR1pa2oEDB6Q/703GGxPxbGv4YNQ9fVUU4s4wFBoQymaWkczMTGdnZ84ncPb29p7ld3XhQ/WhZvQ2GEmkfkxuQ6/sQh9MxYFUl8jIyGXLlq1fv56rYliWnTFjxsWLF385cv2P1809W9GbusN+rxftdKhAV15GKZmWaBQaGR0VFTV58uQajL0n18di6RlhdafqHmdJ/8+eOfYcS2+oqBAeHh4aGlqH5VVRTExMnz59aJpGCF16hX+6xQ42hVlX6ou5FhU8gFdQTgaEsGbWXYKDg3/88cetW7dyWFJkJvk+iu1uSAU4wbzz9ej3LsyMdvT/EnCwxComJub48ePTp0/nZDzS1NTU4uLipUej5jxu4tiUOtqPgctE60/vplSAE3Mvj0yN1w4JiywsLBwzZky111KDscBlxmHWeuRbw0kG5tyWIF/RHw/+Hdn9wYMHJiYm69atk+WcTb6+vkZGRleuXCGE3MzCGgdF3S6IS2U1IUSDnH2iKqIysdoBkd15cZGQvHz5slOnTpMmTRIIqj2pR41nn4iIiBgzZgwh5HY2bnRIZHNWXFBnczAokrqdfeKbWExGR0ooX9HOx2xJScnQoUMdHR2zs7NlVkCFiLdY/aDI7ry4uHaTRsHsE1V0OJWl/URDr0oEYvbhw4cVzzeI2Seq3zRaYUsPZnxretk9dmsSlj7TqVOnO3funD9/fsSIETK4xbCsrGzKlClbtmyJjo52c3N7WEAGX5GYNqKCB/A0YYDBetbPmDrjwntUQNxDJTrGpjdv3hQIBL17905LS6vvTWOM//zzz7Fjx06dOjU2lwwMlTTToK4O5Omq1veWAaIp9LcjM8yMnn2LPfJa4/z583379p05c6Zstl4xiMe1d2ToVYllYyp0IK8xXBMuE+Nb07t7MZdeYp8o0raDbXVfLtdB+PVBt7+OQsi/D+PZiv7lDrvzyT9Z2Lx58+jo6FatWnXu3Pn69et1WOon4uPj7e3tWZaNjY1t06ZNchFxC5E0VqGuDmSayNeF/Q3WoBbUSWcmPo8MCJGI+ZoBAQGTJk3q1avXyZMn62+jb968GTBgwJUrV+Li4tTaO7qFSPTVqIjvmKYweJ6s8Gl00pkZakbPimF3PEGrV68+e/ZsfW+0tLR02rRpAwcORAhdfUsGXZG00qLCB/L04duPDE1vS+/qxQS+xB5hEoEEIYSSkpLmzJlTlbvJ5ToI/xl0u6Y18mh03IkZ3pL++RZ7Nv2fLFRRUdm8efPu3bvHjh37888/l5SU1FW1Fc6ePTtw4MBly5YdOnRIU1MzpYj0D5YwFAofyLTQhL4C2RluRp9xYR7kk35BkiwBmjVrVlhYWD2NvUcI8fPz69q1q5OTU0RERArVzDVEYqROXRvENIedLlsqNDrlzIxsRc+9w/4e/++FAhKJpD7uMrx69aqtrS1CKDIy8mw6HnpV0kabihzEg6GDZW9mO3p/H+bKG+IeKikSIQsLC5Zl//rrr2+/sh5bbWut+0+bKF9RVu1ayMslpHugmPYT7Xnyn5mgCwoKpkyZ0qNHj1qt/UuysrJyc3OlPycW4KZHRcbHRMmFsuuYrKC0fYQfC3uDGx0SmZ8QPy2q9i6oYh/hw4cPe/Xq1aNHj0ePHhFCTqSxqgdEtmfF75S+c0fGfYQfk2AyJVqCfEVToyUilhBC0tPTjYyMZs+enZ+fXyebSE9P9/b2Njc3Dw0NJYRsT2IZP1HvS+LCmnQrfxn0EdbAyTRWxV9kc1b8sgQ3hD7C5tmxfzWKNKrdFytVBkV+x/uuBfVjDLv+Ea54XldX18/PLzo6urZVIoQQunnzZmlpqfRnIyOjJk2aIIRu5xDHIAmPpq4NghElOONiQkV+x/sgIT0vSqLe/XuPkVgs7tGjx/79+4VCYS03ERcXN2XKlJiYmA42Nn8+xD6RbA9D6vpgHrSIcoihkG8fZnln2u8pHhgqKRCili1bPnnyBGPctm3b1atX1+ZCgTdv3syZM8fOzq5Dhw5JSUnOrgNm32J/vs0OMaWvuvNgEDVueZvTIe6816Wke6Dkdk7VbiuUQT7XmKen58mTJ+tkVSKWfB8pQb6isVGSD5WcI61evXrbtm15eXlVX21xcfH+/fu7dOnSvn37tLS0j391IYPVOChqc0qc/p6Dc0EpOCOskPYetz8t5vuLtiX92zBw+/bt7777ztjYeMWKFS9evPj8VZWdEZaXl8fHx3/yZKmYjP7/v7FySd2Wr6g4PCOs8PczVu2AqNUJ8b3cfz6Jz58/nzRpkp6e3o8//vj5fqyKIUOGzJ8/X3o96rsy0i9IjHxFC+5I2Lr+rMMZYY09KcStT4lV/EV7H3/7jFBZgpAQwmKyOp5l/ESdzolffCmcYmNjx44dq62t7eLisnHjxjt37nzxgnuhUBgfH79jx47Bgwdra2uPGDEiNDT0k1sy/nrIMn6i7oHinGpfsV+XIAg/Viwiw69KkK9oZLjk45sZHj9+/PPPPxsaGtrb269cuTIqKqqiLeXjIJRIJMnJyQcPHvTx8dHT0xs8ePDHK0/Ix+1Oixk/0bqEOj8YKjB5CEJCyN0cbBogVj0g2vSIrdg9mZmZq1atMjc379mz59dfnpGRcerUqdjY2M9/FfwKGx0VaR4UHXvOfv7b2oMgrI2CcjI4VGxz5ttBSJEaDUgjG15eXl5eXt7e3nW4ztA3ZEyUhCB0oC8z/EtzY5aVlV29ejU8PPzWrVvJlB/fJgAAHLdJREFUycmGhoZ9+/Y9cuSI9LeJiYndu3e3sLBwcHBwcXEZMGCAtrb2xy8vFaNpN9kTadjbnD7Ul1Hn9E4JgUDA5/N5PLhd4x8EoS2JeEkca6BO7e3FfDwprkQiiY6Ovnr16q1bt1auXOns7IwQEgqFv//++82bN3Nzc1++fGliYtK9e/d+/foNHjzY2Nj4nxditCERr4pn9VWpo06MkzG0gf9LLBZjjFVVub96Ml+IpkazF17iPk2p/b2Zj7sqcnNzDQwMpD/HxsbOmDFDR0eHYRixWJyXl/fq1SstLS07O7t58+b169ev4lUFQrTwLnswFdvoUQH9mfb10/ch7eJSV4dG9hrCGLMsy+d/4y4WpQtChFB6CRkVycblkmlt6U3dGa3K3yKJRPL27VuJRPLxbGcYY+kwMZ+LzSVjr7Ev3pO1dsyijtyPJgFB+EUP8smE62xiARnZit7QjW6lVemOEgqFKSkpxcXFBgYGLVu2/Px4dO0dmXObfVRAvM3pXT3h3phPyU8QSv39DM+7w5aK0WxremknRu+zujDGiYmJ+fn5GGMej9ekSZMWLVp88mVXjJHfU7ziPlskQots6RWdGdV6GycKgrCWIAi/RoTRyvvshke4mQa1zYH2aFnbi4bKJGj1A3ZTIm6mQR3tx/SRj+nmIQgrI8ZoUyL+4wErIWiaFb3AljZr9IVdJhQKKYpSUfnCxQ93csiaB+zl16SlFrW1Bz3sS60LQN6CECGUI0DL7rMHnuJGfDSrPT2rPd1Mo6qf1g8S9PczvOERTi8hTsbU9p5MB936/aRDENYSBOG3xeaSH26wDwtI/2bUn/ZMN4Oa/E0ThE6/wL/G4ZclZIoVvbE7oy0314xBEH5dZhlZ8wAfeIoxQkNM6QmtqQHNabWPvt1/HoR55ehcBvZ/imNziYEaWmjLzLb+z0vAx+QwCKUeF5I1D/CZdExRyL055dmKHtCcruwq31IxuvaOnM/AZ9LxezFyMKSWd2YGymQuLQjCWoIgrBIJRvtT8KoHbI4AuZpQs63p71rQVRwZWcii0+l44yP8sIB00qd2ODC95eNEsAIEYVW8+UB2PsGHU3GWAGnwUJ+mVNcmVDsdqrkmpUpEFEUVs/zXH8jjQnIrm9zPIyxB1rrUzHb0pDa0Bry1XyW3QSiVXkL2p+DjaeRVKUEImWtRHfQos0ZIulvFGL35gJ4WkcdFRIKRtgryaElPb0v3MJTdxxyCsJYgCKuhVIz2puCtSfjtB2KsgTxa0u7NKQdD+otdPmKMbueQs+k4IA3nliNrXWpJR9rHgua+S/AzEIRVJ8Eo6h0Jfo2vvyOPC4kYf7qAJg91bUL1b0YPM6M66cvfzpZLch6EUgShhHwSmUnu5pCUYvKujOSVI4RQIz5qpkG1boy6NKEcjek+TSkVmbd/QxDWUhWDEA6RCCHUiI8W2NBzremg1/jYc3I4Fe9+ghBim2lQnfWRtS5FUYjFKEuAUovJowJSziI1Bg0zo6dY0S4m8jQbOqgpHo1cTShXEwYhJMIovYRklqEyoZimqMZqPBMNZNqIksPvOqD2KIQ661Od4cuNEoMg/BePRsPN6OFmSMgysbkkNpc8LiS3c0jkOyzBSJ1BTdQo88bop/Z0r6aUczP6K5ebAoWmQiMrbcpKGwmFhKKQigocIgFoyCAIv0CVQX2aUnJy5ScAAIB6Bdd8AwAAUGoQhAAAAJQaBCEAAAClxk0fYUZGxv379z98+DB+/HhOCgAAAACkOAjCwMDACRMmmJmZZWZmQhACAADgFgdNowMHDiwsLNy1a5fsNw0AAAB8goMzwi8OYQwAAABwQq7vI8zMzDxy5EhsbKz0oZqa2tKlSyubAgl8rry8nGVZGGKtxqSDbmP82XhroGqkQ6zJ8ziOck46xBoFo1fVlHTWPG6GWAsLCxs5cuTnzycmJpqZmVV9PXw+v1GjRnp6etKHOjo6PB4P/iaqjvl/XBeiqBiGoSgK3sAawxjDG1hL8BGujSrmRb0EobOzc1ZW1ufPV3foWAMDAw8PDxkMut1QSSQSGHS7NqTH8W9+nQRfgTGGN7DGaJomhMAbWGPSQbe/uVi9HCJpmtbQ0KiPNQMAAAB1i4Nzhbdv306cOLGoqKi4uNjV1dXMzMzPz0/2ZQAAAACIkyDU1dX99ddfKx5qamrKvgYAAABAioMg1NDQcHFxkf12AQAAgM/BrQgAAACUGgQhAAAApQZBCAAAQKlBEAIAAFBqEIQAAACUGgQhAAAApQZBCAAAQKlBEAIAAFBqEIQAAACUGgQhAAAApQZBCAAAQKlBEAIAAFBqEIQAAACUGgQhAAAApQZBCAAAQKlBEAIAAFBqEIQAAACUGgQhAAAApQZBCAAAQKlBEAIAAFBqEIQAAACUGgQhAAAApQZBCAAAQKlBEAIAAFBqEIQAAACUGgQhAAAApQZBCAAAQKlBEAIAAFBqEIQAAACUGgQhAAAApQZBCAAAQKlBEAIAAFBqEIQAAACUGgQhAAAApQZBCAAAQKlBEAIAAFBqEIQAAACUGgQhAAAApcbjZKuPHz9OTEzU1NR0dHRs3LgxJzUAAAAAiJMzwgULFgwePDgwMHDnzp0WFhYJCQmyrwEAAACQ4iAIZ86cmZaWFhAQcOXKFU9Pz7Vr18q+BgAAAECKgyC0sLCg6X+2a2JiIhQKZV8DAAAAIMVNH6FUbm7u3r17d+7cWdkC+fn5YWFhBQUF0ofq6upjx46VVXUNAcuyNE1TFMV1IYqKZVmKoliW5boQRcWyLMYY3sAaY/8f14UoKowxIeSbi9VLECYnJ48ZM+bz5w8fPmxjYyP9+cOHDyNGjPDw8Bg+fHhl6xEIBGlpaRX/DW1tbaFQWHE2Cb5JLBYjhKrydwC+SCwWUxQF3yRqTCwWY4zhM1tjLMuKxWIej8szFoVWxT8/qj6OkgKB4NmzZ58/b2lpqaGhIV1gyJAhpqamfn5+X6nSy8vLy8vL29u7zitUEgKBgM/nw6eoxoRCIUVRKioqXBeiqKRBqKqqynUhioplWZFIpK6uznUhikraIMHn87++WL0cItXV1W1tbSv7rUgk8vLy0tfX9/X1ha+KAAAAuMVBDi1cuDA8PFxLS+vHH3+cPn36qlWrZF8DAAAAIMVBo9nQoUOtra0rHurq6sq+BgAAAECKgyB0dnZ2/r/27jyoibMBA/ibhFMShERJgjCoXIrWCqVWqxREpBatWqwcKoXCWK2O4wjVtupYLVNbW+vUq6NWRwMiglUZUJFzwIpaFGUQuRVR5Ao3ikBI9vtjvy/DB1YRlWW7z++vvZJ93Bl5kt03u7NmDf5+AQAA+sIlOgAA4DQUIQAAcBqKEAAAOA1FCAAAnIYiBAAATkMRAgAAp6EIAQCA01CEAADAaShCAADgNBQhAABwGooQAAA4DUUIAACchiIEAABOQxECAACnoQgBAIDTUIQAAMBpKEIAAOA0FCEAAHAaihAAADgNRQgAAJyGIgQAAE5DEQIAAKehCAEAgNNQhAAAwGkoQgAA4DQUIQAAcBqKEAAAOA1FCAAAnIYiBAAATkMRAgAAp6EIAQCA01CEAADAaShCAADgNBQhAABwGooQAAA4DUUIAACchiIEAABOQxECAACn6TCy14qKiqqqKlNTU3t7ex6Px0gGAAAAwkgRrl27Nj4+3srKqry8XCKRJCYmSqXSwY8BAABAGDk1+sMPP5SXl2dkZJSXl5uamu7evXvwMwAAANAYKEKhUPjfffP5MpkMp0YBAIBBzFwjvHXrVlRUVElJiUajCQ0N/afNnjx5cvv2bbFYTM8aGhpOnz59sDICAAAnvJEiTExMPHr0aK+FAoEgOjqanhYKhTY2Nt3d3XFxcSUlJdOmTXvm+1RXV589ezYrK4ueHTZs2IkTJ/h8jHTtr6dPn+rq6uroMPNx51+gs7OTx+Pp6ekxHYStVCqVRqNRqVRMB2ErtVrd1dWlVquZDsJWGo1GV1dXV1f3+Zu9kT+RdnZ2fn5+vRb2LDBbW1tbW1tCiFQq3bJlS0pKyjPfx8bGZvHixT4+Pm8iJBcIBAIU4avQ1dVFEb4Kugj19fWZDsJWdBEaGhoyHYStNBpNfz5GvJE/kdbW1tbW1v3ZUl9fX6PRvIkMAAAA/cHAd4U1a9Y4OjqamZkVFBT8+OOPBw4cGPwMAAAANAaKcPr06ampqU1NTebm5gkJCTNmzBj8DAAAADQGitDPz6/vFUQAAABGYAQmAABwGooQAAA4DUUIAACchiIEAABOQxECAACnoQgBAIDTUIQAAMBpKEIAAOA0FCEAAHAaihAAADgNRQgAAJyGIgQAAE5DEQIAAKcN6SJsbGxsbW1lOgWL5eXlVVZWMp2CxYqKiu7du8d0Cha7f/9+QUEB0ylYrKqqKjc3l+kULNbQ0HDt2rUXbjaki7CkpAT/i17FH3/8cfHiRaZTsNiJEydOnz7NdAoWO3v2bGRkJNMpWCw5OfngwYNMp2CxrKysnTt3vnCzIV2E8OooimI6ArvhAL4KHL1XhAP4ivp5AFGEAADAaShCAADgNN5Q/uotFotFIpGdnR3TQdiqsLBQJBJZWFgwHYStysrKdHR0Ro8ezXQQtqqoqOjs7MR/4QGrqqpqbm52cHBgOghbKZVKQsgLBxzpDEqYAdq/f7+urq6JiQnTQdhKqVQaGhoKhUKmg7BVY2OjQCAYPnw400HYqrW1VaVSSSQSpoOw1ZMnTx4/fiyVSpkOwladnZ3Dhg174WZD+hshAADAm4ZrhAAAwGkoQgAA4DQUIQAAcBqKEAAAOG3ojhqtrq5OTU01MTH58MMP9fT0mI7DMmq1Ojs7u7S01MzMzN3dHQdwwG7fvt3c3Ozi4sJ0EFbKycnJy8szMzNzcXExNjZmOg7LNDY2ZmRkdHR0TJ06dezYsUzHYQeVSpWfn9/a2urq6tpzeVlZ2eXLly0sLNzd3fn83t8Ah+io0ZycHE9Pz/nz59+9e1elUmVkZOjr6zMdik08PDzq6+sdHR0LCgqam5svX748cuRIpkOxT0VFhaOjo5GR0cOHD5nOwjIURYWEhKSlpbm5uTU2Nnp4eKxdu5bpUGySl5fn7u7u6elpYmISExPz22+/BQQEMB1qqEtNTZ03b55IJNJoNA0NDdrl8fHxwcHB3t7e2dnZtra2p06d6v1Kakj6+OOPv//+e4qiVCrV5MmTo6KimE7EMmVlZfSERqOZPn16eHg4s3lYas6cOV999ZWFhQXTQdjn6NGj9vb2LS0tTAdhqzVr1gQGBtLThw4dcnR0ZDQOOzQ1NdXX11++fFksFvdcPnHixMjISIqiWltbpVLp1atXe71wKF4jVKvViYmJixYtIoTo6OgsWLDg3LlzTIdiGWtra3qCx+PJZLKuri5m87DRkSNH5HL57NmzmQ7CStHR0V9++WVtbW16enpTUxPTcdhHIpE8efKEnm5vbx8xYgSzeVjBxMSk790bysvLCwsLvb29CSEikcjT07NvoQzFIqytre3u7tbeGGzUqFGPHj1iNhJ73bp1KzU1denSpUwHYZnq6uodO3b8/PPPTAdhq7t378bFxQUEBOzbt8/Ozi4zM5PpRCwTFhbG5/NdXV3nz58fHR194MABphOx1aNHj0xNTbX3l3lmoQzFIlSr1YQQHo9HzwoEgu7ubkYTsVVFRcUnn3yya9cue3t7prOwzKpVq8LDw/ExfMA6Ojr09fWvXr165syZzZs34wLhy7py5Up2dravr6+vr69KpYqJiWE6EVup1Wptm5B/KJShOGpUJpPx+XylUikSiQghtbW15ubmTIdin0ePHnl4eKxbty44OJjpLCxTVFSUkpJiZmaWnp5eWVnZ1NS0YsWK7du3456Z/Wdubu7q6kr/AZo5c+b69espiur59wieLzw8PCwsbNWqVYSQCRMmvPfee2FhYRj+PQByubypqUmlUunq6hJCamtr5XJ5r22G4jdCXV3d999/PykpiZ5NTk52c3NjNBH71NXVeXp6hoSE4JP4AMjl8qNHj3p4eHh4eDg5ORkYGHh4eBgaGjKdi03c3d1LS0vp6ZKSklGjRqEFX4pAINBe2u/s7OTxeH0H/UN/WFtbm5ubp6enE0K6u7vT09NnzpzZaxvB1q1bGYj2InK5fPXq1YSQY8eO3bx588CBA/j5xEvx8vJ6+PChVCo9d+7cuXPn6urqnJycmA7FGgYGBhP+p7u7+8KFC4cPH6Y/TkI/jRs3bsOGDUqlMj8/f8uWLdu2bXN0dGQ6FJvo6el9/fXX3d3dubm5Gzdu9PHxmTdvHtOhhrq6urrQ0NCkpKTCwsKHDx/m5OS4ubnx+XwDA4MNGzZQFPXLL7+o1eqffvqp18eyIfo7QkJIdnZ2QkKCsbFxYGCgmZkZ03FYJjY2trm5WTtrY2Pj7u7OYB72qqyszMzMxGijAaisrDx+/HhXV5enp+fUqVOZjsM+OTk5SUlJnZ2dU6ZM8fLywlfqF2ptbT158qR21tTUdPHixfR0cnJyZmamXC4PCgrq+2S6oVuEAAAAgwAnnQEAgNNQhAAAwGkoQgAA4DQUIQAAcBqKEAAAOA1FCAAAnIYiBCCdnZ09f3bJIjU1NQqFouej1wZBUVGRQqGg7wkM8C+A3xECd7W1te3cuTMqKuru3buEEJFI5O7uHhoa+sEHHzAd7dlSUlLa2troB8rQ0tPTZ82adf36dWdn59e1l4MHD+7YseOf1i5btmzEiBFr165tb2/Hbefg32Eo3nQbYBAolcpZs2aVlJQEBwd7enoKhcLy8vKYmBhXV1eNRjM07+Jx6NCh8vLynkVobW0dHh4+atSo17iXSZMmaW/Ufv/+/SNHjixatGjy5Mn0EmdnZ4lEEh4ejnvOwb8GvhECRy1cuPDChQt9b+keHR3t5+enLUKKourq6gwMDIYPH/7M96Eoqr6+XiwWCwSCl81A3xT/n+4g2NbW9uTJE5lMpl2yePHi8vLyGzduvOyOeurq6mpsbBw+fHh/vs9lZma6ubkpFIrPPvvshRt3dna2tLT0/Oc8ffpUpVIZGxv33VilUjU0NBgbG2sfFAfAFFwjBC4qLCyMj48PCQnp+2ATf39/bQsePHjQwsJCJpOZmJg4OTldvnxZu1lwcLCbm1tCQoKVlZWZmZlIJFq9erVGoyGEFBcXi8Xi48eP93zbkydPisXiO3fu0LNnzpwZN26cWCyWSqWjR4/+888/e24cFxf31ltvGRsby+VyoVAYGhpKCJk/f358fHxubq5YLBaLxfT526ysLLlcnpeXRwhZs2aNnZ1dr2etzZgxY9GiRfR0a2vr8uXLxWKxXC43Njb29vZWKpUDOHpHjhyRy+UdHR30rIWFRXh4+Pr1601NTaVSqbW19fXr1xsaGry9vYVCoYmJyezZs+vr67Uvb29vX7NmjUQioWN89NFHlZWVA4gB8NpQANyzd+9eQsjFixefs83hw4cJIQEBAdnZ2ampqY6OjoaGhgUFBfRaHx8fsVg8fvz42NjY7OzssLAwQkh0dDS91snJaebMmT3fzcPDY+LEifR0TEwMj8cLCQm5du1aTk7O8uXL+Xx+WloavfbUqVM8Hm/27NkpKSl37tw5c+bMpk2bKIq6ceOGi4uLra1tSkpKSkrK1atXKYpKS0sjhFy/fl07ff78ee1Ob9++TQiJiIigKEqlUk2fPl0mkx07duzOnTtxcXGjR4+eMmWKWq1+zkHIyMgghCgUip4Ld+/eTQhpb2+nZ42MjKRSqbe3d2ZmZlJSko2NzdixYz08PL755ptr165FRkYKhcIvvviC3lij0cyZM0cikRw8eDA/P//8+fP29vYODg6dnZ3PiQHwRqEIgYvWr19PCCkuLn7ONlZWVs7OzhqNhp6trq42MDAIDAykZ318fPh8fn5+Pj2r0Wjs7Ox8fHzo2d27d/N4vHv37tGzlZWVAoFg165dFEWp1WorK6t58+Zpd6TRaKZNm+bl5UVPW1lZTZo06Zn99Omnn77zzjs9l/QsQo1GM3bsWG0GiqLWrVsnFArb2tooiqLvyp+RkaFd+9dffxFCtAX8TP0swnHjxqlUKno2MjKSEKI9UBRFrVy50szMjJ6+ePEiISQuLk67lm7r06dPPycGwBuFU6PARfQ5zOc86bSxsbGiosLX11d7mlQmk7m5uV26dEm7jaWl5YQJE+hpHo83fvz4hw8f0rNLly7V09OLioqiZyMiIng8nr+/PyGkuLi4oqLCxsYm9X/S0tIsLS3pPigtLa2oqAgKChrAU1h5PN6yZcvi4+ObmpoIId3d3dHR0b6+vvRDZ5KTk42MjLq6urT7bW9v19HRyc/Pf9kd9TVr1iwdnf+OvLOzsyOEeHp6atfa2dkplUr6VGpSUpJAINDT09PGqKmpEYlEryUGwMBg1ChwkVwuJ4RUVlba2Ng8c4MHDx5oN9MyNzfPysrSzorF4p5r9fX1tY8Ul0gkc+fOVSgUmzZt4vF4ERERc+fOpYe91NbWEkIOHz6sUCh6vpwea0NfS7O0tBzYvysoKCg8PDwmJmblypWJiYk1NTWBgYH0qtra2o6ODl9f357bi0QiujVfkampqXZaT0+v7xKKorq6ugwMDGpraymK6vV8Rx0dHZb+jhP+HVCEwEUuLi6EkKSkpL6DZWhGRkaEkF5jSZRKpYmJST93ERgYuGDBgitXrggEgqKiou3bt9PL6dGne/fuDQoK6vsq+v1ramr6uZdexowZ4+LiolAoVq5cqVAoxowZM2PGDO1+TU1NBzY65jUaPny4np5ebW0tfn0BQwdOjQIXTZkyZerUqfv37y8pKem16u+//6YoytraeuTIkefPn9cub2lpuXTpUv+ftO7l5SWTyRQKhUKhkEgkXl5e9PKJEydKJJLY2Nhnvsre3l4qlZ46deqZa4VC4dOnT5+/38DAwGvXrl25cuXcuXOff/659tSuq6trfX19enp6P/O/Ia6urh0dHQkJCczGAOgJRQgcFRERYWhoOGPGjD179hQWFlZVVWVlZa1evZr+WQKfzw8LC0tNTf3uu++USmVZWZm/v//jx4/p0aH9oaOjs2TJktjY2JiYmKVLl+rr69PLdXV1t23blpiYuGLFipKSkqdPn967d+/YsWO//vorIUQgEGzduvXSpUvLly8vLS1tb2/Pzc39/fff6ddOmDChpKQkMjLy+vXrBQUFz9zv4sWLjYyMli5dqlKpAgICtMsDAgIcHBwCAgJiY2MbGhqampqys7NDQ0P7fhR4oxYtWvTuu++uWLEiIiJCqVS2tLTk5OR8++23N2/eHMwYAP+H4cE6AMy5f/++r6+vtqIIIZMnTz558iS9Vq1Wb9y4UbvWzMzs1KlT2tf6+Pg4Ojr2fDcfH59eQzrp8S+EkJycnF67PnDgQM8fnkul0r1792rX7tmzR3sOlsfjLVmyhF7e2trq5+c3cuRIQsjbb79N/f+oUS26/9zd3XvttLq6euHChdphOHw+f9q0aQ8ePHjOIernqNHNmzdr1966dYsQcuHCBe2Sffv2EUJaWlro2YaGBn9/f+39B3g8nrOzc1FR0XNiALxRuLMMcF17e3tZWVl3d7e1tXXf28c8fvy4oKDAwMDAwcFBOzDytVCr1cXFxY8fP5bJZBYWFr2GiapUqoKCApVKZWVlRTffc97npW5q09TUVFpaamhoaGlp2Z9Lnmq1ms/n97znHEVRGo1mAHfS6am1tbW4uFhfX9/CwqLXsCOAQYYiBAAATsM1QgAA4DQUIQAAcBqKEAAAOA1FCAAAnIYiBAAATkMRAgAAp/0HCwW6Y/XpUbIAAAAASUVORK5CYII=", "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", - "0\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "30\n", - "\n", - "\n", - "40\n", - "\n", - "\n", - "50\n", - "\n", - "\n", - "Convective Time\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−3\n", - "\n", - "\n", - "−2\n", - "\n", - "\n", - "−1\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "1\n", - "\n", - "\n", - "2\n", - "\n", - "\n", - "3\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\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/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "30\n", - "\n", - "\n", - "40\n", - "\n", - "\n", - "50\n", - "\n", - "\n", - "Convective Time\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−3\n", - "\n", - "\n", - "−2\n", - "\n", - "\n", - "−1\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "1\n", - "\n", - "\n", - "2\n", - "\n", - "\n", - "3\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 23, + "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "plt = plot(ylabel = \"\\$C_y\\$\", ylim = (-3.5,3.5), \n", + "plt = plot(ylabel = \"\\$C_y\\$\", xlim = (0,Inf), ylim = (-3.5,3.5), \n", " xlabel = \"Convective Time\")\n", - "plot!(Δt:Δt:tf, 2imag.(forces), linewidth = 1.5, linestyle = :solid, label = \"sheet\")\n", + "plot!(Δt:Δt:tf, 2imag.(forces), linewidth = 1.5, linestyle = :solid, label = \"Vortex model\")\n", "plot!(Δt:Δt:tf, 2fytheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")\n", "plt" ] }, { "cell_type": "code", - "execution_count": 158, + "execution_count": 33, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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", - "0\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "30\n", - "\n", - "\n", - "40\n", - "\n", - "\n", - "50\n", - "\n", - "\n", - "Convective Time\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−1.0\n", - "\n", - "\n", - "−0.5\n", - "\n", - "\n", - "0.0\n", - "\n", - "\n", - "0.5\n", - "\n", - "\n", - "1.0\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\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/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", - " \n", + " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "30\n", - "\n", - "\n", - "40\n", - "\n", - "\n", - "50\n", - "\n", - "\n", - "Convective Time\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−1.0\n", - "\n", - "\n", - "−0.5\n", - "\n", - "\n", - "0.0\n", - "\n", - "\n", - "0.5\n", - "\n", - "\n", - "1.0\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 158, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "plt = plot(ylabel = \"\\$C_M\\$\", ylim = (-1,1), \n", + "plt = plot(ylabel = \"\\$C_M\\$\", xlim = (0,Inf), ylim = (-1,1), \n", " xlabel = \"Convective Time\")\n", - "plot!(plt,Δt:Δt:tf, 2moments, linewidth = 1.5, linestyle = :solid, label = \"sheet\")\n", + "plot!(plt,Δt:Δt:tf, 2moments, linewidth = 1.5, linestyle = :solid, label = \"Vortex model\")\n", "plot!(plt,Δt:Δt:tf, 2momtheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Evaluation of Kinsey and Dumas results" - ] - }, - { - "cell_type": "code", - "execution_count": 149, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "f* = 0.14\n", - "Δα = 5.0\n", - "α(1/4) = 5.0\n", - "K = 0.4398229715025711\n", - "χ = Inf\n" - ] - } - ], - "source": [ - "L = 1.0 # chord length\n", - "ċ = L # translation velocity\n", - "# α = π/3#*ramp(0)#π/30 # angle of attack\n", - "\n", - "N = 128 # number of plate control points\n", - "\n", - "Δt = 1e-2; # time step\n", - "δ = 0.05 #0.01\n", - "lesp = 10.0 #0.1\n", - "tesp = 0.0\n", - "\n", - "a = 0.5 #0.2 # location of pitch axis, a = 0.5 is leading edge\n", - "ϕ = -π/2 # phase lag of pitch to heave\n", - "A = 0.0 #1.0 # amplitude/chord\n", - "fstar = 0.14 # fc/U\n", - "α₀ = 0π/180 # mean angle of attack\n", - "Δα = 5π/180 #20π/180 # amplitude of pitching\n", - "\n", - "# specify feathering parameter\n", - "#χ = 1.0 # feathering parameter\n", - "#Δα = χ*atan(2π*A*fstar)\n", - "#fstar = tan(Δα/χ)/(2π*A)\n", - "#println(\"α(1/4) = \",α₀/χ - α₀)\n", - "χ = Δα/atan(2π*A*fstar)\n", - "K = π*fstar # reduced frequency, K = πfc/U\n", - "println(\"f* = \",fstar)\n", - "println(\"Δα = \",Δα*180/π)\n", - "println(\"α(1/4) = \",abs(atan(2*K*A)-Δα)*180/π)\n", - "println(\"K = \",K)\n", - "println(\"χ = \",χ)\n", - "\n", - "\n", - "oscil = RigidBodyMotions.PitchHeave(1.0,a,K,ϕ,α₀,Δα,A);" - ] - }, - { - "cell_type": "code", - "execution_count": 146, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "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", - "0\n", - "\n", - "\n", - "5\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "15\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "25\n", - "\n", - "\n", - "Convective time\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−30\n", - "\n", - "\n", - "−20\n", - "\n", - "\n", - "−10\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "30\n", - "\n", - "\n", - "Effective angle (deg)\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "5\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "15\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "25\n", - "\n", - "\n", - "Convective time\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−30\n", - "\n", - "\n", - "−20\n", - "\n", - "\n", - "−10\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "30\n", - "\n", - "\n", - "Effective angle (deg)\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - "execution_count": 146, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "t = 0:0.01:(4.0./fstar)\n", - "#plot(t,oscil.Ẏ.(t))\n", - "#plot!(t,oscil.α̇.(t))\n", - "Vy = map(x -> imag(x[1]),oscil.(t))\n", - "αeff = atan.(-Vy)+oscil.α.(t)\n", - "plot(t,αeff*180/π,ylim=(-30,30),ylabel=\"Effective angle (deg)\",xlabel=\"Convective time\")" - ] - }, - { - "cell_type": "code", - "execution_count": 147, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:01\u001b[39m\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total number of vortex elements at tf = 31\n" - ] - } - ], - "source": [ - "plate = Plate(N, L, 0, oscil.α(0.0))\n", - "motion = Plates.RigidBodyMotion(oscil);\n", - "Plates.enforce_no_flow_through!(plate, motion, (), 0.0)\n", - "\n", - "sys = (plate, ((), ()))\n", - "\n", - "# sys[1] is the plate, sys[2] is the vortex system\n", - "# sys[2][i] corresponds to edge i (i = 1 is leading edge, i = 2 is trailing edge)\n", - "# sys[2][i][1] is the set of blobs associated with edge i\n", - "# sys[2][i][2] is the vortex sheet associated with edge i\n", - "# sys[2][i][1][1] is the current active vortex for edge i\n", - "\n", - "sys = shed_new_vorticity!(sys, motion, δ, 0.0, lesp, 0.0)\n", - "states = Tuple[];\n", - "forces = [];\n", - "\n", - "tf = 60\n", - "T = Δt:Δt:tf\n", - "\n", - "counter = [0, 0]\n", - "ϵ = 1e-3 #0 #1e-3\n", - "countermin = [10,10] #[10,10] #[Inf, Inf]\n", - "@showprogress for t in T\n", - " push!(states, deepcopy(sys))\n", - "\n", - " # Perform the impulse matching correction on the active vortex position, but only if there is a sheet and vortex\n", - " Δzs = [length(sys[2][i]) == 2 ? [impulse_matching_correction(sblob, sys[2][i][1][1], sys[1]) for sblob in sys[2][i][2].blobs] : [] for i in 1:2]\n", - " \n", - " ẋs = (motion, allocate_velocity(sys[2]))\n", - " compute_ẋ!(ẋs, sys, t)\n", - " \n", - " push!(forces, Plates.force(plate, motion, sys[2], ẋs[2], (new_element(sys[2][1]...)..., new_element(sys[2][2]...)...), Δt)) \n", - " advect!(sys, sys, ẋs, Δt)\n", - " \n", - " for i in 1:2 # each edge\n", - "# @show sys[2][i]\n", - " if length(sys[2][i]) != 2\n", - "# @show \"! $i\"\n", - " continue\n", - " end\n", - " point = transfer_circulation!(sys[2][i][2], sys[2][i][1][1], Δzs[i], plate, ϵ)\n", - " if point == sys[2][i][1][1]\n", - " # nothing was done to the active blob in this step.\n", - " counter[i] += 1\n", - "# @show \":( $i)\"\n", - " else\n", - "# @show i\n", - " counter[i] = 0\n", - " sys[2][i][1][1] = point\n", - " end\n", - " if length(sys[2][i][2]) > 2 && counter[i] > countermin[i]\n", - " # convert current active vortex into an inactive one, and release tip of sheet as new active vortex\n", - " tips = sys[2][i][2].blobs[1:2]\n", - " # factor of 2 in circulation is due to the trapezoidal weight on blob strength of first blob\n", - " newPoint = Vortex.Blob(0.5*(tips[1].z + tips[2].z), 2circulation(tips[1]), tips[1].δ)\n", - " splice!(sys[2][i][2].blobs, 1)\n", - " splice!(sys[2][i][2].Ss, 1)\n", - " # now the second blob is the first blob and needs to have its strength adjusted for trapezoidal weight\n", - " sys[2][i][2].blobs[1] = Vortex.Blob(tips[2].z, 0.5*(sys[2][i][2].Ss[2] - sys[2][i][2].Ss[1]), tips[2].δ)\n", - " pushfirst!(sys[2][i][1], newPoint) # used to be unshift!\n", - " counter[i] = 0\n", - " end\n", - " end\n", - " \n", - " length(sys[2][1]) == 2 && Sheets.arclength(sys[2][1][2]) ≥ 50Δt && Sheets.filter!(sys[2][1][2], 2Δt, 8Δt)\n", - " length(sys[2][2]) == 2 && Sheets.arclength(sys[2][2][2]) ≥ 50Δt && Sheets.filter!(sys[2][2][2], 2Δt, 8Δt)\n", - " \n", - " # or remeshing instead\n", - " #length(sys[2][1]) == 2 && Sheets.arclength(sys[2][1][2]) ≥ 30Δt && Sheets.remesh!(sys[2][1][2],2Δt)\n", - " #length(sys[2][2]) == 2 && Sheets.arclength(sys[2][2][2]) ≥ 30Δt && Sheets.remesh!(sys[2][2][2],2Δt)\n", - " \n", - " Plates.enforce_no_flow_through!(plate, motion, sys[2], t)\n", - " sys = shed_new_vorticity!(sys, motion, δ, t, lesp, 0.0)\n", - " \n", - "\n", - "end\n", - "println(\"Total number of vortex elements at tf = \",sum(length(states[end][2][j][i]) for i = 1:2, j = 2))" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "6000" - ] - }, - "execution_count": 61, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "length(states)" - ] - }, - { - "cell_type": "code", - "execution_count": 148, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "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" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - "execution_count": 148, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plt = plot(states[end],color = cgrad(:RdBu,rev=true), ratio=1,legend=:none,markersize=3,markerstrokealpha=1,\n", - " markerstrokewidth=0.5,linewidth=2,ticks=nothing,border=nothing,framestyle=false,\n", - " clim=(-1,1),ylim=(-3,3)) #,xlim=(-2,13))\n", - "zc = map(x -> 0.5x[1].zs[64] + 0.5x[1].zs[65],states[1:end]) \n", - "plot!(real.(zc),imag.(zc),linestyle=:dash,color=:black,linewidth=1)\n", - "#savefig(\"oscil-alf60A1-eps1em3tmin02-t50.pdf\")\n", - "#savefig(\"oscil-alf20A1-sheet-t12.pdf\")\n", - "plt" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "metadata": {}, - "outputs": [], - "source": [ - "for n in [20, 50, 100]\n", - " plot(states[n], ratio=1, markersize = 3, markerstrokealpha = 0, linewidth=1,\n", - " color = cgrad(:RdBu,rev=true), clim = (-0.02, 0.02), legend = :none,\n", - " ylim = (-1.2,0.5), xlim = real(states[n][1].zs[end]) .+ (-2, 0.1), size = (200, 160))\n", - " #plot!(filter(b -> circulation(b) < 0, states[n][2][1][1]), marker_z = nothing, markersize = 3, markerstrokealpha = 0, markercolor = :white)\n", - " #savefig(\"pitchup_k07_d10_t$(lpad(n, 3, 0)).pdf\")\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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" - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jeff/.julia/v0.6/Conda/deps/usr/lib/python2.7/site-packages/matplotlib/cbook/deprecation.py:107: MatplotlibDeprecationWarning: Passing one of 'on', 'true', 'off', 'false' as a boolean is deprecated; use an actual boolean (True/False) instead.\n", - " warnings.warn(message, mplDeprecation, stacklevel=1)\n" - ] - } - ], - "source": [ - "plt = plot(states[100],color = :RdBu_r, ratio=1,legend=:none,markersize=4,markerstrokealpha=1,\n", - " markerstrokewidth=0.5,linewidth=2,ticks=nothing,border=nothing,framestyle=false,\n", - " clim=(-1,1),ylim=(-2,2))" - ] - }, - { - "cell_type": "code", - "execution_count": 89, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3-element Array{Float64,1}:\n", - " 0.383144\n", - " 16.0873 \n", - " 89.3972 " - ] - }, - "execution_count": 89, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "180*pitchup.α.([0.2, 0.5, 1.5])/π" - ] - }, - { - "cell_type": "code", - "execution_count": 286, - "metadata": {}, - "outputs": [], - "source": [ - "forces_alf20A1_eps1em3cmin20 = deepcopy(forces);\n", - "states_alf20A1_eps1em3cmin20 = deepcopy(states);" - ] - }, - { - "cell_type": "code", - "execution_count": 297, - "metadata": {}, - "outputs": [], - "source": [ - "forces_alf20A1_sheet = deepcopy(forces_sheet);\n", - "states_alf20A1_sheet = deepcopy(states_sheet);" - ] - }, - { - "cell_type": "code", - "execution_count": 171, - "metadata": {}, - "outputs": [], - "source": [ - "plot(T,180pitchup_k07.α.(T)/π,xlim = (0,5), ylim = (0,100),legend=false)\n", - "plot!(T,180pitchup_k02.α.(T)/π,xlim = (0,5), ylim = (0,100),legend=false)\n", - "savefig(\"pitchup_alpha.pdf\")" - ] - }, - { - "cell_type": "code", - "execution_count": 295, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "5000" - ] - }, - "execution_count": 295, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "length(forces_alf20A1_eps1em3cmin20)" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "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", - "0\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "30\n", - "\n", - "\n", - "40\n", - "\n", - "\n", - "50\n", - "\n", - "\n", - "60\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−3\n", - "\n", - "\n", - "−2\n", - "\n", - "\n", - "−1\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "1\n", - "\n", - "\n", - "2\n", - "\n", - "\n", - "3\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "30\n", - "\n", - "\n", - "40\n", - "\n", - "\n", - "50\n", - "\n", - "\n", - "60\n", - "\n", - "\n", - "Convective Time\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−3\n", - "\n", - "\n", - "−2\n", - "\n", - "\n", - "−1\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "1\n", - "\n", - "\n", - "2\n", - "\n", - "\n", - "3\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "30\n", - "\n", - "\n", - "40\n", - "\n", - "\n", - "50\n", - "\n", - "\n", - "60\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−3\n", - "\n", - "\n", - "−2\n", - "\n", - "\n", - "−1\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "1\n", - "\n", - "\n", - "2\n", - "\n", - "\n", - "3\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "10\n", - "\n", - "\n", - "20\n", - "\n", - "\n", - "30\n", - "\n", - "\n", - "40\n", - "\n", - "\n", - "50\n", - "\n", - "\n", - "60\n", - "\n", - "\n", - "Convective Time\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "−3\n", - "\n", - "\n", - "−2\n", - "\n", - "\n", - "−1\n", - "\n", - "\n", - "0\n", - "\n", - "\n", - "1\n", - "\n", - "\n", - "2\n", - "\n", - "\n", - "3\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - "execution_count": 64, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Vy = map(x -> imag(x[1]),oscil.(Δt:Δt:50))\n", - "plt = plot(layout = (2,1), \n", - " ylabel = [\"\\$C_y\\$\" \"\\$C_x\\$\"], ylim = [(-3,3) (-3, 3)], \n", - " xlabel = [\"\" \"Convective Time\"], size = (600, 300), legend = :none)\n", - "plot!((Δt:Δt:60), [2imag.(forces) 2real.(forces)], linewidth = 1.5, linestyle = :solid)\n", - "#plot!((Δt:Δt:12), [2imag.(forces_alf20A1_sheet) 2real.(forces_alf20A1_sheet)], linewidth = 1.5, linestyle = :solid)\n", - "#plot!((Δt:Δt:tf), [Vy Vy])\n", - "#savefig(\"oscil-force-alf20A1.pdf\")\n", - "plt" - ] - }, - { - "cell_type": "code", - "execution_count": 439, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.8254777667281494" - ] - }, - "execution_count": 439, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mean(2real.(forces_alf20A1_eps1em3cmin20))" - ] - }, - { - "cell_type": "code", - "execution_count": 442, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "-0.5356737589022174" - ] - }, - "execution_count": 442, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mean(imag.(forces_alf20A1_eps1em3cmin20).*Vy)" - ] - }, - { - "cell_type": "code", - "execution_count": 147, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAEsCAYAAAAfPc2WAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xd4FNX+P/D3mdlkSdtNQoAAIQhShUBAiooICKJ+bdhA8cK14VUUrNcfKiAgRVGvDe61YblYKIoULwIiFqqhJQhIBIQQQklCyG767syc3x+TLCykAclmN75fz7NP2CnLmTOzu5895TNCSilBRERERDVGqesCEBEREdU3DLCIiIiIapjPA6xZs2ahR48esFqtGDJkiGd5ZmYm7rnnHsTFxcFms6Fbt25YunSpr4tHREREdMF8HmA1a9YM48ePx6hRo7yW5+fno1u3bti0aRNyc3MxZcoU3H333di9e7evi0hERER0QURdDXKfNGkSkpOTsXjx4gq36d69Ox577DHcf//9PiwZERER0YWx1HUBKpKZmYnff/8dXbp0KXe9lBLZ2dkIDg6GEMKz3Gq1wmq1+qqYRERERGfxy0HuJSUluOuuuzB06FD06NGj3G3y8vLQuHFjREZGwm63ex4zZszwcWmJiIiIvPldC5bL5cKdd96J0NBQfPDBB1Vun56eDpvN5nnO1isiIiKqa34VYJUFVy6XC0uWLEFwcHCV+9hsNq8Ai4iIiKiu+TzA0jTN8zAMA8XFxVAUBUIIDB06FAUFBfj222/ZEkVEREQBy+djsKZOnYqQkBBMmzYNy5YtQ0hICAYPHowNGzZgyZIlWL9+PWJiYhAeHo7w8HBMnz69ytect9/A94cNH5SeiIiIqGp1lqbhQjmdTtjtdjgcDtjnhwAA5KigOi4VERERkZ/OIiQiIiIKZH41yP1CiQ/caBkOpOUDKbdZ0KWhqHonIiIiohpW71qw0vLNvz8d5ZgsIiIiqhv1LsAq06MRW6+IiIiobtTbAMsIyKH7REREVB/U2wDr832MsIiIiKhu1NsAqw2TuxMREVEdqbcBVqFW1yUgIiKiv6qAD7CMCvKkrj3GLkIiIiKqGz4PsGbNmoUePXrAarViyJAhXuucTieGDx8Om82GJk2a4KWXXqry9fQK4qjMIgZYREREVDd8nmi0WbNmGD9+PFavXo3Dhw97rRszZgxycnJw6NAhZGZmYtCgQWjZsiVGjhxZ4evpZ6S7urmlwNI0iYnd1dooPhEREVGVfN6Cddttt2HIkCGIiYnxWl5YWIh58+Zh6tSpiIyMRLt27TBmzBjMmTOnytfsEWPmvLqyicCApua/YxrUfNmJiIiIqsNvxmClpqbC5XIhMTHRsywxMRE7duyodD9XYR4+7lUAFDnxQHw+eke5AQCzdzOTOxEREdUNv7kXYX5+PsLCwmCxnCpSZGQk8vLyKt2vRYsWnn/fB2Dc+ImI6zge6fm1VVIiIiKiyvlNgBUeHo7CwkJomuYJshwOByIiIirdb8WOQ7jux1C0CANe7qUiONiKl38BGqgc5E5ERER1w2+6CNu3b4+goCCkpKR4liUnJyMhIaHS/axhEUCIDemGDUdlBI64gwEA+5y1WlwiIiKiCvk8wNI0DcXFxdA0DYZhoLi4GC6XC6GhoRg2bBgmTJgAh8OBvXv34p133sGDDz5Y6eudPotwW7ZEZtGp5w4XW7GIiIjI93weYE2dOhUhISGYNm0ali1bhpCQEAwePBiAmSPLbrcjLi4Offr0wQMPPFBpigYA0E6LoU6UAEKcev7+7xzoTkRERL4npKwgFbqfczqdsNvtSM/KRVJeBG5freP6FgKXxghM3W4GVh/2VfFAB7/pBSUiIqK/iICPPmzBAlfGms1WPRudyoMFAPlaQMaOREREFOACPsD6I1fin7/qAIBuDQVaRQg8nWAeVp6rLktGREREf1UBH2AdyJP4716JrtFAtBVwuoF9TvN5eFBdl46IiIj+ivwmD9b5KrvZc0oOcDAPiAiSWJImsesOCy6JEpXvTERERFQLAr4FSzttomBGoURKjhlxpedLBOj4fSIiIgpw9SrA2pot0dZutlq9kmLgiqV6HZWKiIiI/soCPsC6yAb8va0ZVD3SUcHwiwV23G5B78YCxwrZgkVERES+F/BjsLrHKOjf2oJP+p9alhAN2IPNAe9EREREvhbwLVg5xRIpJ84eb2ULBvLc4DgsIiIi8jm/C7AyMjIwZMgQNGzYEDExMbjzzjtx/PjxCrf/X7pE4iINZ4ZRtiABtwGUcBgWERER+ZjfBVijR48GAKSlpeHAgQMoKSnB448/XuH2ZWkaFOGdkuH/WgjsvN2CIL87QiIiIqrv/C78OHDgAIYOHYrw8HBERERg2LBh2LlzZ4Xb64aEWk66q+gGAp2iBVSFubCIiIjIt/wuwHrqqaewcOFCOBwO5Obm4ssvv8QNN9xQ4fYF+U4oxU44neajpKQEAHA4X2LULxoOODkGi4iIiHzL7wKsPn36IDMzE1FRUYiOjkZOTg7Gjx9f4fYTBl4E95gY2O122O12zJgxAwBQqAEfpkqkFzDAIiIiIt/yqwDLMAxcc8016NOnD/Lz85Gfn48rr7wS1157bYX7pKenw+FweB7PPfccAHMWIQA4ecNnIiIi8jEh/SiPQXZ2Nho1aoT09HTExcUBMAOo+Ph4ZGVlISYmxrOt0+mE3W6Hw+GAzWY767UKNYmwjzV8PkDF8DZ+FUcSERFRPedXkUdMTAzatGmD2bNno7i4GMXFxZg9ezbi4uK8gqvTffqHgauWaWctD1EBVQBOl9/Ej0RERPQX4VcBFgAsWbIE27ZtQ/PmzdG0aVMkJSVh6dKlFW6fWSSR6jg7iBJC4LlEBV0achYhERER+Zbf3SrnkksuwcqVK6u9vS5RbpoGAHiph1pDpSIiIiKqPr9rwTpXRiUB1rZsid0n2UVIREREvhXwAZZuVBxgPbZex2s7eK8cIiIi8i2/6yI8V3e2VjCoTfldgbZgwOn2cYGIiIjoLy/gA6wOUQI2W/kNcbYgIJd5sIiIiMjHAr6L8KcjBubsMcpdxxYsIiIiqgsXFGC53W7ccsstNVWW87I8XeKNneWPs2oeJmAP8nGBiIiI6C/vgroIDcPAt99+W1NlOb8yVDKLcPKlTNNAREREvldlC5bL5d+DmCrLg0VERERUF6oMsMLCwpCQkIC//e1vmDlzJlauXIljx47VaqGWLl2KxMREhIWFoVmzZnj33Xcr3FaXEqooP8L6cp+B2M/c8KPbLRIREdFfQJVdhHv27MGOHTuQkpKCjRs34r333sPBgwfRsGFDdO7cucYLtGLFCowePRqfffYZ+vbtC6fTiePHj1e4fZdogViUH2AJARwvAgo0IJxjsYiIiMhHhDyteSc/Px9vv/02rrvuOnTv3r3CnZxOJ3777TdP4FVZC9O56tmzJ0aNGoWHHnqo0u2cTifsdjscDgdsNlu52yw/ZOCGlToyhlvQLIz9iEREROQbXl2Es2fPxrRp0xAWFlbpTjabDX369MEjjzxSo8FVQUEBtm7dCqfTiQ4dOiA2NhbDhg2rtEsyLcuBA5kOOJ1OOJ1OlJSUnCpnsPmXqRqIiIjIl7wCrEWLFuH+++9H+/btK9xhzZo1GDBgAFJSUmq8MCdPnoSUEnPnzsXKlSuxb98+BAUFYcSIERXu06VNPFo3iYTdbofdbseMGTM862xBZquV08UxWEREROQ7Xl2EERER+PLLL3HjjTdWulPv3r3Rv39/vPLKKzVamNzcXERFReHDDz/EAw88AADYv38/2rZti7y8PK+WtbIuwhu+OICCIBuWDDaHk1mtVlitVgBAoSaxLVuia7RARDC7CImIiMg3vAa567qOiIiIKncaNmwY5s2bV+OFiYyMRHx8PEQ5swIrmgmohNhgtdpgs509Xj/UInBlLAMrIiIi8i2vLsKmTZti//79Ve6UkJCAQ4cO1UqBHnroIbz99tvIyMhAUVERpkyZgoEDByI8PLzc7SvLgyWlxD9/1bHxePm30iEiIiKqDV4BVr9+/fDpp59WuZOqqsjNza2VAo0bNw4DBw5E165d0aJFCxQWFmLu3LkVbl9ZgCWEwDu7DGzJ4hgsIiIi8h2vAOvhhx/GunXrMHXq1Ep32r17Nxo1alQrBVJVFa+//jqys7ORnZ2NhQsXIjY2tsLtPxugYuGgim+JYwsC8jiLkIiIiHzIK8Dq1asXnn32WUycOBF33XUX9u3bd9YOWVlZePXVVzFgwACfFbIywaqAtZJ75diCmaaBiIiIfOuskeEzZsyA1WrFtGnT8NVXX6Fv375ITExE06ZNkZaWhgULFqCgoADjxo2ri/Ke5YXNOppE6RjfvfxWLFsQ4PTv2ykSERFRPVPurXImTZqEm266CVOnTsV3332Hn3/+2bOudevWWLBgAS655BKfFbIyySck4kXFY6yGt1HQLJQzCYmIiMh3vPJglaewsBC7du1Cbm4uYmNjkZCQ4KuyVaosD9bl806gTWMb/jugytsqEhEREflElVFJaGgoevbs6YuynBddAqpS8fr0fAmHC+gczVYsIiIi8o1KQpPAUFmaBgCYnmzg7z9rvisQERER/eUFfL/a050VNI+pOE6M4CB3IiIi8rGAD7BuaKnAZqs4wGIeLCIiIvK1gO8iXHrQwK+ZFd8KxxbMFiwiIiLyLb8NsIqKitCmTRtERkZWut3U7Trm7a94ImSUVSDUAmgGb5dDREREvuG3AdbEiRMRFxdX5XZVDXIf0VZB9sggWBTOIiQiIiLf8MsAa9u2bVi+fDmee+65Krc1qgiwiIiIiHzN7wIsTdMwatQozJ49G1artcrt3YV50AqdcDrNR0lJidf6nTkSbee78ftJdhESERGRb/hdgPX666+jS5cu6N+/f7W2T3+sFf51dTTsdjvsdjtmzJjhtV4VwD4nkFPCAIuIiIh8w6/SNOzfvx+zZ8/G9u3bq71Peno6bDab5/mZrV4RQeZfJ1M1EBERkY/4VYC1du1aZGVloVOnTgAAl8sFp9OJ2NhYLF26FL169TprH2tYBMIjIqCI8gdi2YLNv3lM1UBEREQ+4lddhMOGDcOBAweQnJyM5ORkfPjhh4iIiEBycjK6detW7j5t5mt447eK82CFswWLiIiIfMyvWrBCQkIQEhLieR4dHQ0hBGJjYyvcx20AlkrCREUILL9ORUIUpxoSERGRb/hVgHWm/v37Izc3t9Jt3AYQVEU73PUt/KqhjoiIiOq5gI88NAMIqiKJ6Hu/6/g2reJuRCIiIqKaFPABFgBYquj9m5MqsYQBFhEREfmIX3cRVseuOyyIb1R5hBURBORxkDsRERH5SMC3YMWFC4QHVR1g5TPAIiIiIh8J+ADr7z9qSMqsvPsvnC1YRERE5EMBH2AtTpM4VlT5Nv2bKhjYnGkaiIiIyDcCfgwWUPUg9wc7BHwcSURERAGkXkQeVeXBcrgk/sjlzZ6JiIjIN/4SAdZHqQYuXaz5pjBERET0l+dXAVZJSQlGjRqFVq1aISIiAh06dMBHH31U6T4TuytobatqFqFAvhswJFuxiIiIqPb51RgsTdPQtGlTrF69Gq1bt8avv/6K66+/HnFxcRg8eHC5+zzdRYUtvPIAq+yGzwVuICK4pktNRERE5M2vWrDCwsIwZcoUXHzxxRBC4LLLLsOAAQOwbt26CvdZfsiAw1V5y1REaYCVz15CIiIi8gG/CrDOVFxcjKSkJHTp0qXCbe5enotdR5xwOs1HSUnJWdtEBAGqMFuwiIiIiGqbkNI/ByZJKTFixAhkZGTghx9+gKJ4x4JOpxN2u/2s/V588UVMmjTprNcCACGYC4uIiIhqn1+NwSojpcQjjzyC1NRUrF69+qzgyssrB5AyPAoXlQ50t1qtZ23CwIqIiIh8ye+6CKWUePTRR5GUlIRVq1aV20rlpUEEGkfbYLOZj/ICrNwSiZ7faFiTUfktdYiIiIhqgt+1YD322GNYv3491qxZg6ioqCq3b2sHQqo4CqsKbMmWOFJYQ4UkIiIiqoRftWClpaXh3//+N1JTU9GyZUuEh4cjPDwcDz/8cIX7bLk1CPbgyrsAG6jm7XTy3H453IyIiIjqGb9qwWrZsiVqY8y9EAK2YMDpqvGXJiIiIjqLX7VgnY8286uXeyEiCHAyTQMRERH5gF+1YJ0Pl1697WZdoaJlBGcTEhERUe0L+ADLqlZvuxtbBnxjHREREQWIgI86wqsZIn6bZuDrA0zTQERERLUv4FuwqppBWOazfQayi4HbWwV8TElERER+LuCjjfeurF4fIQe5ExERka8EfIDVPqp6LVi2YME8WEREROQTAR9gffVn9cZV2YKYB4uIiIh8I+ADrN0nq9cqlRAtcHUzpmk4VyUlJZg0aRJKSkrquij1HuvaN1jPvsO69h3WtW+cSz0LWRup0y+A2+3Gk08+iS+++AIAcM899+CNN96AxeI9Ht/pdMJut+O1X3PwdK+q71lI56esnh0OB2w2W10Xp15jXfsG69l3WNe+w7r2jXOpZ79rwZo6dSrWrVuHXbt2YdeuXVi7di2mT59e4fYXhVevVUo3JA7nS5TofhVPEhERUT3kd2kaPvroI7zxxhto2rQpAOCFF17AM888g4kTJ5a7ffeY6gVYySeAHos1JA1R0bNR5ftIKSGEuc0Bp4TDDYSqQCsbcMBp/g1SBI4USBRq5gzFIAWwKOaNpYNVAUNKGKfFcqqA5zXpFCklNAkUa0CxDpTogC3YnJRQokucLAEUAQgAQpg37Y60mvWY75YQOLVeEeZ5YD3XvLLzBJjXvkuXcJSOaSyrblUAUaXnJrdEQuLUeVGF+d5QFQG99I2h8D1RpwwpoRmAJoFgBbAoAsWaRLFunlMF5t8gBbCWfqa5SteVvR8F+NkWCIo0Cbfhfd6sqnnOdUNCl6ed19JtFJ7TC+ZXAdbJkydx+PBhJCYmepYlJibi0KFDcDgcsNvtnuVlPZvFJ47gsCvPs9xqtcJqtZ712o0goRZr6PUlcFE48EovFdfFK9iZI/H8Zh2FGpDnlsgpAaKtwK9DggAAvea7kV3k/Vrrb7agc7TAs+s0fL7Pu0Xsyc4KJvVQ8ctRAzet9L6PT/NQYPdQ83UTv3bjeJH54aSUPuYPVNG7sYI3duj45A8DQar5wResCNwYL/BMVxWH8iSe3qQjuHRdkAKEWATeusJMV/HhHh0nS8xARJeAIYEhFyloFymw4ZiB1Rlm4GfAfHSMFLinjQKHS2LKNgO6AehSevad2rkAADBl/Unsc2nQ5anXHdVBwTVxClYfNvDmTsOzXJdA5yiBN69QoRkS/Zad2s9tAEUasOYGC5qHC9z3k4ZFB73r8IVEBc8mqlhxyMCwNd512MYGbL3NrMP4L9yeL/kya25UcWmMgmd/1fHe74anbhVhlnd6TxXbsyVuWqmVfoiYHyhRwcD2283Xve47DWl5EhZhBs2qArx5uYorYxXM3Wvgkz8MzzqrCvSLFXg8QUVOscTErTqsqkCwAlhLg+4XuikQQmDOHh3p+aXXb2l5b22lILGhwK+ZBhbscgAAHv/hJNRQHe3swMOXqCjSJB7foHvOm3mOgNlXqrAHC7ycrCMpyzxnZesebK/g9tYKfjpi4MWthuec6gbQ1i7w+dXmW7/7IjeKNHMfvfS1V11vQbtIgac36Zi71zyvmuF9fa87ZuCGFd7npmkosKf0+u60wI0jhd7nZtm1Kq5qqmDSFh1v7Dw1OUUIYEQbgXf6WJB6UqLf/zTznME8P1YV2DvMfN1bV2nYfVJ6zqkqgFd7q7i2hYIv9hl44zf91DkH0CdWwczeKk4US/zfCg2qAFBsfl70W5iD726VCLUIjN+i47ccab4fYb7ug6XX9/pjBj5ONa8lVTHXtbEJPJGgwpASz282j8WQpx7juymIbmCe882l50aWnr9bWyq46SIF27INzEwxPO8ZCaBpCDD7SvPc3P69hjw3PPvq0kxL0yFK4LUUHQv+PPWeMyRwdxsF4xJVJJ+QGLpag15aJinNST477jDrsOc3bux1msvLfDVIxTVxCl5O1jEj2Xvi0B2tBOb0s+CgU6LrIg1nyhlpgaoIDF6u4ddM6fWD59Wu5ufHu9tyMXm32+vHUt8mAl8MtKDALZHwtXYqqCt9rLvZgkYhAmM3aPgxQ3rer6oAnkhQMaKtgl+OGpi87dT70aIArSME3rjc/Dx84GcNmnHqvKkCGN9NRVy4wML9BjZnn7qWDGm+l6+PV7DfIfHu7wZk6Xu1rA4n9TBfd8IWHTnF0mv9k51VtI8SWPSngeXpp/Y1JNA3VuCBDioO50s8+6tufv6WnjdFAAsGmef8iQ069jql13l9oZuCAc0ULNhvYNZu3bNcl0CfJgr+dbn52XPpvJPm+/DDHGhWN9wGkHa3BfZggVtXaVhzxPtz9tXeCh7qqGL+fgMPrfV+L1/aSGDNDWaZIj818xudHnwl3WLBxXaBx9Zr+PqA9ARnigCe6Kzg6S7md+DIn/TSH1Lm+vjwU6/bd6kbOSXer/tpfwu6xQi8+ZuOL/cbZsOFELAowC0tBcZ0VvGnU+Kfv+qe82lRgDAL8G5f83Vf2qrjWJEsPecCqgDubaegc7TAmgwDKw5LSHnq3HRtKPD3dgpyiiVe3Kp7zmfZ+Xv7ChVBisCrKTpScyVchU4Ap2KQyvjVGKz09HTEx8cjKysLMTExAICsrCw0btwY6enpiIuL82x7+PBhtGjRoq6KSkRERH9RmZmZaNSoUaXb+FULVnh4OADA4XB4AiyHw/xVHxER4bVts2bNsH//fgQFBXk1T1fUgkVERERUE86MScrjVwFWVFQU4uLikJycjIsvvhgAkJycjBYtWnh1DwKAoiho3bp1XRSTiIiIqFJ+N4vwvvvuw7Rp03Ds2DEcO3YM06dPx4MPPljXxSIiIiKqNr9qwQKACRMm4MSJE+jYsSMAMw/W888/X8elIiIiIqo+vxrkTkRERFQf+F0XIdWdWbNmoUePHrBarRgyZIjXOqfTieHDh8Nms6FJkyZ46aWX6qiUga+kpASjRo1Cq1atEBERgQ4dOuCjjz7yrGdd15wxY8agRYsWsNlsaN68OZ544gm4XGZuD9Zz7SgqKkKbNm0QGRnpWca6rjn33nsvgoODER4e7nls3LjRs97tduOxxx5DdHQ0oqOjMWbMGGja2ek1qHqWLl2KxMREhIWFoVmzZnj33XcBVO+aZoBFHs2aNcP48eMxatSos9aNGTMGOTk5OHToENauXYsPPvgA//3vf+uglIFP0zQ0bdoUq1evhtPpxCeffIKnn34aq1atAsC6rkmjR4/Gnj174HQ6kZycjJSUFMycORMA67m2TJw40SulDsC6rmmjR49Gfn6+53H55Zd71p3r3VCoYitWrMDo0aPx5ptvwul0YteuXejfvz+Aal7TkugML774orzllls8zwsKCmRwcLDcvHmzZ9nMmTPlVVddVRfFq5duvfVWOWHCBNZ1LcrMzJRXX321HDlyJOu5lmzdulVecsklcsWKFdJut0sp+flR0/7+97/Lxx9/vML1cXFxcuHChZ7nCxYskPHx8b4oWr3To0cP+d577521vLrXNFuwqEqpqalwuVxnZdjfsWNHHZaq/iguLkZSUhK6dOnCuq4FL7/8MiIiItC4cWOkpKRgzJgxrOdaoGkaRo0ahdmzZ3vlImRd17z//ve/iI6ORqdOnfD666/DMMzs+1XdDYWqr6CgAFu3boXT6USHDh0QGxuLYcOG4dixY9W+phlgUZXy8/MRFhYGi+XUpNPIyEjk5eVVshdVh5QSDz74INq2bYvbbruNdV0Lxo0bh7y8POzevRsPP/wwYmNjWc+14PXXX0eXLl08XShlWNc1a+zYsUhNTUVWVhbmzJmDt956C2+99RYAs64BeI1/K/s36/vcnDx5ElJKzJ07FytXrsS+ffsQFBSEESNGVPuaZoBFVQoPD0dhYaHXQEmHw1GtTLZUMSklHnnkEaSmpmLx4sVQFIV1XYs6duyIrl274t5772U917D9+/dj9uzZeO21185ax7quWd27d0ejRo2gqiouu+wyjBs3DvPnzwfgfTeUMhXdDYUqV1aXY8eORcuWLREeHo7Jkyfjhx9+gKIo1bqmGWBRldq3b4+goCCkpKR4liUnJyMhIaEOSxXYpJR49NFHkZSUhFWrVnnuVMC6rl1utxt79+5lPdewtWvXIisrC506dUJsbCxuu+02OJ1OxMbGIi8vj3VdixTl1Nf46XdDKVPR3VCocpGRkYiPj/e6FV+ZhISE6l3TtTpCjAKK2+2WRUVF8oUXXpA33XSTLCoqkiUlJVJKKUeMGCGvv/56mZubK//44w8ZHx8vP/300zouceAaPXq07NKli8zOzj5rHeu6ZuTl5cmPPvpInjx5UhqGIXfs2CE7duwoR40aJaVkPdekwsJCefToUc/j66+/ljabTR49elS6XC7WdQ2aP3++dDgc0jAMuXnzZtmyZUs5c+ZMz/oJEybIbt26ec5Ft27d5OTJk+uwxIFr6tSpsmvXrvLw4cOysLBQjhw5Ug4aNEhKWb3PDwZY5PHiiy9KAF6Pfv36SSmldDgc8q677pLh4eGyUaNGfMNegIMHD0oA0mq1yrCwMM/jH//4h5SSdV1T8vPz5aBBg2R0dLQMCwuTrVq1ks8884wsKCiQUrKea9OPP/7omUUoJeu6JvXt21fa7XYZFhYm27VrJ1955RWp67pnvcvlkqNHj5aRkZEyMjJSPvroo9LtdtdhiQOXpmnyqaeekg0bNpQNGzaUd9xxhzx69KiUsnrXNDO5ExEREdUwjsEiIiIiqmEMsIiIiIhqGAMsIiIiohrGAIuIiIiohjHAIiIiIqphDLCIiIiIahgDLCIiIqIa5vMAa9asWejRowesViuGDBniWZ6ZmYl77rkHcXFxsNls6NatG5YuXerr4hERERFdMJ8HWM2aNcP48eMxatQor+X5+fno1q0bNm3ahNzcXEyZMgV33303du/e7esiEhEREV2QOsvkPmnSJCQnJ2Px4sV3mjEYAAAgAElEQVQVbtO9e3c89thjuP/++31YMiIiIqILY6nrAlQkMzMTv//+O7p06VLueiklsrOzERwc7HW3a6vVCqvV6qtiEhEREZ3FLwe5l5SU4K677sLQoUPRo0ePcrfJy8tD48aNERkZCbvd7nnMmDHDazvxgRviAzfe/E33RdGJiIiI/K8Fy+Vy4c4770RoaCg++OCDKrdPT0+HzWbzPD+z9WpaDwUvbDFg8JbWRERE5CN+FWCVBVculwtLlixBcHBwlfvYbDavAOtMz3dTcUO8guZhNVlSIiIioor5PMDSNM3zMAwDxcXFUBQFQggMHToUBQUF+Pbbb2tkHJVmSPx8VKJrQ4GYBqLqHYiIiIhqgM/HYE2dOhUhISGYNm0ali1bhpCQEAwePBgbNmzAkiVLsH79esTExCA8PBzh4eGYPn36ef9fXx2QGLRcR89vNHy+z6jBoyAiIiKqWJ2labhQTqcTdrsdDoejwi7CMet1zNptBlb3txOY08+vekSJiIionvLLWYQ1ZWu2GTuqAijQ6rgwRERE9JdRr5t0LrYB+RpwUbhggEVEREQ+U68DLKcbiA8TWHYoIHtBiYiIKEDV2y7CEl1iaZrE77kSd19sziDUmQyLiIiIfKDetmBZVYHpPRV0jRbIdQFf7tdRYgCh9TakJCIiIn9Rr8ON5xJV/F+8ggaq+byY47CIiIjIB+ptgLX4oIHW89zId8tTARZvR0hEREQ+UG8DrMMFEhkFQJgFaBYmcEMLAZXJ3ImIiMgHfB5gzZo1Cz169IDVasWQIUO81jmdTgwfPhw2mw1NmjTBSy+9dN7/T2YR0DgEEEIgsaHAt9dZ0CSUERYRERHVPp8Pcm/WrBnGjx+P1atX4/Dhw17rxowZg5ycHBw6dAiZmZkYNGgQWrZsiZEjR57z/5NTAjQsvZ2hbkjkugBbMBCkMMgiIiKi2uXzFqzbbrsNQ4YMQUxMjNfywsJCzJs3D1OnTkVkZCTatWuHMWPGYM6cOef1/+S6JCKtZjD120kgZq6GlBNM00BERES1z2/SNKSmpsLlciExMdGzLDExscqbPTudTq/nVqsVVqsVLySqKCod1B5cGka6eL9nIiIi8gG/GeSen5+PsLAwWCynYr7IyEjk5eVVul+LFi1gt9s9jxkzZgAAOkYJdI8xW7A8ARZnERIREZEP+E0LVnh4OAoLC6FpmifIcjgciIiIqHS/9PR02Gw2z3Or1Rx49Uqyjq4NBa5rocBamqaBLVhERETkC37TgtW+fXsEBQUhJSXFsyw5ORkJCQmV7mez2bweZQHWO7sNbDhujrliCxYRERH5ks8DLE3TUFxcDE3TYBgGiouL4XK5EBoaimHDhmHChAlwOBzYu3cv3nnnHTz44IPn9f/ku81ZgwDQKATIGWnBtS04g5CIiIhqn88DrKlTpyIkJATTpk3DsmXLEBISgsGDBwMwc2TZ7XbExcWhT58+eOCBB84rRYOUEvluILy0A1QRAlFWwRQNRERE5BNCShmQuQucTifsdjscDofXGCwAKNIkQj/WMLe/ir+1VaAbEjet0vFEZwWD4/ymV5SIiIjqqXoZbRgSeKiDgg6R5nNFAN+lS6Tl1225iIiI6K/Bb2YR1qSwIIH3+qqe50IIKMLM6E5ERERU2+plC1aBW2LHCYli7VRAZRGAzviKiIiIfKBeBlg7ciS6LtKw77Qk7yoDLCIiIvKRetlFWKCZf8ODTi3712UKLmtSL+NJIiIi8jP1MsAqLA2wQk4Nw8LDl6jlb0xERERUw+plk05RWYB1Wvi46ICBnTnsIyQiIqLaVy8DrDy3Oebq9ADrkfU6lqTxZoRERERU++pdgKUZEqPW6mgcAq/M7RzkTkRERL7idwFWRkYGhgwZgoYNGyImJgZ33nknjh8/Xu39s4vNv0cLvZczwCIiIiJf8bsAa/To0QCAtLQ0HDhwACUlJXj88cervX+D0rHsCwd6D2pXBaCxh5CIiIh8wO8CrAMHDmDo0KEIDw9HREQEhg0bhp07d1Z7/0irgBwVhDtaex9a9xiB5mE1XVoiIiKis/ldmoannnoKCxcuxA033AApJb788kvccMMNFW7vdDq9nlutVlit1rO2W3SN3x0qERER1VN+14LVp08fZGZmIioqCtHR0cjJycH48eMr3L5Fixaw2+2ex/OvvAPxgRv/O8T+QCIiIqobfhVgGYaBa665Bn369EF+fj7y8/Nx5ZVX4tprr61wn/T0dDgcDs/j0TFjAACnTSAEACR+7cbjG/TaLD4RERERAD8LsHJycpCWloaxY8ciNDQUoaGhGDNmDDZu3Ijs7Oxy97HZbF6PoKBgAOUfmMZZhEREROQDfhVgxcTEoE2bNpg9ezaKi4tRXFyM2bNnIy4uDjExMdV6DaM0iBJntGCpCqCz15CIiIh8wK8CLABYsmQJtm3bhubNm6Np06ZISkrC0qVLq71/WYB1ZhehRQjokk1YREREVPv8bmrdJZdcgpUrV573/nHhwN6hFjQ7IyUDE40SERGRr/hdgHWhghSBNvazl88bqMLqd+11REREVB/Vu5DjWKHEiB817Mn1bq6KDxdoEioq2IuIiIio5tS7AMvhAj7bJ5FV5B1gzUzRMXsX0zQQERFR7at3AVZZWHXmIPcfMiR+OspBWERERFT7qjUGy+12Y/Xq1cjIyEBMTAyuuOIKNG7cuLbLdl6+PmDmYjgzwFIVDnKvbcWaRFKWxFVNAz9uP1Yo8fk+Aw93VBAWxK5lIiI6N1UGWJmZmbjqqqtw9OhRXHTRRXA4HMjIyMAdd9yBt99+G40aNfJFOavtgz1mgFWoeS+vaBahZkhYSqMxp0vCogChFn6hno/ERRpSHUDWCIGYBoFbh4fzJVrP1+A2gJk7DCwapKJPbOAHjWeat99A01CgXz0IiImI/E2Vn6yTJ09Gz549kZWVhZSUFBw8eBB//vknQkND0bdvXzgcDl+Us9ry3ObfRmd8wasC0M5INHq0UCJojoalaeaK+C81tFtwRmTmAx/sMRD1qRvjkgJvjFixJvHWTh26IdEpyqzzYT8E3nGU2eeQ6LtMQ9NQYNEgFX9ro6DvMh3fpdefLLV/5Eq0me/G3Wt09P82cM9VZaSU+DjVwA8ZBiTz3xFRHagywPr+++/x8ssvIzg42LOsRYsWmDNnDq644gq8/vrrtVrAcxURZP49Mw/WsNYK7rpYgZQSu3IkpJQ4XmSu+98h8wPY4QIyCnxYWAAr0g38Y60OiwIEKUC7+W50X+RGvtv/vxROFEsMWq5jXJKB304CCwaq+EcHBdnFErkl/l/+8jjdQOMQgbU3WXBrKwWv9lYwOE7ggV90OFyBeUyn0w2JW77XsN8JNA0FnkpQzppxG+g0Q+KhtTru/0XHoOU67J9qKPkLjA/YmiVREACfG0R/FVUGWMePH0fz5s3LXffcc8+dU5Z1XygLmhwu7+V3t1Ewoq2Cbw5KdP5aw/t7DIxZb/56T2xobvNkZwUdIn1X1iJN4pF1Oq5pLnD8bxZMuVTB450VbD8BvPe7f7eYpOdL9Fmq4Q+HxI83qEhsKKAqAv+5UsHWWy2ItAZWF2HyCYkSXaJ7jMCmW1TEh5vlV4TAh31V5JYAr6b49zmpjCEl8lwSqiIw/2oLcv9uQcZwC345KnHLKg3OehA8AkCJLnHLKh2f/CHxfl8Vf2sjkOcGRv6k19uWLJcu8cU+Az0Wa3h7V+Beo9V1oljibz9qGLra970NROeiygCrsg+ltm3bIj09vUYLBABLly5FYmIiwsLC0KxZM7z77rvV3jexofnFuNfhXe6dORKbswwcyjeX//NXA+uOm/8uu71OlBU4WVIDB1BNRwqB1jaBd65QoQgBIQQe7aTizlYCc/f67wfl8UKzG61YBzbcbMFlTU5dRkIIWBSB7dkS7+wMjO6nhX8auHyJhpmlAZQ440aWceECTyQoeGOngWOFgfclnVMscfNKHbevNoOMLg0F7MHm9fbF1SrS84Hpyf57vZ2LYAVoFSHwv+tUjOqgYO4ACxYOVLHgT4kv9gfeuavK8UKJa5bruOdH8722NK3+HePpdp+UiJmr4fN9EgsP1O9j/SvLKZa4Z40W8C2yVQZY+fn56Ny5M4YPH46XX34Z3333HTIyMjzrNa1mf0WsWLECo0ePxptvvgmn04ldu3ahf//+1d7/qQTzkGzB3stfTtHxzCbDMyOsSYi53CKAvrEKDCkxe7eB5xJ9N+D3YpvADzdY0C7S+wv9b20VpOQAO07458XVKAQY2VbBupssaGMvv6Xqu3QDz/xq4KgfByRSSkzdpmPoDzpuvUjgn10qPvfPdlHwxmUq7MEVbuKXkjINXPqNhg2ZEk90Vs4KHtvaBf7ZVcGbOw2k5fnvuarKqsMGFh80IITArD4qBsedOpd3tFZwZyuBZ3/VUaQF7jGe6ccjBhIXadjjkFh8jQoA2JQpPRN96qN2dmBYa4EeMQIv91SgGfXnfFbku3QDr6boAR9sVNe8/QYaztXwxX6JFYcD+5irjCYOHDiA6dOno2PHjtiyZQvGjh2L+Ph4xMTEYMCAASguLq7RAk2YMAETJ05E//79oaoqoqKi0KFDh2rv/6fTPCHhZ8wEtJTOIrwpXmDFdSoujTHXaxKICwPy3Wb3YmyIb7q2kjINLDlowCinhfD6FgKv9VbQNNQnRam2zVkGVqQbUITAlB4q4sIrrqtHOylooAJv/OafH/aGlBjxk44JWw1MuVTB5wNUNKhk9mikVeChjgpCAmiG6SvJOq5YqqNRiMC2Wy34v/jy3+7/7KLAHhyYrViGlHg1Rcf1K3R8sa/i8k/vqaJIB7ZlB/YHdplFBwwMWq6jY6RA8m0W3HKRgg03q7issUD3hoFzjVaH25B4YqOODccNWBSBeQMt2HyrBSPbKejytYYfjwTedVsdmiExfrOO/1uh49kkA+GfaPijno2XLM9Vsaeu35gGdViQGuCVpiE/Px9vv/02rrvuOnTv3h0A0LJlS7Rs2RI333yzZ7uCggLs2LEDKSkp5xT8VKWgoABbt27FsGHD0KFDB+Tm5qJfv3546623EBsbW+4+TqfT6/m4zWbTVJEuAZw6Uaowg6nYUAFdAj0aCcz/07xYN2ZKdIk2t31kvY5bWopKv2zP1+oMAz8ekdjrkLCqZsZ51wOWs3J2BSkCT3dRIaXER6kGOkYClzep26n0P2QYuPV7Hb0aCVwbJ85qCTmTPVhg9CUKZpW2Ckb52ZgsRQhcFC4w/2oFQy+uXt1KKTF6vYEOkcDjndVaLuGFC7EAL3RTML6bgqAzL7LThAcJLByookOkf52jqmQVSdz7s47l6RLjuiqY2qPi89jGLpAx3BJQAXJ5SnQJqyowsLn5I2xsJwVq6bm9vImCjbeYdaAb0rM8kB3Klxj2g44tWRLdG6q4osmpdY0amBNS/rFWx293CFjVwD/eMoWaxHXf6Vh/XGJaDwV/OCQ+3SvRfqGGtLstnjGi9UV6vsSj63W8fYWKiyIE5ChzttrBPPM78P72gZlKxqvUs2fPxrRp0xAWFlbR9gCAsLAwXH755Xj44Yfxn//8p8YKc/LkSUgpMXfuXKxcuRL79u1DUFAQRowYUeE+LVq0gN1u9zzK5Lu9t1MVQDfMlqO4LzRoBhBeOuNw43GJ79LNYOtkCbDHgRprjj1SIHH3Gg1bsgx8uc/AR6kGFh6Q+GyfxNMJlX/x7cgBHl5ntkJ8Xsmv89okpcR/dpstBH2aCCwerFYZXJV5vLMCtwH8Z7f//ML83yHzHADA1J5qtYMrwBybVaJLvLrDgMsPZ6UZpedq4hZzPM7YziomX6pWeo2VuaqpgsYhIqC60O77WUdSlsTy61TM6KVWGVCEWARySyR+yPCf67G6pJR4d7eO1vM0HMqXsAcLPJlQ/jEfKZBI+FrDz0cD7zhP922a2QV6pFBi3c0qRrbzfq9aFIHZV6j4M89/W8rPV6hF4LLGAj/doOL5bir+c6WKOVeZP+qWpdWvY12RbqDbIg3JJ+RZY6AX/mlg1FodW7IC85i9rthFixbh/vvvR/v27SvcYc2aNRgwYABSUlJqvDDh4eEAgLFjx6Jly5YIDw/H5MmT8cMPP6CgoPz8Cenp6XA4HHA4HMjNPZWT62Kb9wdP4wYCTUOBpCzzC+TXTIlvSsctlBjAP9adGpDdbZGG61fUzADtfDew6bjE+C1mKoNr4wTGdlLQMRL4f10r/3Lv2lCg6D4LhrYWeGJj3fTBT9hiYPR6Aw+2V7D0WhXh55DVPDZUYMFAc7BxXXPpEuOSdNy40sxpdb4zyp7poiKjwGx99Cd7ciX6LdMxer2BzKLKJ6dUZGeORIsvNL/uRnPpEgdLx4q9fYWKlNssuL5F9a+vV3cYuGWVjswi/z3GM6XlSQz+Tscj6w3cGK8gsopxgLGhgC1Y4PENZn66QFSsSYxer6NvrMD2Wy3o3bj8c9wpWmBMJwVTtxs4UhCYx1omt0Ti/p81fFY6wWlmbxV9S5MAh1gE7m+v4ORICx7t5P+t59WhGxITtphdoL0aC2y/zYJuMd7fL08mKOgaDTz4iw53AF7LXlft7t27ce2111a6w9VXX43CwkJ88cUXNV6YyMhIxMfHl9tCUtEXhs1m8zxESMRp23tvN7WniqXXWuAqjZsWp0msPCyREA2UlBNLrT1WMyezXaTA2M4K1hyR2JJldkW+dYWK3XcGoVE1xnupisDMXipySuCTmYVSSixLM7Cm9Ff+na0VrLhOxb+vrF5LyJlubqmgUYio0ynyv+VI9F6i4fUdBl7ppWDBwOq3wp3pkiiBWy8SmJ6s+8UAWyklXtqmo+vXGo4XmSkz3u17fsfXIdIc8zB+i3/O/tyeLdFzsYZbVmkwpERrm0CzsHM7zqcTFFgUYNr2wPhF/NWfBjp9pWFPrsTK61W811eFLbjyY1aEwFuXmxNl5qTW/TV6LrZnS6TnSzSwCGy42YLF16iIruKuEC92V9AhUiAtP7CO9XT/O2Se568PyLOGjJwu0ipgSIk5e4yA+pFQnrR84M2dBqb2UPDttSoalnOeLYrAh1dZsPMk8NqOwHjPns4rwNJ1HRERERVt6zFs2DD8+OOPtVKghx56CG+//TYyMjJQVFSEKVOmYODAgZ7Wrcqc3i34ZwUzolynnaOIICBYEdhYmq7hmdNmkV3e2DzZGQUS//xVxwHnuV3MhZqZbPOdnToSogXchnkj6i7nMQC1ZYTA0wkK7FV8sF6oNRlmU+3Nq3TM+9OsqK4NBa49hxaC8iw6YKD7N1qd/QIZl6RDM4CkIRY82/X8g6syE7qpOJgHz3VTV6SUEELgUL7EM10UpNxuQf9m53+uLIrASz1UfJcusdaPupdcusSLW3X0WqxBAPi0vwXKeZ7D6AYCz3ZR8J/fDb+dpQvAk2i4U5TAgx0U7LzD4jUzsiq9GysY2VbghS16QCT9dRsSU7aZ5/iV0nQpceFVj/UEzKBj8xC1zsepng+ny8zpdeNKHV2iBXbdYcHwNpUfx8kS4NkkHU9v8s8fQpWRUuLLfQaKNPMH0v5hFjzfTa30/dw9RuCpBAWv7jCQF2D5+rzOZNOmTbF///4qd0pISMChQ4dqpUDjxo3DwIED0bVrV7Ro0QKFhYWYO3dutfZtFiZQcJ8Fk7or6N/U+4RN3qqjz1LNq7XKFgR0jAS2lHaJtLEB47qa2bsXDDSbYQ/mSby2w8DNq6qfjiKrSKLtfPNNM3ajgZanDUjsGn1+Xwwze6u4u4o33vmSUuKVZB0Dl+sIDxL4+UYV7/et1n3Aq6WtXSD5BDxjn3xhS5aBX0qDhE/6qdhy69nNz+erW4zAobstnuZ7X9vnMJODfvyHed2+31fFtJ5qjQzgvr2VQLeGwFOb/Gec2S2rdEzfbuCFbgqShlg8ue7O19NdFLSzAw/84n/JR48WStz7k4Ye35jZ5ztGCbx5uXpeP65m9FQR0wDYd44/Dn1ta5bE5Ut0TNlmYFyign9ddu7vKyEE0vIk/t+vgdEtWnbdhVrM2esf91Ox/LrKZ2aXadhA4NXeKj7bJ7E6gMYTHiuUuHmVjuE/6lh80Dz+xtWctT/pUgVJt1gQUcuNDDXN60ru168fPv300yp3UlUVubm5tVIgVVXx+uuvIzs7G9nZ2Vi4cGGFMwjPlOcyB8lN7K6cNfizQDMDn87RAg91KMuVZf46BICRbQX6N1Uwo5eKB9or+D1X4smNOn7LMS+Esrfs6R/IZdH0gv0G+iw9lRStUYjAE50VrD8u0UA1A7d5V6tIu9tSrW7BimzPlrUycLVAAz76w8D4bgrW3qTiqhoOHBKiBe5tJzAuqfbHSeSWSDy2XkevxTr+VTrwtVFIzc8wahYmoBtmU315qTZqw8kS8wvkkq80bM+WninMF9oidzpFCLx7pQqr6tuku2c6Vig9OdSeSlCw+VYLJl2qIrgGzqNVFZjb34I3Lj87L1hdyXdLTNqqo+18DcsOSTzdRUXQBb4Nm4UJ7L7Dgh6N/Ldl52SJRL9vNbgMiQ03q3ipx/mf44xCcwLKq37elfTLUbOnYGuWhEUR+P7/LLi33bldi/e1E+jXVODhdf6f280onaDRYaGGzVkSSwefe2NBqEWgjV2gUJPYdNy/z68XeZpff/1VKooiX3rpJVmZd955R8bFxVW6TW1zOBwSgHQ4HJ5l7+3WpXjfJQ3DOGv755I02fpLl7lviSEjP3HJr//UZUq2IfG+S246rkvdMOS/d2my/XyXxPvmI/pT8+8lC8x97/jeLfNdhvz+sC7xvkv+mKHL3ovdEu+75Px9uixwG/JwviFduiGHrXbL//6h19gx37bKLS9d5K6x1ztaYJZVSinzXGfXWU3KLjJk889dsvsil8wtqfn/y6UbcvYuTTae65LhH7vkv3Zo0q3X7jGtPWpeb0NXu2u9/n47YUj7Jy4Z+pFLTt6qyQJ37f5/Ze+hYq12/58zFbkN+XqKJm0fu+R9P9XctV4Rt27IX47U3Hv0fF2+2C2DP3TJf27SZE5xzdb50QJDPrZOk0W1fM1Ul2EY8us/dc81vPGYLl019F59LkmT6gfm57m/+f2kIYesNL8rLlvslr+duLBj3nPSkMEfuuQ7O7UaKmHtWHvU/K584Ge3zC66sGN+dpMm7Z+4ZEa+f1zLVfEKI3v16oVnn30WEydOxF133YV9+/adFZBlZWXh1VdfxYABA3wVA1ZbsW62GJX3S6AsD9bxQokJWwzcepHAba0URFnN9Z/tlchzA6PXG0g9NRkRA5uJ0tc2W0e+OiCxJE16BsF/nyGx8WYVrSKANUckVqRLxH2h4XghMG+gBSPa1tyvx7+1UbA1W2Jnzvn/YtnrkHhrp46bV2poM1/D338y+0zPZXbg+WjYQODbay1oaBWoyVREZa1HhgT+9ZuB6+ME9txpwZMJKiy1nAfoylgF8weqWJ4ukbhI83RJ1pTMIulJz9ExEngmQcGfwyyY2F1FaC3ncxJC4FihRKevNMzbX/u/GDVD4uNUA+0WaHg2ycA9bRS81rv2Z0t9lCrR71sdH/uw+xowj/fTPwxP4shXeytIHWrBzN5qjeeMO1oIfJBq4PGNdf/Lf9NxA1cuM2/b9HXprW4ua1J5uppzMflSBb0aCdy+WsdhPxr0Pn+/gc5fadh+QmJufxXrb1bR+TyHi5RpHymw7mYVj3T0vxbKkyUS/95tdsFfGatg9x0WfHiVpdyB7OdiXKKZwHrET4Exq/CsgTYzZsyA1WrFtGnT8NVXX6Fv375ITExE06ZNkZaWhgULFqCgoADjxo2ri/JWqlg3kyuWRy3N5D5pm4F3fzfQKcpcXjbledZuA49ccvaFOqqDgoUHdOS6gN2lH4bL0w0MKO1GSzlhDjQe3FzBL8cMaFKgQySq1Zd+rm6IF4hpAHzyh4HXLjv3L58v9xkY/qMOqwr0aSLwfKKCh3345kxsKLDyenOQ+Y4TEr/nSgw7hzxUp8t3mwno3tppYMX1FrS1C+y43VLrgceZ7mytoGu0wP2/6Oj3rY5Nt6DCKeXVIaXE1myJ/+w28Pl+CYsArosTaNhAYHx3307PbhxiXifD1+hwuCT+0bH2/v/DBWbOt1tamgPt2/so6emDHQS2ZSt44BcduoRnyEBtKdElPtsrMT1Zx595wJuXK2gXqaJPbO39v91izHxRD67VcbENeLar76f5H3BKjNusY8GfEl2jgVXXq7jmHAbtV1eQIvD1NSquWqZhS7aslc/h6soskth1UmJAMwUDmgm82lvBIx2VGk1i3bO0+/fHIwa6x4hanwhVFZcu8Z/fDUzZZqBEB65upqBDJNAxqmbKFWUVmHe1imuW63hyo4FZffw8ZUVFTVtbtmyRQ4YMkVarVQohPI+LL75YrlmzxndtbBUor4tw8lZNNvvMVe72aXmG3Jypy/t/cnu6/w7nG9IwDPlKsibxvksecBqedWWPT1N1mVNsyIx8Q/73D92zfPEBXS7cr8vH1mky4SuX/HKfLj9O1WWzz1zyqY2112T71EZNRn16bt1sB5zmtkVus2k+v5a7s6rj+SSzzkf+6JYnzqHZeNNxXY76xS1tH7uk+oFL3rPGLfc76v54NN2s27KutaRMs8v5XBiGIXt9Y16fzT93yRnbtXOqm9qgG4Ycs948V1O2aud8TBVxlhjyrd80eflit6cbMj2vbo5VNww5ep15jM8naeUOMagJ3x3SZZO55ufHHd+7ZXK2b493/GbzGOfs8V33WVk3/cp087Px41RdarXcdS/lqa5twzBqvTv9TBn5hnxigyZD5rhkqy9dNfaeqYizxJANP3XJ65a7a31YRGX+l6bLNvNcUvnAJUf94pZHC2qvLO/tNr+Lt2bV/Wd/ZSqcKnbppZfim2++QWFhIXbt2oXc3FzExsYiISHBh2bP//EAACAASURBVOHfuSnWgQYVBLTx4QLx4QIu41QzeZTV7Aopu0VI6Gm10cYGZBQAj23QcWWsBa1tAgfzDDRqABRqwORtOn660YIiHZi1G7gxXmBPrsSRQuD/WtTer4inExTo0sxKX2befgPPJekY21nBkwmnKkA3JKZuNzAt2cCWIRZ0aShwWyv/GNQ7tYeCdnaBxzfq+C5dw5hOCp7pcupef1JKOFxAqkPitxyzfmNDBT5ONfOXje2sYFQHxW9uGaEqp+p243EDVyzV0dYG3HqRgn5NBTpFCbSMMPOBHcoHjhRKpJwwW6t+Piqx5VYLbMEC97cXmHypgkHNRa13cVZHWU6lRg2AqdsN3NFKQceo83+9TccNfJhqYN5+iWIduOtiAafLvIF4XbU2KEJg1hUKWkcAex1Vb19dLt28Vl0GcHsrBW1sAre3UjCmk1IntyWacqmCE8WoNM9STdmZI/FKio6jhcDqG8wUE/uH1c4tyMpTNqll8jYD/zsk8d31KmIusHuqKsWaxGMbdMzdKxFqAZ7tat7K6HxTilRXRLDAl1eruH6Fjvt/1vFxv6rvalBTDGm+j0MtArtzJVpHCCy6RkXCBXZ/VuWhjgq6x5gpHHyt7HZV1SGk9LN5ytXkdDpht9vhcDhgs9kAmAGFy0C509V/OmJgdYbEXqfEnlyJmb1UT36nSxa68XsukH+vBeGfmOkY5KggTNiiY+p2A7EhQJ9Ysxswo9AcK5JeAKy/WcU/1urYdRIwRgVhaZqBd3YZ+O662h//AwB/5Er8+3ezm2xwc4GZvVV0bSjwzQEDi9MMbMqU2OswP1hf6OY/M6ZOd7RQYuIWHYsOShy9x4JgVWDg/zT8clSibHKMALBwkIrbWynIc0mEBaHWP7QuhJQSG45LfJhqYHm6RGYR0DkK+O2OIEgpEfKxmS5EFebYqv5NzfsFNgn132MCzPvCxYebtwt6Lskcx9gnVlR6Lhwuic1ZEgObmTmNen6jIbNY4oH2Cu5rp6CFnwTIZWRpbrF3d+tIyQGe6KycU3fl/2/vzuOiLNf/gX+eGRjEGQYYEAFZBFM2AbdQ9Ki4R8qpzNKOC+KRDEyz0/llae65RHlaTCs9CZY/O9q3NCy3NO1o+lNc0G+glJYKyjKIMoBsM8/1++NxpkYWUWdgxOv9es1L53nuZ+aem4G55rq38lrCviuEHbmEr34Xca0aeNJfwNbhllv25H4YXx8gDRkYHWC5GbZ6URqf+mGWiAP5hA5KYHaEDNObIchoSOY1wvAderSRA1uGyNHHwmtlVekJP1wlxPpK7+/R3+vxaDtpH9bm7q7bfEEaAjKps4B1/a37GVRjIHz5O2FFpgFDOsjwXrQcIlGL/JzfPm3AtWpgaa+6qwdYml4kdNqsx6Xn7JtU3jZ+6y1ELhPg2MDvz/FiwofZIoZ4C/BVmi+eefbWihOOdjBtMgn8sZO3TAC++p2wsIeArhoZHnUX8PVFESEuAn6+DvjfWgM1zFXA5zHNE1yduUbodWvhxfeipW9Kxj+cWdcJOaXSYqmfx8gQdR9jgqzNq62AdQPs8GE/Mk3PnvCIDE8HENwcBHR2FhDi8kfQ/CCsgyIIUuDRz1MGkQh5FdKyA8Zzux6TBjIHOaPZvtFbgjFbePYG8PVFEe/+DDgrgN7tBES6SQE+IC3seu4G4ZdSwrkb0hInp0bboZsb8NUwOTq0hc1uRGz8HRIEaR+0j8+K6OEujSVJ6CJDqKuA69WEa1VSxvzqTSkj6ekIjPKX4VQx4cnvpezllCAZJjwiu6fFha3F+PrOl0obZS/LBFb2kWNYh6Yt6nk7IsIFnbSZdpUBmPKjtGDmfwbL8VRHwSLLatyPbm4CTj5lh2f2GdBvuwHJIYT3ou/vg9ggSpOc/u95aV/Z0hrgzNN2CNcAXw9ruY/UsZ2k3o1FJw3Q1QCaNpZ/juIqwppsER9liyiolLZ+GxsotWVLBdFyQdoC62Qx4d8D5Bbt1ajSE9IvEdJ+FfHFYGk9ulV9mz7uq1VlsJaeMqCwUtqj7Hbv/q8B846LKE+wN/sWBwAjduihVgBfDjX/5dj4q4iJBwyI0EgbLy9/VOqW+vNMiH+fkwbMN/cqwgaRcFRL8FMKLTqQkz2cxFtZugNXCRnFBEe5NGsWAP6SroeTPRCoFhDVTkBvDymYtMUMamMq9YTvLhP+53cRPxUS1vaXI9ZXhmWnDJh7/I8+egHSYPm1/e1QK0oB1+17odqiM9cIST8ZcLiQ0NtD2i3imcA7/x0ruEk4VED4/gphT56I/EqgcIIdnBXSzFNPG8zE1oqEVT+L+N/rhNSBdqjSE05eI/TxaDwDC0hB5KVyoKOTVK7XVj1OFBMCnIDxj8gw/pGW6fJtiLEL64KOcKyIMK7TvQXPRpV66T0d5CJNTopO12NSZ6mrO9RCg9fv1/d5Iqb8V5qM9n8iZJh3nz02O3NFfHFexDeXCLpa4C/tBfx7wN1PvmlVAdZzP+hRVAnsG1n3W8Sqnw149ZiIyil1U3tj9+lxrUoaK/BnGVoRUdsMGN5BwJ4rUjOtHyBHQpDtZoQYY9Zh/GJ2qYzwWxlBIQO82wrwVsLiC9k2FyKpO3N1tohoDwHzeshxXCvNAvNRCnCQSxlIFwWwsKcclXqCKk0PkYAgZ2BYBxme6ChgkJdgs1nJ+nx3WcSo3Qa4OQA93QWEukqzv40zZRefNOByOeFimdTNeK0auPI3O3grBaRfksbi9vG4v8DF2pZnGjAnQ0S4BvhHuJRRbGq3ZV65NH5wZ56IPXkEPxXw8xjps7O8lqy+rM+90NUQFp4QkVdB2DJU+rKzJ4/Qt73Q6NInJVWEMyWEY1rCzDBplmfsTj0ulRPGBsrwbKDsnmdB2myAVVlZifDwcBQXF9e7avztAdZNPUGZqkd7R6BgQt0gak22AbOOiIjvLMBXJWD+n6a8t11fi0qDefegUdf/qcWT/jIszZS+sf53lLzFtkhhjDFrMQaQR4ukAOtKBaH2VqIu0k3ApsHSF9DduSJCXQWbGz93Nwwi4f8VEfZcIZwqlrqzOzoJ2BUrvUb/L2rR3lGAnwoIdxXwaDsBMd5Csy8Dc7/+my9ieaaIXXnSF4JNg6WxrFklhHOlBLkA1IpAYSXBVyngiY4yHCsS0fsbAwQAvT0EPO4rYGygDF1sKEvXGOP7eO8VEcN2SOs8dlQBPkopkP6kv/TZP2C7Hud1hPyb0nVKO+Cnv9oh0k2wWBBps2Ow5s+fDx8fHxQXFzepfOWtrQKLKus/39VVQGKwtFAnwTymPPO0nWlbjtv9PMYeIhH2XiUcLaIHIvXPGGN3y5iN6e0hw3ePNfwl8n43f7cFcplxnGT955s6iNnWDfCSYYCXDLnlhK8vigi7lYn56qKIBSf+6Oa2lwGTu0gBVoRGwFdD5RjoJdz3wqAtwfg+HuIt4Ndn7XC4kJB9g5BXQdD/aXHSfu0FDPIWEOIiIFIjoLMzTOOnLZWhs8kM1smTJzFx4kT861//wtixY5uUwSqqJLTf+McMwIb0+LoWfTxkWPOXu1ug7J0zBiw8IaJssp1Np4UZY4yxxohEuFENiADsBECtsO2Z2Q8qm8tg6fV6JCYmYvXq1U0qr9PpAACllQDgCAdZ/fFiSZU0ULHaADjcw+KvChkQobHtPnfGGGPsTmSCYJVZhsyczeV6V65ciYiICMTExDSpvK+vL5ydndElOAQA4H3zYr3lvr1M6LFVj3K9FCzdrYFed5/1YowxxtjDyaYyWBcuXMDq1atx6tSpJl+Tm5sLtVqN0hrAbyvQpn3HesvZ3QqqUqLk6OJ891moSBtay4Yxxhhjts2mAqyDBw9Cq9UiLCwMAFBTUwOdTgdPT0+kp6cjKiqqzjVqtRpqtRpORAD0cG1Tf3rKOIv6cV/hgViskjHGGGMPLpsKsMaOHYvHHnvMdP/w4cNISEhAZmYm3NzcGr12fY409mpW18YDrDXZIob7yNC9BfYwYowxxtjDwaYCLEdHRzg6OpruazQaCIIAT88G5tL+yclrUoB1sIDwTGDd8w5yQGUPvJYhQiEHurvzeCrGGGOMWYfNDXL/s5iYmHqXaKjP1Furq/8zov6XFOcvQ9lkeyhk9zbInTHGGGOsqWwqg3U/ursLja5/BUgrvNaIaPENSBljjDHWurWaXE5ZDeF8KcEg1r8O1uFCEUFbpIVIHVrNq2aMMcaYLWo1ocbbZ0R03qI37Z11u5t64FcdEOoC+Kqat26MMcYYe7i0mi7CJaekyKpNA5txGnsFvxluh0fuYR0sxhhjjLGmajUZrDsNXDcGWMVV5hs+MsYYY4xZWqsJsIom2uHsMw0n5IwruUenG/DDVQ6wGGOMMWY9rSbA2viriKzrDQdOwc4C3uktvVxepoExxhhj1tRqQo20Xwh78hoOsDRtBMT63gqweI1RxhhjjFlRqwmwakRqNDNVVElYfNIAgDNYjDHGGLMumwo1qqurkZiYiICAADg5OSE4OBjr169v0rXSAqINny+sBDb/JmW4HHihUcYYY4xZkU0t06DX6+Hl5YW9e/ciMDAQR48eRWxsLHx8fDB8+PBGr60xNJ6ZMq7ekD5cjhAXC1aaMcYYY+w2NpXBUiqVWLx4MTp16gRBENCnTx8MGjQIhw4duuO1YwJkiGrXcGbKOIvQyR6wk3EGizHGGGPWY1MB1u2qqqpw7NgxRERENFhGp9NBp9NhbkgFhriVo7q6ut5yxgzWiJ0GXKviZRoYY4wxZj02G2AREaZOnYrOnTtj9OjRDZbz9fWFs7MznIOj4ewdgOXLl9dbzkkhBVk1IsDrjDLGGGPMmmxqDJYRESEpKQk5OTnYu3cvZLKG48Dc3Fw4OanhssURS7vV4pWI+ke6u7cRsGmwHM/uM/AyDYwxxhizKpvLYBERpk+fjmPHjmHPnj1wdnZutLxarcZ/b0i7N/+oVcDBwaHeciIRftNJqStepoExxhhj1mRzGawXX3wRP/30E3744Qe4uro26RptlfRvgFPDg9d1NcBrGdKG0BxgMcYYY8yabCrUuHTpEtasWYOcnBz4+/tDpVJBpVLhhRdeaPS6m3opM/VoE2YR9vEQIOdZhIwxxhizIpvKYPn7+4Po7kegX9BJ/wqNxE3GWYTTQ20qpmSMMcZYK2RTAda9mt9DBlcH4JmAhiMs+1tx1ebfREzozEEWY4wxxqynVQRYrg4C5vdofGqgsVfw28u8RgNjjDHGrKtVpHI+zDJg2SlDo2UEQcCrETJ4OjZTpRhjjDH20GoVGawZh6XZgXO6N57FkssAx1bxihljjDFmy1pNuBHchA2cl2eK1q8IY4wxxh56raKLUOMATOaB64wxxhizEQ98BouIoKsB1Io7l23XBpjVlQMxxhhjjFnXAx9gCYKAioSmvQyFHKhsfCw8Y4wxxth9axXpHIVcgEJ+59XZr1QAn5zlcVh3o7q6GgsXLkR1dXVLV6XV47ZuHtzOzYfbuvlwWzePu2lnge5l6XQrqq2txcsvv4xNmzYBAMaPH493330XdnbmWSqdTgdnZ2dsOnMdn1xSYXesHA53CLJ+LiG4twE82/JWOU1lbOfS0lKo1eqWrk6rxm3dPLidmw+3dfPhtm4ed9PONpfBevPNN3Ho0CFkZWUhKysLBw8exLJlyxosf7KYcF5HdwyuAKCrRuDgijHGGGNWZ3MB1vr16/HGG2/Ay8sLXl5emDt3Lj799NMGy5+4Rghz4aCJMcYYY7bDpga5X79+HXl5eejWrZvpWLdu3XD58mWUlpbC2dnZdNzYs7n/Nx3m9KpBXp4eAODg4AAHB4fmrXgrptPpzP5l1sNt3Ty4nZsPt3Xz4bZuHsb2bcroKpsag5Wbmws/Pz9otVq4u7sDALRaLTw8PJCbmwsfHx9T2by8PPj6+rZUVRljjDH2kCoqKkK7du0aLWNTGSyVSgUAKC0tNQVYpaWlAAAnJyezst7e3rhw4QLs7e0hCH90EXIGizHGGGPWdHtMUh+bCrBcXV3h4+ODzMxMdOrUCQCQmZkJX19fs+5BAJDJZAgMDGyJajLGGGOMNcrmBrknJCRg6dKlKCgoQEFBAZYtW4apU6e2dLUYY4wxxprMpjJYADBv3jxcu3YNISEhAKR1sObMmdPCtWKMMcYYazqbGuTOGGOMMdYa2FwXIWs5H374IXr16gUHBwc8+eSTZud0Oh3+9re/Qa1Wo3379liyZEkL1fLBV11djcTERAQEBMDJyQnBwcFYv3696Ty3teXMmDEDvr6+UKvV6NChA2bNmoWamhoA3M7WUllZiUceeQQuLi6mY9zWljN58mQoFAqoVCrT7ciRI6bztbW1ePHFF6HRaKDRaDBjxgzo9foWrPGDLT09Hd26dYNSqYS3tzc+/vhjAE17T3OAxUy8vb3xxhtvIDExsc65GTNmoKSkBJcvX8bBgwexbt06fPbZZy1QywefXq+Hl5cX9u7dC51Oh7S0NLzyyivYs2cPAG5rS0pOTsa5c+eg0+mQmZmJ06dPIyUlBQC3s7XMnz/fbEkdgNva0pKTk1FeXm66RUdHm87d7W4orGG7du1CcnIy3nvvPeh0OmRlZSEmJgZAE9/TxNhtFixYQE888YTpfkVFBSkUCsrIyDAdS0lJoQEDBrRE9Vqlp556iubNm8dtbUVFRUU0ePBgmjRpErezlZw4cYJCQ0Np165d5OzsTET898PS4uPj6aWXXmrwvI+PD3355Zem+1u2bCE/P7/mqFqr06tXL/rkk0/qHG/qe5ozWOyOcnJyUFNTU2eF/TNnzrRgrVqPqqoqHDt2DBEREdzWVrBixQo4OTnBw8MDp0+fxowZM7idrUCv1yMxMRGrV682W4uQ29ryPvvsM2g0GoSFhWHlypUQRRHAnXdDYU1XUVGBEydOQKfTITg4GJ6enhg7diwKCgqa/J7mAIvdUXl5OZRKJezs/ph06uLigrKyshasVetARJg6dSo6d+6M0aNHc1tbwWuvvYaysjJkZ2fjhRdegKenJ7ezFaxcuRIRERGmLhQjbmvLmjlzJnJycqDVavHpp5/i/fffx/vvvw9AamsAZuPfjP/n9r47169fBxHh888/x+7du3H+/HnY29tj4sSJTX5Pc4DF7kilUuHmzZtmAyVLS0ubtJItaxgRISkpCTk5Odi2bRtkMhm3tRWFhIQgMjISkydP5na2sAsXLmD16tV455136pzjtrasHj16oF27dpDL5ejTpw9ee+01bN68GYD5bihGDe2GwhpnbMuZM2fC398fKpUKixYtwr59+yCTyZr0nuYAi91RUFAQ7O3tcfr0adOxzMxMhIeHt2CtHmxEhOnTp+PYsWPYs2ePaacCbmvrqq2txa+//srtbGEHDx6EVqtFWFgYPD09MXr0aOh0Onh6eqKsrIzb2opksj8+xv+8G4pRQ7uhsMa5uLjAz8/PbCs+o/Dw8Ka9p606Qow9UGpra6myspLmzp1LcXFxVFlZSdXV1URENHHiRIqNjaUbN27QL7/8Qn5+frRhw4YWrvGDKzk5mSIiIqi4uLjOOW5ryygrK6P169fT9evXSRRFOnPmDIWEhFBiYiIRcTtb0s2bNyk/P990++qrr0itVlN+fj7V1NRwW1vQ5s2bqbS0lERRpIyMDPL396eUlBTT+Xnz5lH37t1NP4vu3bvTokWLWrDGD64333yTIiMjKS8vj27evEmTJk2ioUOHElHT/n5wgMVMFixYQADMbgMHDiQiotLSUho3bhypVCpq164d/8Leh4sXLxIAcnBwIKVSabpNmzaNiLitLaW8vJyGDh1KGo2GlEolBQQE0D//+U+qqKggIm5na9q/f79pFiERt7Ul9e/fn5ydnUmpVFKXLl3orbfeIoPBYDpfU1NDycnJ5OLiQi4uLjR9+nSqra1twRo/uPR6Pf3jH/8gNzc3cnNzozFjxlB+fj4RNe09zSu5M8YYY4xZGI/BYowxxhizMA6wGGOMMcYsjAMsxhhjjDEL4wCLMcYYY8zCOMBijDHGGLMwDrAYY4wxxiyMAyzGGGOMMQvjAIuxh8iZM2eQkJCAgIAAtGnTBiqVCj169EBKSgpKSkpaunoWt2zZMmzbtq3O8QMHDkAQBBw4cKDZ6hITEwNBEO54W7hwIQCgY8eOmDx5crPVjzFmWbzQKGMPiXXr1iE5ORlBQUFITk5GaGgoamtrcfz4caxbtw6RkZHYunVrS1fTolQqFcaMGYO0tDSz4zqdDtnZ2QgNDYVarW6WumRnZ0On05nuf/fdd3jzzTeRmpqK4OBg03EfHx/4+Pjg1KlTUKvV6NSpU7PUjzFmWXYtXQHGmPUdOXIESUlJGDZsGLZt2wYHBwfTuWHDhuGVV17Brl27WrCGzUutVqNPnz7N+pyhoaFm98+dOwcA6Nq1K3r16lWnfPfu3ZulXowx6+AuQsYeAsuWLYMgCFi7dq1ZcGWkUCjw17/+1XRfFEWkpKQgODgYDg4O8PDwwKRJk5CXl2d2XUxMDLp27YqMjAz0798fbdu2RWBgIFasWAFRFAEAWq0WCoUC8+bNq/O8586dgyAI+OCDD0zHCgoKMG3aNPj4+EChUCAgIACLFi2CXq83u7a6uhqLFy9GSEgI2rRpAzc3NwwaNAiHDx8GAAiCgIqKCmzYsMHU/RYTEwOgbhfhe++9B0EQcP78+Tp1nD17NhQKBYqLi03H9u7diyFDhkCtVqNt27bo168f9u3b19iP4K7d3kVorPOmTZswe/ZseHl5QaVSIS4uDoWFhSgrK8Pzzz8Pd3d3uLu7IyEhAeXl5WaPSURYs2YNunXrBkdHR7i6umLMmDH47bffLFp3xhgHWIy1egaDAT/88AN69uwJX1/fJl2TlJSE2bNnY9iwYUhPT8eSJUuwa9cu9O3b1yzQAKSAaPz48ZgwYQLS09MRGxuL119/HRs3bgQAtGvXDqNGjcKGDRtMQZdRamoqFAoFxo8fb3qsqKgo7N69G/Pnz8fOnTvx97//HcuXL0diYqLpOr1ej9jYWCxZsgSjRo3C1q1bkZaWhr59++Ly5csApKydo6MjHn/8cRw5cgRHjhzBmjVr6n29EyZMgEKhqNOVaDAYsHHjRsTFxcHd3R0AsHHjRgwfPhxqtRobNmzAli1boNFoMGLECIsHWfWZM2cOioqKkJaWhpUrV+LAgQN47rnn8PTTT8PZ2RlffPEFXn31VXz++eeYM2eO2bXTpk3DrFmzMHToUGzbtg1r1qxBVlYW+vbti8LCQqvXnbGHSjNuTM0YawEFBQUEgMaNG9ek8mfPniUAlJycbHb86NGjBIDmzJljOjZw4EACQEePHjUrGxoaSiNGjDDdT09PJwC0Z88e0zG9Xk/e3t709NNPm45NmzaNVCoVXbp0yezx3nnnHQJAWVlZRET02WefEQBat25do69FqVRSfHx8neP79+8nALR//37TsdGjR5OPjw8ZDAbTsR07dhAA2r59OxERVVRUkEajobi4OLPHMxgMFBkZSVFRUY3W589SU1MJAGVkZNR73t/f36zuxjrf/tyzZs0iADRz5kyz408++SRpNBrT/SNHjhAAWrlypVm53NxccnR0pFdffbXJdWeM3RlnsBhjZvbv3w8AdWawRUVFISQkpE6WxtPTE1FRUWbHIiIicOnSJdP92NhYeHp6IjU11XRs9+7duHr1KqZMmWI69u2332LQoEHw9vaGXq833WJjYwEAP/74IwBg586daNOmjdm19yshIQF5eXnYu3ev6Vhqaio8PT1Nz3/48GGUlJQgPj7erH6iKOKxxx5DRkYGKioqLFan+owaNcrsfkhICABg5MiRdY6XlJSYugm//fZbCIKACRMmmNXd09MTkZGRzTqjkrGHAQ9yZ6yVc3d3R9u2bfH77783qfy1a9cAAF5eXnXOeXt7mwVOAODm5lannIODAyorK0337ezsMHHiRKxatQo3btyAi4sL0tLS4OXlhREjRpjKFRYWYvv27bC3t6+3bsbuSa1WC29vb8hklvuOGBsbCy8vL6SmpmL48OG4fv060tPT8dJLL0Eul5vqBwBjxoxp8HFKSkqgVCotVq/baTQas/sKhaLR41VVVVCpVCgsLAQRoX379vU+bmBgoBVqy9jDiwMsxlo5uVyOIUOGYOfOncjLy4OPj0+j5Y0BU35+fp2yV69eNY1FulsJCQl4++238Z///Adjx45Feno6Zs2aZQpeACkYjIiIwNKlS+t9DG9vbwDSuK5Dhw5BFEWLBVlyuRwTJ07EBx98gBs3bmDTpk2orq5GQkKCWf0AYNWqVQ3OQmwogGlp7u7uEAQBBw8erHeiQ33HGGP3jgMsxh4Cr7/+Onbs2IHExER88803puyGUW1tLXbt2oW4uDgMHjwYgDSY+9FHHzWVycjIwNmzZzF37tx7qkNISAh69+6N1NRUGAyGOsELIHV/7dixA506dYKrq2uDjxUbG4svvvgCaWlpjXYT3p5Ju5OEhASkpKSYHjs6Otpsjap+/frBxcUF2dnZePHFF5v8uLZg1KhRWLFiBa5cuYJnn322pavDWKvHARZjD4Ho6Gh89NFHSE5ORs+ePZGUlISwsDDU1tbi1KlTWLt2Lbp27Yq4uDgEBQXh+eefx6pVqyCTyRAbG4uLFy9i3rx58PX1xcsvv3zP9ZgyZQqmTZuGq1evom/fvggKCjI7v3jxYnz//ffo27cvZs6ciaCgIFRVVeHixYvYsWMHPv74Y/j4+OC5555DamoqXnjhBeTk5GDQoEEQRRFHjx5FSEgIxo0bBwAIDw/HgQMHsH37dnh5ecHJyanOc/5ZcHAwoqOjsXz5cuTm5mLt2rVm51UqFVatWoX4+HiUlJRgzJgx8PDwgFarxenTp6HVavHRRx/dc/tYU79+/fD8888jISEBx48fx4ABA6BUKpGfn49Dhw4hPDwcHJHXmgAAAURJREFUSUlJLV1NxlqPlh5lzxhrPpmZmRQfH09+fn6kUChIqVRS9+7daf78+VRUVGQqZzAY6K233qIuXbqQvb09ubu704QJEyg3N9fs8QYOHEhhYWF1nic+Pp78/f3rHC8tLSVHR8dGZwBqtVqaOXMmBQQEkL29PWk0GurZsyfNnTuXysvLTeUqKytp/vz51LlzZ1IoFOTm5kaDBw+mw4cPm73efv36Udu2bQkADRw4kIjqn0VotHbtWgJAjo6OVFpaWm8df/zxRxo5ciRpNBqyt7enDh060MiRI+nLL7+st3x97nUW4e3P0dDjLFiwgACQVqs1O75+/Xrq3bs3KZVKcnR0pE6dOtGkSZPo+PHjTa47Y+zOeKscxhhjjDEL42UaGGOMMcYsjAMsxhhjjDEL4wCLMcYYY8zCOMBijDHGGLOw/w/G+L2VyY0znQAAAABJRU5ErkJggg==" - }, - "execution_count": 147, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plt = plot(layout = (2,1), \n", - " ylabel = [\"\\$C_L\\$\" \"\\$C_D\\$\"], ylim = [(0, 12) (0, 12)], \n", - " xlabel = [\"\" \"Convective Time\"], size = (600, 300), legend = :none)\n", - "plot!(Δt:Δt:tf, [2imag.(forces) -2real.(forces)], linewidth = 1, linestyle = :dash)\n", - "# sheet_forces = open(deserialize, \"aoa60_sheet_force.dat\")\n", - "# plot!(plt, range(Δt, Δt, length(sheet_forces)), [2imag.(sheet_forces) -2real.(sheet_forces)], linewidth = 2, label=\"Sheet Only\", legend = :none)\n", - "#savefig(\"pitchup07_hybrid_force.pdf\")\n", - "plt" - ] - }, { "cell_type": "code", "execution_count": null, diff --git a/src/PotentialFlow.jl b/src/PotentialFlow.jl index d65a510..0ab165e 100644 --- a/src/PotentialFlow.jl +++ b/src/PotentialFlow.jl @@ -3,6 +3,7 @@ __precompile__() module PotentialFlow using Reexport +using UnPack include("Properties.jl") include("Utils.jl") @@ -52,6 +53,8 @@ import .Doublets: Doublet import .Freestreams: Freestream +include("vorticity_transfer.jl") + #== Plot Recipes ==# include("plot_recipes.jl") diff --git a/src/elements/Plates.jl b/src/elements/Plates.jl index 84e9651..67249ca 100644 --- a/src/elements/Plates.jl +++ b/src/elements/Plates.jl @@ -1,5 +1,6 @@ module Plates +using UnPack using DocStringExtensions using LinearAlgebra: rmul! diff --git a/src/vorticity_transfer.jl b/src/vorticity_transfer.jl new file mode 100644 index 0000000..e0ec68f --- /dev/null +++ b/src/vorticity_transfer.jl @@ -0,0 +1,241 @@ +export impulse_matching_correction, transfer_circulation!, sheettip_to_blob!, newest_element, + shed_new_vorticity! + + +""" + shed_new_vorticity!(sys,motion,δ,t,lesp=0.0,tesp=0.0) + +Returns the plate/vortex system after adding new vortices of the appropriate type +at the plate edges, in order to satisfy the respective regularization conditions at those edges. +""" +function shed_new_vorticity!(sys, motion, δ, t, lesp = 0.0, tesp = 0.0) + plate, ambient_sys = sys + le_sys, te_sys = ambient_sys + + + nlev = new_vortex(le_sys..., plate.zs[end], plate.α, δ, plate, motion) + ntev = new_vortex(te_sys..., plate.zs[1], plate.α, δ, plate, motion) + + Γ₊, Γ₋, _, _ = Plates.vorticity_flux!(plate, nlev, ntev, t, lesp, tesp) + + plate, (add_new_vortex!(le_sys..., nlev, Γ₊), add_new_vortex!(te_sys..., ntev, Γ₋)) + +end + +""" + impulse_matching_correction(vs, vt, plate) -> ComplexF64 + +Compute the impulse matching position correction for a target vortex `vt` when the circulation +of a source vortex `vs` is to be fully transferred to it. Equation (A26) of Darakananda and Eldredge JFM 2019 +with Γ̇ = ΓₛΔt. Assumes a flat plate body. +""" +function impulse_matching_correction(vs, vt, plate::Plate) + @unpack c, α, L = plate + + c⁺ = plate.zs[end] + c⁻ = plate.zs[1] + + z̃t = 2(vt.z - c)*exp(-im*α)/L + z̃s = 2(vs.z - c)*exp(-im*α)/L + + pt = Plates.unit_impulse(z̃t) + ps = Plates.unit_impulse(z̃s) + + η = z̃t/(√(z̃t + 1)*√(z̃t - 1)) + + Δp = ps - pt + Δz = im*0.5L*exp(im*α)*(Δp*(1 + η') + Δp'*(η' - 1))/(η + η')*(circulation(vs)/circulation(vt)) +# if isnan(Δz) || isinf(Δz) +# error("Δz is $Δz") +# end + return Δz +end + + +""" + transfer_circulation!(sheet,point,Δz,plate,ϵ=1e-3;[max_segments=10]) -> Vortex.Blob + +Return a vortex blob that is initially identical to `point` and, where appropriate, +accrues the circulation of the last several segments of the vortex sheet `sheet`. +In these cases, it also removes the last several segments of `sheet`. The position +correction `Δz`, which accounts for the impulse matching correction due to the +transfer of circulation from each segment, is added to the position of `point` +to create the output vortex blob. `ϵ` is the maximum allowable discrepancy in +the impulse due to the circulation transfer (compared to the impulse if no circulation +is transferred). `max_segments` is the maximum number of sheet segments that can be considered +for transfer; it defaults to 10. +""" +function transfer_circulation!(sheet, point, Δz, plate, ϵ = 1e-3; max_segments=10) + z₀ = Elements.position(point) + Γ₀ = circulation(point) + + ΣΔz = zero(ComplexF64) + ΣΓ = 0.0 + + Σp = Plates.vortex_impulse(plate,Vortex.Point(z₀, Γ₀)) #total_impulse(Vortex.Point(z₀, Γ₀), plate) + + segments = 0 + + # If the sheet isn't long enough to transfer, then return with no transfer + if length(sheet) < max_segments+2 + return point + end + + for n in 1:length(sheet)-max_segments # Don't eat into the last `max_segments` segments + if isnan(Δz[n]) || isinf(Δz[n]) + if n ≤ 2 + return point + else + segments = n-1 + break; + end + end + + ΣΔz += Δz[n] + ΣΓ += circulation(sheet.blobs[n]) + + p₊ = Plates.vortex_impulse(plate,Vortex.Point(z₀ + ΣΔz, Γ₀ + ΣΓ)) # impulse of active vortex with this segment transferred + Σp += Plates.vortex_impulse(plate,sheet.blobs[n]) # impulse of the sheet if this segment is not transferred + + + if abs2(p₊ - Σp) > ϵ^2 + if n ≤ 2 + return point + else + segments = n-1 + break + end + end + segments += 1 + end + + # Change the position and strength of `point`, using the impulse correction + # and strength of each segment + z = z₀ + sum(Δz[1:segments-1]) + 0.5Δz[segments] + Γ = Γ₀ + sum(circulation(sheet.blobs[1:segments-1])) + + 0.5(sheet.Ss[segments] -sheet.Ss[segments-1]) + point₊ = Vortex.Blob(z, Γ, point.δ) + + # Remove the transferred segments from the sheet + splice!(sheet.blobs, 1:segments-1) + splice!(sheet.Ss, 1:segments-1) + sheet.blobs[1] = sheet.blobs[1](Γ = 0.5(sheet.Ss[2] - sheet.Ss[1])) + + return point₊ +end + +""" + sheettip_to_blob!(blobs,sheet) + +Transform the tip of a vortex sheet into a vortex blob. Add it to the beginning of the list +of blobs (and remove it from the sheet). +""" +function sheettip_to_blob!(blobs::Vector{T},sheet::Vortex.Sheet) where T <: Vortex.Blob + tips = sheet.blobs[1:2] + + # factor of 2 in circulation is due to the trapezoidal weight on blob strength of first blob + new_blob = Vortex.Blob(0.5*(tips[1].z + tips[2].z), 2circulation(tips[1]), tips[1].δ) + + # remove the first entry from the sheet, since this has been transferred to the active blob + splice!(sheet.blobs, 1) + splice!(sheet.Ss, 1) + + # now the second sheet element is the first element and needs to have its strength adjusted for trapezoidal weight + sheet.blobs[1] = Vortex.Blob(tips[2].z, 0.5*(sheet.Ss[2] - sheet.Ss[1]), tips[2].δ) + pushfirst!(blobs, new_blob) + nothing +end + + +""" + new_vortex(edge,angle,δ,plate,motion) -> Vortex.Blob + +Create a new vortex blob near the edge `edge` of the plate, with unit strength +""" +new_vortex(edge, α, δ, plate, motion) = Vortex.Blob(edge - 1e-2im*exp(im*α)*sign(Plates.normal(motion.ċ+im*motion.α̇*(edge-plate.c),α)), 1.0, δ) + + +""" + new_vortex(blobs::Vector{Vortex.Blob},edge,angle,δ,plate,motion) -> Vortex.Sheet + +Create a new vortex sheet near the edge `edge` of the plate with unit strength, using the vortex blobs in `blobs` +to place the sheet segments. (The blobs are placed at the sheet segment centroids.) +""" +function new_vortex(blobs::Vector{T}, edge, α, δ, plate, motion) where T <: Vortex.Blob + Δz = (blobs[end].z - edge)/2 + #Vortex.Sheet([0.5, 1.5] .* Δz .+ edge, [0.0, 1.0], δ) + Vortex.Sheet([1.5, 0.5] .* Δz .+ edge, [1.0, 0.0], δ) +end + +""" + new_vortex(blobs::Vector{Vortex.Blob},sheet::Vortex.Sheet,edge,angle,δ,plate,motion) -> Vortex.Blob + +Create vortex blobs near the edge `edge` of the plate with unit strength, using the last vortex sheet segment in `sheet` +to place the blobs. +""" +function new_vortex(::Vector{T}, sheet::Vortex.Sheet, edge, α, δ, plate, motion) where T <: Vortex.Blob + z = (edge + 2sheet.zs[end])/3 + Vortex.Blob.([sheet.zs[end], z], [0.5, 0.5], δ) +end + + + + +""" + add_new_vortex!(blob::Vortex.Blob,Γ) -> (blob,) + +Create a new vortex blob with the position and radius of `blob`, but with strength `Γ`, +unless `Γ` is zero, in which case it returns an empty tuple. +""" +function add_new_vortex!(b::Vortex.Blob, Γ) + if Γ != 0 + ([Vortex.Blob(b.z, Γ, b.δ)],) + else + () + end +end + +""" + add_new_vortex!(blobs::Vector{Vortex.Blob},sheet,Γ) -> (blob,) + +Return blobs and a sheet with the same positions and radii as `sheet`, but with the strengths +set to 0 and `Γ`. This is meant for cases in which the sheet is initially created. +""" +function add_new_vortex!(blobs::Vector{T}, sheet::Vortex.Sheet, Γ) where T <: Vortex.Blob + blobs, Vortex.Sheet(sheet.zs, [0.0, Γ], sheet.blobs[1].δ) +end + +""" + add_new_vortex!(blobs::Vector{Vortex.Blob},sheet,segment::Vector{Vortex.Blob},Γ) -> (blob,) + +Return blobs and a sheet that appends the last vortex in `segment` to the end of `sheet`, with strength `Γ`. +This is the newly-created entry from the edge. +""" +function add_new_vortex!(blobs::Vector{T}, sheet::Vortex.Sheet, segment::Vector{T}, Γ) where T <: Vortex.Blob + Vortex.Sheets.append_segment!(sheet, segment[2].z, Γ) + blobs, sheet +end + + +""" + newest_element() -> () + +Returns an empty tuple +""" +newest_element() = () + +""" + newest_element(blobs::Vector{Vortex.Blob}) -> (Vortex.Blob,) + +Returns the most recently added vortex in `blobs` +""" +newest_element(blobs::Vector{T}) where T <: Vortex.Blob = (blobs[1],) + +""" + newest_element(blobs::Vector{Vortex.Blob},sheet::Vortex.Sheet) -> (Vortex.Blob,) + +Returns the most recently added vortex in `sheet` +""" +function newest_element(blobs::Vector{T}, sheet::Vortex.Sheet) where T <: Vortex.Blob + (sheet.blobs[end],) +end From 5565bcaf238bfc878e23eb6c23f8b8be0531094d Mon Sep 17 00:00:00 2001 From: Jeff Eldredge Date: Tue, 22 Aug 2023 10:36:43 -0700 Subject: [PATCH 08/11] Added hybrid model to binder notebooks and fixed an error in chebyshev transform typing --- binder/notebooks/Hybrid Model.ipynb | 912 +++++++++ ...brid Model Force Compare Oscil Heave.ipynb | 1823 ----------------- src/elements/plates/chebyshev.jl | 16 +- 3 files changed, 922 insertions(+), 1829 deletions(-) create mode 100644 binder/notebooks/Hybrid Model.ipynb delete mode 100644 other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb diff --git a/binder/notebooks/Hybrid Model.ipynb b/binder/notebooks/Hybrid Model.ipynb new file mode 100644 index 0000000..bf7ed74 --- /dev/null +++ b/binder/notebooks/Hybrid Model.ipynb @@ -0,0 +1,912 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Hybrid vortex sheet-point vortex model" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mPrecompiling PotentialFlow [73af2aaf-3f58-5b29-82a9-435ecf827f5b]\n" + ] + } + ], + "source": [ + "using PotentialFlow" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "using Plots\n", + "using ProgressMeter\n", + "using SpecialFunctions\n", + "using PotentialFlow.UnPack" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Time Marching" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "compute_ẋ! (generic function with 1 method)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function compute_ẋ!(ẋ, x, t)\n", + " plate, ambient_sys = x\n", + " motion = ẋ[1]\n", + " motion.ċ, motion.c̈, motion.α̇, motion.α̈ = motion.kin(t)\n", + "\n", + " Plates.enforce_no_flow_through!(plate, motion, ambient_sys, t)\n", + " reset_velocity!(ẋ, x)\n", + " self_induce_velocity!(ẋ, x, t)\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "counter_min (generic function with 1 method)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "counter_min(Tmin,Δt) = isinf(Tmin) ? Inf : round(Int,Tmin/Δt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison with Theodorsen " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set up the Theodorsen solution" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "C(κ::Float64) = hankelh2(1,κ)/(hankelh2(1,κ)+im*hankelh2(0,κ))\n", + "\n", + "struct Theodorsen\n", + " kin :: RigidBodyMotions.PitchHeave\n", + " L :: Float64\n", + "end\n", + "\n", + "function (theo::Theodorsen)(t::Float64)\n", + " @unpack L, kin = theo\n", + " @unpack Y,Ẏ,U₀,α,a,α̇,Ÿ,α̈,K = kin\n", + " # defined for motion in +x direction\n", + " ReΓb = π*L*(-Ẏ(t) + U₀*α(t) + (1/4 + a)*L*α̇(t))\n", + " ImΓb = π*L*(-2K*Y(t) - U₀*α̇(t)/(2K) + (1/4 + a)*L*2K*α(t))\n", + " fy = π*(L/2)^2*(-Ÿ(t) + a*α̈(t) + U₀*α̇(t)) + U₀*real((ReΓb+im*ImΓb)*C(K))\n", + " momp = π*(L/2)^2*(a*Ÿ(t)-(L^2/32+a^2)*α̈(t)-(L/4+a)*U₀*α̇(t)) + (L/4-a)*U₀*real((ReΓb+im*ImΓb)*C(K))\n", + " return fy, momp+a*fy\n", + "end" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now set up the problem parameters and kinematic" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "f* = 0.3183098861837907\n", + "Δα = 5.0\n", + "α(1/4) = 5.0\n", + "A/c = 0.0\n", + "K = 1.0\n", + "χ = Inf\n" + ] + } + ], + "source": [ + "L = 1.0 # chord length\n", + "\n", + "a = 0.5 #0.25 # location of pitch axis, a = 0.5 is leading edge\n", + "ϕ = -π/2 # phase lag of pitch to heave\n", + "A = 0.0 #0.0 # amplitude/chord\n", + "fstar = 1/π # fc/U\n", + "α₀ = 0 # mean angle of attack\n", + "Δα = 5π/180 #2π/180 # amplitude of pitching\n", + "\n", + "\n", + "#=\n", + "# Kinsey-Dumas case\n", + "a = 0.2 #0.2 # location of pitch axis, a = 0.5 is leading edge\n", + "ϕ = -π/2 # phase lag of pitch to heave\n", + "A = 1.0 #1.0 # amplitude/chord\n", + "fstar = 0.14 # fc/U\n", + "α₀ = 0π/180 # mean angle of attack\n", + "Δα = 60π/180 #20π/180 # amplitude of pitching\n", + "=#\n", + "\n", + "χ = Δα/atan(2π*A*fstar)\n", + "K = π*fstar # reduced frequency, K = πfc/U\n", + "println(\"f* = \",fstar)\n", + "println(\"Δα = \",Δα*180/π)\n", + "println(\"α(1/4) = \",abs(atan(2*K*A)-Δα)*180/π)\n", + "println(\"A/c = \",A)\n", + "println(\"K = \",K)\n", + "println(\"χ = \",χ)\n", + "\n", + "oscil = RigidBodyMotions.PitchHeave(1.0,a,K,ϕ,α₀,Δα,A);\n", + "motion = Plates.RigidBodyMotion(oscil);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot the effective angle of attack" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t = 0:0.01:(4.0./fstar)\n", + "Vy = map(x -> imag(x[1]),motion.kin.(t))\n", + "αeff = atan.(-Vy)+motion.kin.α.(t)\n", + "plot(t,αeff*180/π,xlim=(0,Inf),ylim=(-30,30),legend=false,ylabel=\"Effective angle (deg)\",xlabel=\"Convective time\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Select the metaparameters for the hybrid vortex model\n", + "\n", + "* $N$ is the number of plate control points\n", + "\n", + "* $\\Delta t$ is the time step size.\n", + "\n", + "* $\\delta$ is the blob radius. It is best to set this to around 0.05 times the chord length.\n", + "\n", + "* `lesp` and `tesp` are the critical edge suction parameters at the leading and trailing edge, respectively\n", + " - Setting this to 0 leads to the Kutta condition at that edge\n", + " - Setting this to a large positive value ($\\sim 10$) suppresses vortex shedding from that edge\n", + "\n", + "* $B_f$ sets the tolerance for force error in the hybrid model.\n", + " - Setting this to zero turns off variable-strength point vortices and generates a traditional vortex model. \n", + " - It is generally advisable to set this to around 0.05 or 0.1 \n", + "\n", + "* $T^*_{min}$ sets the minimum time interval between the release of a new active vortex from the tip of each vortex sheet.\n", + " - Setting this to infinity (and setting $B_f$ to 0) generates a pure vortex sheet model.\n", + " - Setting this to 0 generates a discrete vortex model\n", + " - For a hybrid model, it is generally best to set this between 0.1 and 0.3\n", + " \n", + "* $t_f$ is the final time " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "N = 128 \n", + "\n", + "Δt = 1e-2\n", + "δ = 0.05 #0.1 #0.01\n", + "\n", + "lesp = 10 #0.1\n", + "tesp = 0.0\n", + "\n", + "Bf = 1e-1 #1e-1\n", + "Tmin = [Inf,2e-1]; #2e-1;\n", + "\n", + "tf = 10;" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run it!" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:00\u001b[39m\n" + ] + } + ], + "source": [ + "plate = Plate(N, L, 0, motion.kin.α(0.0))\n", + "\n", + "Plates.enforce_no_flow_through!(plate, motion, (), 0.0)\n", + "\n", + "sys = (plate, ((), ()))\n", + "\n", + "# sys[1] is the plate, sys[2] is the vortex system\n", + "# sys[2][i] corresponds to edge i (i = 1 is leading edge, i = 2 is trailing edge)\n", + "# sys[2][i][1] is the set of blobs associated with edge i\n", + "# sys[2][i][1][1] is the current active vortex for edge i\n", + "# sys[2][i][2] is the vortex sheet associated with edge i. Its first entry will be turned into a blob.\n", + "\n", + "sys = PotentialFlow.shed_new_vorticity!(sys, motion, δ, 0.0, lesp, tesp)\n", + "\n", + "states = Tuple[];\n", + "forces = [];\n", + "moments = [];\n", + "\n", + "T = Δt:Δt:tf\n", + "\n", + "# Set up Theodorsen solution results\n", + "theo = Theodorsen(oscil,L)\n", + "fytheo = map(x -> x[1], theo.(Δt:Δt:tf))\n", + "momtheo = map(x -> x[2], theo.(Δt:Δt:tf))\n", + "\n", + "counter = [0, 0]\n", + "\n", + "countermin = counter_min.(Tmin,Δt)\n", + "ϵf = Bf*Δt \n", + "\n", + "@showprogress for t in T\n", + " push!(states, deepcopy(sys))\n", + " \n", + " ẋs = (motion, allocate_velocity(sys[2]))\n", + "\n", + " compute_ẋ!(ẋs, sys, t)\n", + " \n", + " lesys, tesys = sys[2]\n", + " push!(forces, Plates.force(plate, motion, sys[2], ẋs[2], (newest_element(lesys...)..., newest_element(tesys...)...), Δt)) \n", + " push!(moments, Plates.moment(plate, motion, sys[2], ẋs[2], (newest_element(lesys...)..., newest_element(tesys...)...), Δt)) \n", + "\n", + " advect!(sys, sys, ẋs, Δt)\n", + " \n", + " for i in 1:2 # each edge\n", + " \n", + " # If this edge's vortex system is not set up, then skip the transfer\n", + " length(sys[2][i]) == 2 || continue\n", + " \n", + " edge_blobs, edge_sheet = sys[2][i]\n", + " \n", + " # Calculate the impulse matching corrections to the active vortex position\n", + " Δzs = [impulse_matching_correction(sblob, edge_blobs[1], plate) for sblob in edge_sheet.blobs] \n", + " \n", + " # Circulation is only transferred from the sheet to the active blob if\n", + " # - the sheet is long enough, and\n", + " # - more than one sheet segment can be transferred without surpassing the error tolerance\n", + " new_blob = transfer_circulation!(edge_sheet, edge_blobs[1], Δzs, plate, ϵf)\n", + "\n", + " # If the active blob has been modified, then set the counter to zero. Otherwise, increment\n", + " # the counter.\n", + " if new_blob == edge_blobs[1]\n", + " counter[i] += 1\n", + " else\n", + " counter[i] = 0\n", + " edge_blobs[1] = new_blob\n", + " end\n", + " \n", + " # if we have waited long enough between active blob releases, and the sheet is sufficiently long,\n", + " # then convert current active vortex into an inactive one, and release tip of sheet as new active vortex\n", + " if length(edge_sheet) > 2 && counter[i] > countermin[i]\n", + " sheettip_to_blob!(edge_blobs,edge_sheet)\n", + " counter[i] = 0\n", + " end\n", + " end\n", + " \n", + " # Fix up the vortex sheet with filtering or remeshing\n", + " for i in 1:2\n", + " length(sys[2][i]) == 2 || continue\n", + " edge_blobs, edge_sheet = sys[2][i]\n", + " \n", + " # Filter\n", + " Sheets.arclength(edge_sheet) ≥ 50Δt && Sheets.filter!(edge_sheet, 2Δt, 8Δt)\n", + " \n", + " # or remesh\n", + " #Sheets.arclength(edge_sheet) ≥ 30Δt && Sheets.remesh!(edge_sheet,2Δt)\n", + " end\n", + " \n", + " Plates.enforce_no_flow_through!(plate, motion, sys[2], t)\n", + " sys = shed_new_vorticity!(sys, motion, δ, t, lesp, tesp)\n", + " \n", + "\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = plot(states[end],color = cgrad(:RdBu,rev=true), ratio=1,legend=:none,markersize=3,markerstrokealpha=1,\n", + " markerstrokewidth=0.5,linewidth=1.5,ticks=nothing,border=nothing,framestyle=false,\n", + " clim=(-0.5,0.5)) #,ylim=(-3,3))\n", + "\n", + "# Plot the trajectory\n", + "zc = map(x -> x[1].c,states[1:end]) \n", + "plot!(real.(zc),imag.(zc),linestyle=:dash)\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = plot(ylabel = \"\\$C_y\\$\", xlim = (0,Inf), ylim = (-3.5,3.5), \n", + " xlabel = \"Convective Time\")\n", + "plot!(Δt:Δt:tf, 2imag.(forces), linewidth = 1.5, linestyle = :solid, label = \"Vortex model\")\n", + "plot!(Δt:Δt:tf, 2fytheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = plot(ylabel = \"\\$C_M\\$\", xlim = (0,Inf), ylim = (-1,1), \n", + " xlabel = \"Convective Time\")\n", + "plot!(plt,Δt:Δt:tf, 2moments, linewidth = 1.5, linestyle = :solid, label = \"Vortex model\")\n", + "plot!(plt,Δt:Δt:tf, 2momtheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "@webio": { + "lastCommId": null, + "lastKernelId": null + }, + "kernelspec": { + "display_name": "Julia 1.9.2", + "language": "julia", + "name": "julia-1.9" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb b/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb deleted file mode 100644 index 6b6109c..0000000 --- a/other-notebooks/Hybrid Model Force Compare Oscil Heave.ipynb +++ /dev/null @@ -1,1823 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Hybrid vortex sheet-point vortex model" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "using PotentialFlow" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "using Plots\n", - "using ProgressMeter\n", - "using SpecialFunctions\n", - "using UnPack" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Time Marching" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "compute_ẋ! (generic function with 1 method)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function compute_ẋ!(ẋ, x, t)\n", - " plate, ambient_sys = x\n", - " motion = ẋ[1]\n", - " motion.ċ, motion.c̈, motion.α̇, motion.α̈ = motion.kin(t)\n", - "\n", - " Plates.enforce_no_flow_through!(plate, motion, ambient_sys, t)\n", - " reset_velocity!(ẋ, x)\n", - " self_induce_velocity!(ẋ, x, t)\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "counter_min (generic function with 1 method)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "counter_min(Tmin,Δt) = isinf(Tmin) ? Inf : round(Int,Tmin/Δt)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Comparison with Theodorsen " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Set up the Theodorsen solution" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "C(κ::Float64) = hankelh2(1,κ)/(hankelh2(1,κ)+im*hankelh2(0,κ))\n", - "\n", - "struct Theodorsen\n", - " kin :: RigidBodyMotions.PitchHeave\n", - " L :: Float64\n", - "end\n", - "\n", - "function (theo::Theodorsen)(t::Float64)\n", - " @unpack L, kin = theo\n", - " @unpack Y,Ẏ,U₀,α,a,α̇,Ÿ,α̈,K = kin\n", - " # defined for motion in +x direction\n", - " ReΓb = π*L*(-Ẏ(t) + U₀*α(t) + (1/4 + a)*L*α̇(t))\n", - " ImΓb = π*L*(-2K*Y(t) - U₀*α̇(t)/(2K) + (1/4 + a)*L*2K*α(t))\n", - " fy = π*(L/2)^2*(-Ÿ(t) + a*α̈(t) + U₀*α̇(t)) + U₀*real((ReΓb+im*ImΓb)*C(K))\n", - " momp = π*(L/2)^2*(a*Ÿ(t)-(L^2/32+a^2)*α̈(t)-(L/4+a)*U₀*α̇(t)) + (L/4-a)*U₀*real((ReΓb+im*ImΓb)*C(K))\n", - " return fy, momp+a*fy\n", - "end" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now set up the problem parameters and kinematic" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "f* = 0.3183098861837907\n", - "Δα = 5.0\n", - "α(1/4) = 5.0\n", - "A/c = 0.0\n", - "K = 1.0\n", - "χ = Inf\n" - ] - } - ], - "source": [ - "L = 1.0 # chord length\n", - "\n", - "a = 0.5 #0.25 # location of pitch axis, a = 0.5 is leading edge\n", - "ϕ = -π/2 # phase lag of pitch to heave\n", - "A = 0.0 #0.0 # amplitude/chord\n", - "fstar = 1/π # fc/U\n", - "α₀ = 0 # mean angle of attack\n", - "Δα = 5π/180 #2π/180 # amplitude of pitching\n", - "\n", - "\n", - "#=\n", - "# Kinsey-Dumas case\n", - "a = 0.2 #0.2 # location of pitch axis, a = 0.5 is leading edge\n", - "ϕ = -π/2 # phase lag of pitch to heave\n", - "A = 1.0 #1.0 # amplitude/chord\n", - "fstar = 0.14 # fc/U\n", - "α₀ = 0π/180 # mean angle of attack\n", - "Δα = 60π/180 #20π/180 # amplitude of pitching\n", - "=#\n", - "\n", - "χ = Δα/atan(2π*A*fstar)\n", - "K = π*fstar # reduced frequency, K = πfc/U\n", - "println(\"f* = \",fstar)\n", - "println(\"Δα = \",Δα*180/π)\n", - "println(\"α(1/4) = \",abs(atan(2*K*A)-Δα)*180/π)\n", - "println(\"A/c = \",A)\n", - "println(\"K = \",K)\n", - "println(\"χ = \",χ)\n", - "\n", - "oscil = RigidBodyMotions.PitchHeave(1.0,a,K,ϕ,α₀,Δα,A);\n", - "motion = Plates.RigidBodyMotion(oscil);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plot the effective angle of attack" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "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" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "t = 0:0.01:(4.0./fstar)\n", - "Vy = map(x -> imag(x[1]),motion.kin.(t))\n", - "αeff = atan.(-Vy)+motion.kin.α.(t)\n", - "plot(t,αeff*180/π,xlim=(0,Inf),ylim=(-30,30),legend=false,ylabel=\"Effective angle (deg)\",xlabel=\"Convective time\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Select the metaparameters for the hybrid vortex model\n", - "\n", - "* $N$ is the number of plate control points\n", - "\n", - "* $\\Delta t$ is the time step size.\n", - "\n", - "* $\\delta$ is the blob radius. It is best to set this to around 0.05 times the chord length.\n", - "\n", - "* `lesp` and `tesp` are the critical edge suction parameters at the leading and trailing edge, respectively\n", - " - Setting this to 0 leads to the Kutta condition at that edge\n", - " - Setting this to a large positive value ($\\sim 10$) suppresses vortex shedding from that edge\n", - "\n", - "* $B_f$ sets the tolerance for force error in the hybrid model.\n", - " - Setting this to zero turns off variable-strength point vortices and generates a traditional vortex model. \n", - " - It is generally advisable to set this to around 0.05 or 0.1 \n", - "\n", - "* $T^*_{min}$ sets the minimum time interval between the release of a new active vortex from the tip of each vortex sheet.\n", - " - Setting this to infinity (and setting $B_f$ to 0) generates a pure vortex sheet model.\n", - " - Setting this to 0 generates a discrete vortex model\n", - " - For a hybrid model, it is generally best to set this between 0.1 and 0.3\n", - " \n", - "* $t_f$ is the final time " - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "10" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "N = 128 \n", - "\n", - "Δt = 1e-2\n", - "δ = 0.05 #0.1 #0.01\n", - "\n", - "lesp = 10 #0.1\n", - "tesp = 0.0\n", - "\n", - "Bf = 1.75e-2 #1e-1\n", - "Tmin = [Inf,4e-1]; #2e-1];\n", - "\n", - "tf = 10" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Run it!" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:01\u001b[39m\n" - ] - } - ], - "source": [ - "plate = Plate(N, L, 0, motion.kin.α(0.0))\n", - "\n", - "Plates.enforce_no_flow_through!(plate, motion, (), 0.0)\n", - "\n", - "sys = (plate, ((), ()))\n", - "\n", - "# sys[1] is the plate, sys[2] is the vortex system\n", - "# sys[2][i] corresponds to edge i (i = 1 is leading edge, i = 2 is trailing edge)\n", - "# sys[2][i][1] is the set of blobs associated with edge i\n", - "# sys[2][i][1][1] is the current active vortex for edge i\n", - "# sys[2][i][2] is the vortex sheet associated with edge i. Its first entry will be turned into a blob.\n", - "\n", - "sys = PotentialFlow.shed_new_vorticity!(sys, motion, δ, 0.0, lesp, tesp)\n", - "\n", - "states = Tuple[];\n", - "forces = [];\n", - "moments = [];\n", - "\n", - "T = Δt:Δt:tf\n", - "\n", - "# Set up Theodorsen solution results\n", - "theo = Theodorsen(oscil,L)\n", - "fytheo = map(x -> x[1], theo.(Δt:Δt:tf))\n", - "momtheo = map(x -> x[2], theo.(Δt:Δt:tf))\n", - "\n", - "counter = [0, 0]\n", - "\n", - "countermin = counter_min.(Tmin,Δt)\n", - "ϵf = Bf*Δt \n", - "\n", - "@showprogress for t in T\n", - " push!(states, deepcopy(sys))\n", - " \n", - " ẋs = (motion, allocate_velocity(sys[2]))\n", - "\n", - " compute_ẋ!(ẋs, sys, t)\n", - " \n", - " lesys, tesys = sys[2]\n", - " push!(forces, Plates.force(plate, motion, sys[2], ẋs[2], (newest_element(lesys...)..., newest_element(tesys...)...), Δt)) \n", - " push!(moments, Plates.moment(plate, motion, sys[2], ẋs[2], (newest_element(lesys...)..., newest_element(tesys...)...), Δt)) \n", - "\n", - " advect!(sys, sys, ẋs, Δt)\n", - " \n", - " for i in 1:2 # each edge\n", - " \n", - " # If this edge's vortex system is not set up, then skip the transfer\n", - " length(sys[2][i]) == 2 || continue\n", - " \n", - " edge_blobs, edge_sheet = sys[2][i]\n", - " \n", - " # Calculate the impulse matching corrections to the active vortex position\n", - " Δzs = [impulse_matching_correction(sblob, edge_blobs[1], plate) for sblob in edge_sheet.blobs] \n", - " \n", - " # Circulation is only transferred from the sheet to the active blob if\n", - " # - the sheet is long enough, and\n", - " # - more than one sheet segment can be transferred without surpassing the error tolerance\n", - " new_blob = transfer_circulation!(edge_sheet, edge_blobs[1], Δzs, plate, ϵf)\n", - "\n", - " # If the active blob has been modified, then set the counter to zero. Otherwise, increment\n", - " # the counter.\n", - " if new_blob == edge_blobs[1]\n", - " counter[i] += 1\n", - " else\n", - " counter[i] = 0\n", - " edge_blobs[1] = new_blob\n", - " end\n", - " \n", - " # if we have waited long enough between active blob releases, and the sheet is sufficiently long,\n", - " # then convert current active vortex into an inactive one, and release tip of sheet as new active vortex\n", - " if length(edge_sheet) > 2 && counter[i] > countermin[i]\n", - " sheettip_to_blob!(edge_blobs,edge_sheet)\n", - " counter[i] = 0\n", - " end\n", - " end\n", - " \n", - " # Fix up the vortex sheet with filtering or remeshing\n", - " for i in 1:2\n", - " length(sys[2][i]) == 2 || continue\n", - " edge_blobs, edge_sheet = sys[2][i]\n", - " \n", - " # Filter\n", - " Sheets.arclength(edge_sheet) ≥ 50Δt && Sheets.filter!(edge_sheet, 2Δt, 8Δt)\n", - " \n", - " # or remesh\n", - " #Sheets.arclength(edge_sheet) ≥ 30Δt && Sheets.remesh!(edge_sheet,2Δt)\n", - " end\n", - " \n", - " Plates.enforce_no_flow_through!(plate, motion, sys[2], t)\n", - " sys = shed_new_vorticity!(sys, motion, δ, t, lesp, tesp)\n", - " \n", - "\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "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", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\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/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - "execution_count": 46, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plt = plot(states[end],color = cgrad(:RdBu,rev=true), ratio=1,legend=:none,markersize=3,markerstrokealpha=1,\n", - " markerstrokewidth=0.5,linewidth=1.5,ticks=nothing,border=nothing,framestyle=false,\n", - " clim=(-0.5,0.5)) #,ylim=(-3,3))\n", - "\n", - "# Plot the trajectory\n", - "zc = map(x -> x[1].c,states[1:end]) \n", - "plot!(real.(zc),imag.(zc),linestyle=:dash)\n", - "plt" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "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" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plt = plot(ylabel = \"\\$C_y\\$\", xlim = (0,Inf), ylim = (-3.5,3.5), \n", - " xlabel = \"Convective Time\")\n", - "plot!(Δt:Δt:tf, 2imag.(forces), linewidth = 1.5, linestyle = :solid, label = \"Vortex model\")\n", - "plot!(Δt:Δt:tf, 2fytheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")\n", - "plt" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "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" - ], - "text/html": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plt = plot(ylabel = \"\\$C_M\\$\", xlim = (0,Inf), ylim = (-1,1), \n", - " xlabel = \"Convective Time\")\n", - "plot!(plt,Δt:Δt:tf, 2moments, linewidth = 1.5, linestyle = :solid, label = \"Vortex model\")\n", - "plot!(plt,Δt:Δt:tf, 2momtheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "@webio": { - "lastCommId": null, - "lastKernelId": null - }, - "kernelspec": { - "display_name": "Julia 1.9.2", - "language": "julia", - "name": "julia-1.9" - }, - "language_info": { - "file_extension": ".jl", - "mimetype": "application/julia", - "name": "julia", - "version": "1.9.2" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/src/elements/plates/chebyshev.jl b/src/elements/plates/chebyshev.jl index f16be48..74ff523 100644 --- a/src/elements/plates/chebyshev.jl +++ b/src/elements/plates/chebyshev.jl @@ -7,24 +7,28 @@ import ..Utils: dz_partials, value, Dual, ComplexDual, Partials, valtype import Base: *, \ -struct Transform{T,I,D} - dct!::FFTW.r2rFFTWPlan{T,(3,),true,D} +struct Transform{T,I,FT} + dct!::FT #FFTW.r2rFFTWPlan{T,(3,),true,D} end function plan_transform!(x::Vector{T}) where T - Transform{T,true,1}(FFTW.plan_r2r!(x, FFTW.REDFT00)) + plan = FFTW.plan_r2r!(x, FFTW.REDFT00) + Transform{T,true,typeof(plan)}(plan) end function plan_transform(x::Vector{T}) where T - Transform{T,false,1}(FFTW.plan_r2r!(x, FFTW.REDFT00)) + plan = FFTW.plan_r2r!(x, FFTW.REDFT00) + Transform{T,false,typeof(plan)}(plan) end function plan_transform!(x::Array{T,2}) where T - Transform{T,true,2}(FFTW.plan_r2r!(x, FFTW.REDFT00,1)) + plan = FFTW.plan_r2r!(x, FFTW.REDFT00,1) + Transform{T,true,typeof(plan)}(plan) end function plan_transform(x::Array{T,2}) where T - Transform{T,false,2}(FFTW.plan_r2r!(x, FFTW.REDFT00,1)) + plan = FFTW.plan_r2r!(x, FFTW.REDFT00,1) + Transform{T,false,typeof(plan)}(plan) end (C::Transform{T,true} * x::Vector{T}) where T = transform!(x, C.dct!) From 3b60746d3e738dd7d56fbc5b6ae8b0e7f96351bd Mon Sep 17 00:00:00 2001 From: Jeff Eldredge Date: Tue, 29 Aug 2023 13:59:17 -0700 Subject: [PATCH 09/11] Modified the hybrid notebook --- binder/notebooks/Hybrid Model.ipynb | 1350 ++++++++++++++++++--------- 1 file changed, 932 insertions(+), 418 deletions(-) diff --git a/binder/notebooks/Hybrid Model.ipynb b/binder/notebooks/Hybrid Model.ipynb index bf7ed74..21d0ca2 100644 --- a/binder/notebooks/Hybrid Model.ipynb +++ b/binder/notebooks/Hybrid Model.ipynb @@ -4,22 +4,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Hybrid vortex sheet-point vortex model" + "# Hybrid vortex sheet-point vortex model\n", + "\n", + "This notebook implements the hybrid vortex sheet-point vortex model of Darakananda and Eldredge (JFM 2019)\n", + "and demonstrates it on several problems. The model allows a variety of vortex models (vortex sheet models, vortex element models, and variable-strength low-order vortex models), based on some tunable parameters.\n", + "\n", + "A few notes:\n", + "- this implements the model for a flat plate only\n", + "- it is set up in a reference frame in which the plate is in motion and quiescent flow at infinity. The plate is moving from left to right, so it is backwards from the typical perspective.\n", + "\n", + "There are pre-set kinematics below that can be chosen below." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mPrecompiling PotentialFlow [73af2aaf-3f58-5b29-82a9-435ecf827f5b]\n" - ] - } - ], + "outputs": [], "source": [ "using PotentialFlow" ] @@ -31,7 +32,7 @@ "outputs": [], "source": [ "using Plots\n", - "using ProgressMeter\n", + "using ProgressMeter # Not really necessary, but can be helpful in slower vortex sheet cases\n", "using SpecialFunctions\n", "using PotentialFlow.UnPack" ] @@ -40,7 +41,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Time Marching" + "## Define some functions that will be used" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Time Marching\n", + "This carries out the calculation of velocity for every element in the problem, including\n", + "vortex elements and the plate itself" ] }, { @@ -73,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -82,7 +92,7 @@ "counter_min (generic function with 1 method)" ] }, - "execution_count": 4, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -95,19 +105,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Comparison with Theodorsen " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Set up the Theodorsen solution" + "#### Set up the Theodorsen solution for comparison purposes, where appropriate" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -134,200 +137,250 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now set up the problem parameters and kinematic" + "## Now set up the problem kinematics\n", + "Choose one of the pre-set options to start" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "f* = 0.3183098861837907\n", + "f* = 1.536\n", "Δα = 5.0\n", "α(1/4) = 5.0\n", "A/c = 0.0\n", - "K = 1.0\n", - "χ = Inf\n" + "K = 4.825486315913922\n", + "χ = Inf\n", + "Char. time = 0.6510416666666666\n" ] } ], "source": [ "L = 1.0 # chord length\n", "\n", - "a = 0.5 #0.25 # location of pitch axis, a = 0.5 is leading edge\n", - "ϕ = -π/2 # phase lag of pitch to heave\n", - "A = 0.0 #0.0 # amplitude/chord\n", - "fstar = 1/π # fc/U\n", - "α₀ = 0 # mean angle of attack\n", - "Δα = 5π/180 #2π/180 # amplitude of pitching\n", - "\n", - "\n", - "#=\n", - "# Kinsey-Dumas case\n", - "a = 0.2 #0.2 # location of pitch axis, a = 0.5 is leading edge\n", - "ϕ = -π/2 # phase lag of pitch to heave\n", - "A = 1.0 #1.0 # amplitude/chord\n", - "fstar = 0.14 # fc/U\n", - "α₀ = 0π/180 # mean angle of attack\n", - "Δα = 60π/180 #20π/180 # amplitude of pitching\n", - "=#\n", - "\n", - "χ = Δα/atan(2π*A*fstar)\n", - "K = π*fstar # reduced frequency, K = πfc/U\n", - "println(\"f* = \",fstar)\n", - "println(\"Δα = \",Δα*180/π)\n", - "println(\"α(1/4) = \",abs(atan(2*K*A)-Δα)*180/π)\n", - "println(\"A/c = \",A)\n", - "println(\"K = \",K)\n", - "println(\"χ = \",χ)\n", - "\n", - "oscil = RigidBodyMotions.PitchHeave(1.0,a,K,ϕ,α₀,Δα,A);\n", - "motion = Plates.RigidBodyMotion(oscil);" + "probtype = :pitchheave\n", + "#probtype = :fixedangle\n", + "#probtype = :pitchup\n", + "\n", + "\n", + "phproblem = :yuanhang\n", + "#phproblem = :kdharvest\n", + "#phproblem = :kdpropulsion\n", + "\n", + "if probtype == :pitchheave\n", + " \n", + " if phproblem == :yuanhang\n", + " # Yuanhang UVa case\n", + " f_Hz = 2.4 # frequency in Hz\n", + " U_ms = 0.125 # free stream in m/s\n", + " c_m = 0.08 # chord length in m\n", + " a = 0.5 #0.25 # location of pitch axis, a = 0.5 is leading edge\n", + " ϕ = 0.0 # phase lag of pitch to heave\n", + " A = 0.0 #0.0 # heave amplitude/chord\n", + " fstar = f_Hz*c_m/U_ms # fc/U\n", + " α₀ = 0π/180 # mean angle of attack\n", + " Δα = 5π/180 #2π/180 # amplitude of pitching\n", + " elseif phproblem == :kdharvest\n", + " # Kinsey-Dumas case - energy harvesting case\n", + " a = 0.25 #0.2 # location of pitch axis, a = 0.5 is leading edge\n", + " ϕ = -π/2 # phase lag of pitch to heave\n", + " A = 1.0 #1.0 # heave amplitude/chord\n", + " fstar = 0.14 # fc/U\n", + " α₀ = 0π/180 # mean angle of attack\n", + " Δα = 60π/180 #20π/180 # amplitude of pitching\n", + " elseif phproblem == :kdpropulsion \n", + " # Kinsey-Dumas case - propulsion case\n", + " a = 0.25 #0.2 # location of pitch axis, a = 0.5 is leading edge\n", + " ϕ = -π/2 # phase lag of pitch to heave\n", + " A = 1.0 #1.0 # heave amplitude/chord\n", + " fstar = 0.14 # fc/U\n", + " α₀ = 0π/180 # mean angle of attack\n", + " Δα = 20π/180 #20π/180 # amplitude of pitching\n", + " end\n", + " \n", + " χ = Δα/atan(2π*A*fstar) # Feathering parameter\n", + " K = π*fstar # reduced frequency, K = πfc/U\n", + " Tchar = 1.0/fstar # characteristic time scale\n", + " \n", + " U₀ = 1.0\n", + " oscil = RigidBodyMotions.PitchHeave(U₀,a,K,ϕ,α₀,Δα,A);\n", + " motion = Plates.RigidBodyMotion(oscil);\n", + " α₀ = motion.kin.α(0.0)\n", + " \n", + " println(\"f* = \",fstar)\n", + " println(\"Δα = \",Δα*180/π)\n", + " println(\"α(1/4) = \",abs(atan(2*K*A)-Δα)*180/π)\n", + " println(\"A/c = \",A)\n", + " println(\"K = \",K)\n", + " println(\"χ = \",χ)\n", + " println(\"Char. time = \",Tchar)\n", + "\n", + " \n", + "elseif probtype == :pitchup\n", + " \n", + " K = 0.7\n", + " Δα = π/2\n", + " Tchar = 1.0/K # Characteristic time scale\n", + "\n", + " pitchup = let U₀ = 1, # Translation velocity\n", + " a = 0.5, # Pitching axis (leading edge)\n", + " K = 0.7, # Pitch rate\n", + " α₀ = 0.0, # Nominal starting angle\n", + " t₀ = 0.3, # Nominal starting time\n", + " Δα = π/2, # Total angle change\n", + " ramp = Plates.RigidBodyMotions.EldredgeRamp(11) # Smooth ramp function\n", + " \n", + " Plates.RigidBodyMotions.Pitchup(U₀, a, K, α₀, t₀, Δα, ramp)\n", + " end;\n", + " motion = Plates.RigidBodyMotion(pitchup);\n", + " α₀ = motion.kin.α(0.0);\n", + "\n", + " println(\"Char. time = \",Tchar)\n", + " \n", + "elseif probtype == :fixedangle\n", + "\n", + " α₀ = 45π/180 #ramp(0)\n", + " U₀ = 1.0\n", + " Tchar = 1.0; # Just a default value, not physically meaningful here\n", + " motion = Plates.RigidBodyMotion(U₀ + 0im, 0.0);\n", + "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Plot the effective angle of attack" + "#### Plot the effective angle of attack, just for checking" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 32, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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" ], "text/html": [ "\n", "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", + "\n", "\n", - " \n", + " \n", " \n", " \n", "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, - "execution_count": 7, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "t = 0:0.01:(4.0./fstar)\n", - "Vy = map(x -> imag(x[1]),motion.kin.(t))\n", - "αeff = atan.(-Vy)+motion.kin.α.(t)\n", - "plot(t,αeff*180/π,xlim=(0,Inf),ylim=(-30,30),legend=false,ylabel=\"Effective angle (deg)\",xlabel=\"Convective time\")" + "if (probtype != :fixedangle)\n", + " t = 0:0.01:(4.0./fstar)\n", + " Vy = map(x -> imag(x[1]),motion.kin.(t))\n", + " αeff = 0*atan.(-Vy)+motion.kin.α.(t)\n", + " plot(t,αeff*180/π,xlim=(0,Inf),ylim=(-Inf,Inf),legend=false,ylabel=\"Effective angle (deg)\",xlabel=\"Convective time\")\n", + "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Select the metaparameters for the hybrid vortex model\n", + "## Select the metaparameters for the hybrid vortex model\n", + "Read these notes first\n", "\n", "* $N$ is the number of plate control points\n", "\n", @@ -340,8 +393,8 @@ " - Setting this to a large positive value ($\\sim 10$) suppresses vortex shedding from that edge\n", "\n", "* $B_f$ sets the tolerance for force error in the hybrid model.\n", - " - Setting this to zero turns off variable-strength point vortices and generates a traditional vortex model. \n", - " - It is generally advisable to set this to around 0.05 or 0.1 \n", + " - Setting this to zero turns off variable-strength point vortices and generates a traditional vortex sheet model. \n", + " - It is generally advisable to set this to around 0.05 or 0.4\n", "\n", "* $T^*_{min}$ sets the minimum time interval between the release of a new active vortex from the tip of each vortex sheet.\n", " - Setting this to infinity (and setting $B_f$ to 0) generates a pure vortex sheet model.\n", @@ -353,46 +406,47 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ + "# Usually not much need to change the next three parameters\n", "N = 128 \n", - "\n", "Δt = 1e-2\n", - "δ = 0.05 #0.1 #0.01\n", + "δ = 0.05 #0.1 #0.01\n", "\n", - "lesp = 10 #0.1\n", + "# For the pitch-up case, set lesp to around 1 to 1.75\n", + "# For the fixed angle case, set lesp to 0 to 0.5\n", + "# For the pitch-heave case at low amplitude, set lesp to 10 to suppress LE shedding\n", + "lesp = 10.0 #10.0\n", "tesp = 0.0\n", "\n", - "Bf = 1e-1 #1e-1\n", - "Tmin = [Inf,2e-1]; #2e-1;\n", "\n", - "tf = 10;" + "# For the pitch-up case, set Bf to around 0.2 and Tmin to [0.2,0.2] or greater\n", + "# For the fixed angle case, any value is okay\n", + "# For the Yuanhang case, Bf should be 0.4 or so and Tmin = [0.05,0.05] to get an efficient vortex model\n", + "# For both Kinsey-Dumas cases, Bf should be 0.1 and Tmin = [0.1,0.1]\n", + "Bf = 0.4 #0.1\n", + "Tmin = [0.1,0.1]/2; #[0.1,0.1]; #2e-1;\n", + "\n", + "\n", + "tf = 6*Tchar;" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Run it!" + "### Run it!" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 34, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:00\u001b[39m\n" - ] - } - ], + "outputs": [], "source": [ - "plate = Plate(N, L, 0, motion.kin.α(0.0))\n", + "plate = Plate(N, L, 0, α₀)\n", "\n", "Plates.enforce_no_flow_through!(plate, motion, (), 0.0)\n", "\n", @@ -413,9 +467,11 @@ "T = Δt:Δt:tf\n", "\n", "# Set up Theodorsen solution results\n", - "theo = Theodorsen(oscil,L)\n", - "fytheo = map(x -> x[1], theo.(Δt:Δt:tf))\n", - "momtheo = map(x -> x[2], theo.(Δt:Δt:tf))\n", + "if probtype == :pitchheave\n", + " theo = Theodorsen(oscil,L)\n", + " fytheo = map(x -> x[1], theo.(Δt:Δt:tf))\n", + " momtheo = map(x -> x[2], theo.(Δt:Δt:tf))\n", + "end\n", "\n", "counter = [0, 0]\n", "\n", @@ -461,7 +517,7 @@ " \n", " # if we have waited long enough between active blob releases, and the sheet is sufficiently long,\n", " # then convert current active vortex into an inactive one, and release tip of sheet as new active vortex\n", - " if length(edge_sheet) > 2 && counter[i] > countermin[i]\n", + " if length(edge_sheet) > 2 && counter[i] >= countermin[i]\n", " sheettip_to_blob!(edge_blobs,edge_sheet)\n", " counter[i] = 0\n", " end\n", @@ -488,134 +544,168 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 35, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "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" ], "text/html": [ "\n", - "\n", + "\n", "\n", " \n", - " \n", + " \n", " \n", "\n", - "\n", + "\n", "\n", " \n", - " \n", + " \n", " \n", "\n", - "\n", + "\n", "\n", " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, - "execution_count": 14, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "plt = plot(states[end],color = cgrad(:RdBu,rev=true), ratio=1,legend=:none,markersize=3,markerstrokealpha=1,\n", - " markerstrokewidth=0.5,linewidth=1.5,ticks=nothing,border=nothing,framestyle=false,\n", - " clim=(-0.5,0.5)) #,ylim=(-3,3))\n", + "plt = plot(states[end],color = cgrad(:RdBu,rev=true), ratio=1,legend=:none,markersize=4,markerstrokealpha=1,\n", + " markerstrokewidth=0.5,linewidth=1.5,framestyle=false,\n", + " ylim=(-2,2),size=(800,200))\n", "\n", "# Plot the trajectory\n", "zc = map(x -> x[1].c,states[1:end]) \n", @@ -625,12 +715,12 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 36, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "image/svg+xml": [ "\n", "\n", @@ -645,47 +735,39 @@ " \n", " \n", "\n", - "\n", + "\n", "\n", " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\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/html": [ "\n", @@ -701,70 +783,64 @@ " \n", " \n", "\n", - "\n", + "\n", "\n", " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 15, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "plt = plot(ylabel = \"\\$C_y\\$\", xlim = (0,Inf), ylim = (-3.5,3.5), \n", - " xlabel = \"Convective Time\")\n", + "plt = plot(ylabel = \"\\$C_y\\$\", xlim = (0,Inf), ylim = (min(1.5*minimum(2imag.(forces[2:end])),0),max(1.5*maximum(2imag.(forces[2:end])),0)), \n", + " xlabel = \"Convective Time\",title=\"Lift force\")\n", "plot!(Δt:Δt:tf, 2imag.(forces), linewidth = 1.5, linestyle = :solid, label = \"Vortex model\")\n", - "plot!(Δt:Δt:tf, 2fytheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")\n", + "if (probtype == :pitchheave)\n", + " plot!(Δt:Δt:tf, 2fytheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")\n", + "end\n", "plt" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOydd3xUVfr/P2dmkpnJlPQeQkLovVdpqyBgWSyo2Fix4Nrw61dXbCzg17a2RVBX+K0ILrqIuooiSFEgVGnSa0hI722S6TPn98dJhmHqnWTuBHbO+8Uf4c6de888t3zO85znPIdQSsHhcDgcTrgi6egGcDgcDofTkXAh5PyXsHjx4gcffLC8vFzg/lVVVQ8++OB7770naqtcsFgsa9asefnll+fMmfPoo4+G8tRt5ty5c3PmzMnNzQ3K0cxm87Fjx/bs2VNbWyvwKx9//PGDDz5YWFgYlAY4YzKZ5syZ8+qrrwb9yL5pbGx89NFHv/766xCfl+MVyuF4olevXo6bhBASGxs7dOjQV199tampqaOb5plp06YBOHXqlMD9z58/D2DSpEmitsoZu90+efJkhz3j4uJCdur2cNNNN8XExNTV1bXzOHa7/b333ouLi2M3lVQqvfPOO6uqqvx+8bbbbgNw8ODBdjbAHZ1OB2DAgAFBP7JfbrnlltjY2Orq6tCfmuMO9wg5vhg+fPh111137bXXZmVl/f7776+88srIkSPr6+s7ul1BQKlUTpgwYeDAgSE74969ezdt2jRu3LjGxsba2tqampqQnbrN/Prrrz/88MOzzz4bExPTzkO98cYbzzzzTGRk5KuvvrpkyZLRo0evWbNm6tSpRqPR9xf79u07YcIEjUbTzgZcUSxYsKC+vv61117r6IZwAHCPkOMF5hH+9ttvji3Hjh1LSUkB8MILL3Rgw7wRqEcYelasWAHgrbfe6uiGBMC0adOkUmlZWVk7j1NQUCCXy9Vq9blz59gWq9U6adIkAO+99167m9lGOtAjpJSOHDlSrVY3NDR0yNk5zsg6UoQ5VxV9+/Z94YUX5s6d+9NPP73++usATpw4YTQaBw8ebLFYNm/efO7cubS0tDvuuIPtX1VVtWXLlpKSEo1GM2rUqP79+zsfzWq1HjlyRKVS9ezZs7Ky8ueff66srMzOzp46dapSqXTsZrfbDx8+rFQqe/fu7fz1qqqqwsLCjIyM5ORkH20+f/78oUOHiouLlUplenr6qFGjEhMT2UdssEqr1Xbr1g3AhQsX6urqunbtGh0d7XKQvLy8+vp6l49KS0t/+eWX8vLy6OjocePG9ejRw0czmpqazpw5c/ToUdbygwcPAkhLS0tNTWU7GI3GrVu3nj9/XiKR9O7de/z48TLZZc/myZMnDQbDoEGDbDYbM3VycvJdd93l+C07d+48deqUxWLJyMi45pprWJfFmTNnzuzatau6ujo1NfXaa69NS0vz0WBGYWHhzz//PGnSJPej+WbPnj2rV6+eOHEii2oCWLVqlclkeuSRR7p27cq2SKXSRYsWbd68efny5f/zP//j42js0vTu3dv5xrhw4cLBgweLi4sVCkVqauqoUaN83wmMioqKDRs21NbWdunSZcqUKe47sPsqPT09JSXl9OnTubm5jY2N9913X1JSEoCGhoY9e/YUFhbqdLr09PQ//OEPbLsLZrN58+bNZ86ciY6OZtGU/Pz82tranj17qlQqx2733nvvE0888a9//euxxx7z23KOuHS0EnOuUNw9Qkrpzz//DCA1NZX9l739Dxw40KVLF3Y7DRs2jH309ttvO7+2AEybNq22ttZxqIqKCgAjRoxYtWqVQqFw7JaVlXX48GHHbk1NTQD69+/v0ryPP/4YwN/+9jfHFheP0Gq1Pvzwwy53u0Qi2bp1K9vBZYzwnXfeAfDiiy+6nMhms2VkZMhksvLycrbFZDI98cQTzkJFCLn//vuNRqM3Y+7atcv90VuwYAH7dMuWLenp6c4f9ejRw9kIlNK+ffsC2Lt3r0NIBg4cyD5av359Zmamy8/85JNPHN+tqam5+eabnXeIjIxcuHCh3W731mDG22+/DeCDDz7wvZuD8+fPL1iwgHUsAPzzn/90fDRu3DgA69evd97fbrezIcPi4mIfh3UZI7TZbI8//jghxPkXEUJ+/PFH38377LPPoqKiHF/p3Lkzuy7OHuGHH34I4I033nC+eXbv3k0pffbZZyMiIpxPqlAo3P37c+fOOY+vSySS//u//7vnnnsA7Nmzx3nP/Px8AOPGjfPdbE4I4ELI8YxHIfzHP/4BoE+fPuy/TAgzMzP/+Mc/fvXVV7t37/7Pf/5DKf3oo48AJCcnr1q16ty5c7m5uddeey2AMWPGWK1W9l0mhImJiQqFYtGiRefPnz916tQzzzwDICUlpaamhu3WZiFctmwZgFGjRm3atKmwsPDkyZM//fTTQw89tH37draDixBWVFRERESkp6c7WsjYsGEDgOnTpzu2MD9s5MiR69atO3369JYtWyZOnAjggQce8GbM+vr6zZs3szTRxx9/fPPmzZs3b87Ly6OUHjlyRKFQyGSyhQsXnjhx4siRI08++SSAuLi4oqIixxGYEGZmZt5www1r1qzZvXv3t99+SynduHGjVCqVy+Xz588/fPjw6dOnN27c+Nhjjy1dupR90WAwDB48GMCtt966ZcuW06dPf/fddz179gTw97//3VuDGTfeeKP7PeBOXV3dypUrr7vuOiZO0dHR991337p16ywWi2Mf5jm5B66HDh0KYPPmzT6O7yKEn3/+OYChQ4f+9NNPFy9ePHXq1MaNGx999NFNmzb5OMivv/4qkUi0Wu3y5csvXrx48ODB2267jbnF7kKYmZmZmpq6ePHiHTt2fP/994WFhZTSWbNmPfXUU+vXrz9+/PjRo0eXLVvGui/sQjD0en337t0BPPzww0ePHr148eLy5cu1Wi07kYsQUkpTUlLkcrler/dlX474cCHkeMZdCIuKirKzswE8/fTTbAsTwuuuu87Zt2hubo6NjQWQm5vr2Gg0GtnOa9asYVuYEAKYN2+e83nvv/9+APPnz2f/bbMQMrn6/fffvf1A96zRm266yf2lzI7DBJ62+sTDhg0zm82OfSwWS79+/Qghvkco3333XQCLFy923siavWjRIueNDz74IIA5c+Y4tjAhHD9+vM1mcz4vuyLO72IXmFd3//33O2+sqKiIiYmJi4vz/Qpm6mUwGDx+ajQa161bd9999zHXXy6X33jjjStXrmxubnbZ0263SyQSAJWVlS4fXX/99QC++OILH81wEcIHHnjAo6j4ZtSoUQBWr17t2GKz2YYNG+ZRCCUSyZEjR/we8/fffyeEjB8/3rGFdQFvuOEG591Wr17NbnX3NrMs4kB/Cyfo8KxRji/eeOONOXPmPPLII1OmTOnZs2d+fn5mZua8efOc93nuueec41Tbtm2rq6sbO3bsNddc49gol8uZt/ftt986f1cqlT799NPOW5599ln33doAy3Lcs2eP8K/MmjULwMqVKx1bGhoa1q1bFx8fz+QKAHNH5s2b5xwlk8lkjzzyCKV048aNATWyubl506ZNUVFRTz31lPN2ZmEmb87bn3vuOaYojD179uTn5w8bNuyWW27xdgrW4Jdfftl5Y1JS0owZM2pra33Yx2q1VldXq9Vq58A14+jRo48++mhqaurNN9+8evXqUaNG/fOf/ywvL//hhx/uv/9+5/Ajw2g02u12AFqt1uUjdpmam5u9NcOdNlzZ8vLyPXv2dOrU6c4773RslEgk3sYmp06d6jKk7ZEBAwZkZWX99ttvji3r1q0D4HJL33nnnd5GZBMSEgCUlZUJ+BEcEeHJMhxf/Oc//3H8nZmZOXv27JdfftklQaBPnz7O/z116hQAFo5zZsiQIQBOnDjhvDE5Odklx6FPnz4RERHMtXIZBwqIWbNmLV++/M9//vPy5cunTJkyceLEcePGRUZG+vjKTTfdlJCQ8M033yxdupTlxaxZs0av1z/yyCOOLx4+fBjAxo0bnV9/AJh/WVBQEFAjz5w5Y7Vae/Xq5ZKhwxJzqqqqqqqqnK3tYuojR44AGDRokLfjWyyW48ePy2Syf/7zn+6n9t3g+vp6u93unjoE4OOPP/7kk08APPLII/Pnz3cZ4HRHLpcTQiilzc3Ncrnc+aPGxkYA7lrrg/vuu2/p0qXPPPPMypUrp06dOnHixPHjx7sc1oWTJ08C6NOnj1Qqdd7ubfKMS2YWw2g0Ll269Jtvvrl48WJFRQWTdoZer2fyf/bsWfevS6XSnj17lpaWuh+TxU6uiok0/91wIeT4YuvWrew9q1arXTIFHDjyMBksJd09m45tYZ+6bHRGIpEkJCSUlZXp9XrnFLtAGTly5I4dOxYtWvTrr78eOnTo9ddf12q1zz333Lx581wSMh1ERkbOnDlzyZIl33zzzezZs9HqHTJPkcHmUK5du9ZdpGNjYwNVbhb49Zh5mJyc3NDQ0NjY6PwpcyAcMBVxpJ6609jYyN7XbMTUvcHOb3MX2Lw9j77auHHjNmzYcPHixWXLlh06dOjuu+++6667fDRDIpFER0fX19fX1NQ4JtQzWH0Zl42+GTRo0K5duxYsWLB169YjR468+eabarX6mWeeeemll7x1dLzZ2aPl4WZnADabberUqdu2bevSpcutt97KxrYBfPDBB6WlpVarle1mMBjQ6rM6420WJnsc3B1lTojhQsjxhUajYZ1W4bCnurKy0mU7GxR0eeYdI4UObDZbdXW1TCZjXWwWCXR/XwsJpo0ePXrjxo06nW7nzp0///zzihUrXnnlFYlE8uKLL3r7yqxZs5YsWbJy5crZs2efP39+z549/fr1c/YbtFptSUnJ3r17fc+XEAgTG3cjAGC14jw6ZA7YpyUlJd52UKvVhBClUllVVeXiDPlFLpdrtdrGxkabzeby3ZkzZ86cOfPgwYOrVq364osvnnnmmWeffXbUqFEzZsy455573FUEQPfu3X/77bfi4mJHTimjuLiYfRpQ24YNG7Z+/fqmpqbdu3ezK7to0SK73e6tWJo3O3u0vEfWr1+/bdu2SZMm/fTTT84dqcWLFzvvFhsbW1ZWVlpa6kjuZXh0B9HaD/Cmx5yQwccIOUGGhe8OHDjgsn3//v0AWNKHg4qKCpd3xNGjRy0WS+/evZl3pVQqo6Oj3V9YLAArBI1GM3Xq1L///e+bNm0C4LvA45AhQ/r375+bm5uXl7dy5UpKKXMNHTD/ePfu3QLP7psePXpERETk5eXV1dU5bz9z5kxjY2NycrKLt+0Ca8yhQ4e87SCXy3v37t3c3Pz777+3oXl9+/a12+0s6uvOkCFDFi9eXFxcvG7duttuu23//v1PP/10RkbGTTfdtGrVKr1e77zz2LFjAWzbts1545kzZ0pKStLT03NyctrQPLVaPXny5HfffZcd1seVZffksWPHHK4bw4fpXGAGvP32251VsLS01KW2LRsR2L59u/PGmpoaNoXUnTNnzhBCXB4KTujhQsgJMuPHj09MTNy1a5dzmWaj0fj+++8DmDFjhvPOdrudbXfA5vPdfvvtji3Z2dlVVVVMRxn5+flffPGF72awaJgzLGHBZDL5/iJLsFy1atXq1atlMtnMmTOdP/3Tn/4E4M0333SvM2c2m/0e3IWoqKhp06YZDAYXx+KNN96Am63cGTlyZPfu3Q8dOrRmzRpv+7Acy5dfftlFA+DJRC6MHz8ewL59+3zsI5fLb7rppq+++qqkpGTp0qWDBg368ccfZ82alZ6e7pw6dM899xBCli9f7mw3dq3vvffegELK7s1mUVkfxk9KSho7dmxpaanzbWOz2VzuPR+wHolL4e+//vWvLtlMLIrucnssWrTIpVvAqK2tPX/+fN++fT360JyQ0nEJq5wrGo/zCF1g4UGTyeSynaVmJCQkLFu27Pjx4z///DPLIJ04caIj+585ecnJyUqlct68eUeOHDl48OCf//xnABkZGfX19Y6jvfnmmwCysrJWr169c+fOJUuWJCUlsWCaj+kT48aN++Mf/7hq1ao9e/acPn16/fr1LIHeMY3dW9Ht8vJyR2D2j3/8o/uvZj5iTk7Ohx9+uHPnzkOHDn3zzTfPPvtsUlLSiRMnfJjL4/SJkydPRkVFSaXSF1544dChQ3v37mVTuRMTE50LmzGnQafTuRzz119/jYiIiIiIeO6553Jzc48fP/79998/9NBDjjmCJpNpzJgxAEaOHLlq1ar9+/fv2bPnyy+/fPDBB2NiYny0llLKHF8f8yM9cvHixTfffLNbt27Lly933s76EEOHDl23bl1ubi4rp5Kenu638LTL9InJkyffeOONn3322a5du86cObNhwwY2W//555/3cZCdO3fKZDKVSrV48eJTp07l5ubeeOONrBCB+/QJ92nyx48fl0gkSqXygw8+OHHixJ49e2bPnq1Wqx0VZxx7srnzWVlZr7zyyrvvvjt58mStVjty5EgAe/fudT4mS42+MgsWhhtcCDmeaY8QUko/+ugjlyrJM2bMcH5fOCrLfPXVV85JMd27d3eRE5PJdOuttzp2IITMnTuXTdjyIYT33nuvy8iWTCZ78sknHfP/fKw+wSYUwmn6oDM2m+3VV191+XUSiWTUqFGlpaU+zOVRCCmlubm5LrHBAQMGuBjBmxBSSrdu3erydblcvmLFCscOTU1NjzzyiEuuU2Rk5NSpU320ljFo0CCtVus+NdAvdrvdpbUGg4FNEnXQu3fvY8eO+T2UixA+9NBDLldWKpXOmTPH433ozJo1a5yHqHNycljqrxAhpJQuXbrU2YYJCQmbNm1i0WnnG9tsNs+bN88xuDt8+PD9+/ez0gQuP/bWW28lhDiKr3I6EEL5CvUcTxQVFVkslvT0dB+J6Wyf7Oxsj6GtxsbG7du3l5SUqFSqUaNGuaQPVFZWJicnjxgxYu/evXV1dVu2bKmtrc3Ozp4wYYLH3L/9+/cfPnxYLpePGTOma9eujY2N1dXVcXFxjny80tLS5ubmrKwsx9uqvr7+wIEDpaWlZrM5IyNj8ODBzlkJFouloKBApVK5z/Gqq6tjg3aZmZneUkxZpkZBQUFkZGRKSsrAgQP9FuRsaGioqamJj493T4GxWq27du06e/asVCrt06fPsGHDnOcLAiguLjabzVlZWS7bHV/ft2/f2bNnbTZbWlra6NGj3dMUq6qqdu/eXVZWplKp0tPThwwZ4jsTh/H//t//e/jhh//1r38xR6f95OXl7d6922g0du/efezYsR5/jgvl5eU6nS4zM9NxKzY2Nu7fv7+0tNRkMqWnpw8aNEhgNdS6urrNmzfX1dVlZ2dPnDhRKpWyK5iRkeE4sst95Uxpaem+ffsqKyszMzMnTJigVCpLSkpMJpP7dbFYLOXl5Vqtlhm5Z8+e586dq62tddi8qqqqU6dOkydPZlMPOR0LF0JOx+AshB3dFo5XbDbbwIED7Xb7sWPHhIgWx53t27dPmDBh+PDhzqOtzz///Lvvvnv48OF+/fp1YNs4DH5nczgcr0il0rfffttoNG7evLmj23J18Le//e3FF1/Mzc0tLCw8cODA4sWLp0+fDuCll15y7KPT6TZs2DB37lyuglcIfB4hh8PxxZQpU/Ly8jq6FVcNOp3ujTfeYHm/jOjo6GXLljkvAKLRaLxNqOB0CDw0yukY9Hr9kiVL0tLS7rvvvo5uC4cTTPLy8g4dOsRqSmRlZY0bN84ltYpzpcGFkMPhcDhhDR8j5HA4HE5Yw4WQw+FwOGENF0IOh8PhhDVcCDkcDocT1nAh5HA4HE5Yw4WQw+FwOGHN1SqEBoPhrbfe6uhWcFzxseI5p0NgNYU7uhWcy+BX5ErjahXC6urqpUuXdnQrOJdBKTUYDB3dCs5lWCwWs9nc0a3gXIbBYLDZbB3dCs4lrlYh5HA4HA4nKHAh5HA4HE5Yw4WQw+FwOGENF0IOh8PhhDVcCDkcDocT1nAh5HA4HE5Yw4WQw+FwOGENF0IOh8PhhDVcCDkcDocT1sg6ugEcDodzpTN9+vTi4uJgHY1SSggJ1tHCB5lMtm7duqSkpOAfOehH5HA4nP8ytm3b9v3336vV6o5uSFgzY8aM6upqLoQcDofTMQwcODA6OrqjWxHWKJVKkY7Mxwg5HA6HE9ZwIeRwOBxOWMOFkMPhcDhhDRdCDofD4YQ1XAg5HA6HE9ZwIeRwOBzOlQWl1GKxhOx0IgohpbSurs7Hj7HZbEePHr1w4YLL9srKyoMHDzY3N4vXNg6Hw7lK+fTTT5csWeK8paqq6o477qivr/f73fz8/N27d4vWtAAYPnz45s2bvX26Y8eOIUOGhKwxYgnhbbfdFhcXFxcX98MPP3jcoaSkpE+fPrNmzZowYcLMmTPtdjvbvmTJkl69ej355JPZ2dlbt24VqXkcDodzldK5c+cFCxaYTCbHltWrV5eUlMTExPj97q+//vr222+L2bqrErGEcPbs2YcOHerdu7e3HV599dXRo0cfPnz45MmTBw8eZHpZWVk5b9687du37969+91333388ccppSK1kMPhcK5G/vCHP8TGxjr7GJ999tkDDzwAIDc3d+7cuU899dS2bdvYR2fPnv3www9zc3MffvjhTz/99Ouvvz5x4sS8efPefPNNtsOmTZueeuqpuXPn7t27F4DRaHzllVcKCgrYp59//vm6detcGvD666+fOHHipZdeeuCBB3bu3Gk2m99+++3Zs2d/8803jn3OnDkzb968OXPmrFmzxrGxsrLypZdeevDBBx3NY/z+++/PP//8nDlzvv/++6CYKFDEEsIbbrghOzvbxw5r1qx56KGHAKjV6jvvvJMZ67vvvhs4cGDfvn0B3HnnnSUlJb///rtILeRwOJw202hBnSkU/5rcBpcIIffdd99nn33G/nvo0KHz58/fcccdP/744+233z5o0KBhw4bNnDmTydKFCxcWLFjw7rvvTpo0KScnJysrKyYmZsiQIf369QOwZMmS559/fvz48SNGjLjzzjtzc3MVCkVMTMwdd9xhNpu3bdv2/PPPDx061KUBH3300ezZs3v27Dlo0KCpU6fOmjVLLpdfd911c+bMYXHXs2fPjho1KiEhYcqUKa+99tqCBQsAmM3msWPH6vX6W2+99f3338/Ly2NH27Jly/Tp03v16jVt2rSFCxf+4x//EO2ieaVjSqw1NjbW19c7lLJLly6sg1BYWNilSxe2MTIyMiMjo7CwcNCgQR4PYjKZtmzZ4vhv//79xahBx+FwOC5sK6MT11tDcy6ZBOfvkHVWX1ake/bs2a+//npZWVlqaupnn312++23a7Xat956a9GiRX/6058A2Gy2N95447bbbgNgNptXr16tUqkA5OXllZWVzZgxA4DVan355ZcPHDjQrVs3ACaT6YMPPhg7duwzzzyzbdu2xx57bMOGDStXrkxLS3Nv1f/+7//ecccdAP79739nZWU99dRTAHbv3r158+bRo0cvXrz47rvvfvbZZwFkZWWNGTPmpZde+u677zQazfvvvw/gmmuucRx2/vz577zzzu233w6gU6dOd91116OPPiqaOT3TMULIEmHkcjn7r0KhaGpqAqDX6x0bASiVSrbdHYPBoNPpXn/9dceWGTNm3HvvvSI2muMPSqnBYHAM93KuBMxmM6XUbDZ3dEP+qxiWSP45TmoNyZ0eJUMnletSFZ06dRo3bty//vWvuXPnfvnll19//TWAs2fPOhJMhg4deubMGfZ3Tk4OU0EXCgsLdTrdlClT2H8NBkNKSgoAQsgnn3zSuXPnP/3pT5MmTfLYqh49erA/EhISHH/Hx8fX1dWxlsycOZNtHDBggMViKSoqOnfu3MCBA9nG6OhohyN0/Pjx//mf/3n++ecB2Gy24uJibyNilNLm5madTufDXO4oFIqIiAjf+3SMECYmJkql0rq6uri4OAA1NTXsAiQnJzti02x7amqqxyMolcqEhIRffvklJO3lCIJSKpVKPT5ynI6CCaFz/5LTflQyzO7ewXPPHnjggddeey07O1uj0YwbNw5ATEyMI3G0vr7ekTvjLAOEEIfMxMTESCSSo0ePuj+zb7755rBhw3744Yfi4uKMjAz3s0skl36+Y0kpxx/OLWlqarJarTExMdHR0Q0NDY5vOf6OiYlZu3btiBEj/P5kQohKpdJoNH73DJSOuZYymWzAgAG7du1i/929ezcLQw8dOnTv3r3MpSgsLKyoqGCBbA6Hw+E4c+utt5aVlb3wwguzZ89mCjRlypSPP/7YZrPZ7fYPP/xw6tSp7t+Kj48vLS1l79i4uLixY8e+9tprTBrNZvP58+cB/Pjjj99///2PP/745JNP3n333VZrwEHg66+/fuXKlSyet3Tp0hEjRsTFxV177bWbN29mrg6TWMcPefPNN41GIwBK6enTp9tqkrYjlhD++OOPy5Ytq6ur27x587Jly8rLywGsWrVq8uTJbIenn376pZdeWr9+/dKlS3/66aeHH34YwB/+8IfExMQ///nPv/zyy4MPPnjPPfckJiaK1EIOh8O5elEoFHfdddeFCxfuv/9+toXNqcjJycnJyamtrXUeOXIwadKk+Pj4jIyMAQMGAPj8888PHjyYnZ09dOjQnJycjRs3FhUVPfTQQ19++WVcXNwLL7ygUCgWLlwYaNseeOCB0aNHd+/evU+fPv/+979XrFgBoFevXgsXLhwyZMiQIUM++eQTh5Pz2muvxcTEdOnSZfjw4ZmZmUuXLgUgkUj8xjODCBFpfsJ7773niFAD+Mtf/pKTk7Nr165du3b95S9/YRs///zzb775RqPRzJ0715GYVF5e/vrrr+fl5Y0YMeIvf/mLQqHwePyioqLRo0cXFRWJ0XhO26CU6vV6Hhq9ouCh0aAQExNz8eLFq2I9wsbGRrvdLmROoYPm5ua6urrk5OTgao/RaGxsbHTJYTQajXV1de5jXmazuby8PCkpyds7H0CfPn3Wrl3rY1ZemxFLCMWGC+EVCBfCKxAuhEHhKhLC/2LEE0Jea5TD4XA4YQ0XQg6Hw+GENVwIORwOhxPWcCHkcOSbVGgAACAASURBVDgcTljDhZDD4XA4YQ0XQg6Hw+GENR1TYo3D4XCuIuRy+cCBA53rirUHSqmjGhlHOMXFxSJNBOJCyOFwOH44fvx4oLWefWAwGCIjI6VSabAOGCYolUpv1afbCRdCDofD8UNiYmIQyz2yZXa4EF458DFCDofD4YQ1XAg5HA6HE9ZwIeRwOBxOWMOFkMPhcDhhDRdCDofD4YQ1XAg5HA6HE9ZwIeRwOBxOWMOFkMPhcDhhDRdCDofD4YQ1XAg5HA6HE9ZwIeRwOBxOWMOFkMPhcDhhDRdCDofD4YQ1XAg5HA6HE9ZwIeRwOBxOWMOFkMPhcDhhDRdCDofD4YQ1XAg5HA6HE9ZwIeRwOBxOWMOFkMPhcDhhDRdCDofD4YQ1XAg5HA6HE9ZwIeRwOBxOWMOFkMPhcDhhDRdCDofD4YQ1XAg5HA6HE9ZwIeRwOBxOWMOFkMPhcDhhDRdCDofD4YQ1XAg5HA6HE9ZwIeRwOBxOWMOFkMPhcDhhDRdCDofD4YQ1XAg5HA6HE9ZwIeRwOBxOWMOFkMPhcDhhDRdCDofD4YQ1XAg5HA6HE9ZwIeRwOBxOWMOFkMPhcDhhDRdCDofD4YQ1XAg5HA6HE9ZwIeRwOBxOWMOFkMPhcDhhDRdCDofD4YQ1XAg5HA6HE9ZwIeRwOBxOWMOFkMPhcDhhDRdCDofD4YQ1XAg5HA6HE9ZwIeRwOBxOWMOFkMPhcDhhDRdCDofD4YQ1XAg5HA6HE9ZwIeRwOBxOWCOuEOp0OrPZLOopOBwOh8NpD2IJYVVV1YQJE7KzsxMTE9966y33He699944J8aMGcO2jxw50rHxpptuEql5HA6Hw+EwZCId9+WXX05LS/vll18KCwuHDBkyadKkwYMHO+/wj3/8w2KxsL9vu+22sWPHsr8bGxu/+OKLESNGAJDJxGoeh8PhcDgMUZTGZrN98cUXv/76q0QiycrKuu222z7//HMXIVSr1eyPkpKS3Nzc5cuXOz7SaDSxsbFiNIzD4XA4HBdECY1WVFQ0NTX17NmT/bdHjx4XLlzwtvOKFSsmTJiQk5Pj2DJt2jSVSjV27Nh9+/b5OIvNZrvgBB+M5HA4HE4bEMUjbGhoABAVFcX+q1ar6+rqPO5JKV25cuWiRYscWz799NP+/ftTSt9///0bbrjh9OnTCQkJ7l80GAxVVVXXXnutY8ucOXMef/zxYP4MToBQSg0Gg91u7+iGcC5hNpsppbybeEVhMBjMZrNUKu3ohoQFCoUiIiLC9z6iCGFiYiKAhoYGFuGsr69PSkryuOe2bduqq6unT5/u2DJy5Ej2x8svv/zpp5/u3r375ptvdv+iUqlMSUnJz88Pfus5bYVSKpVKVSpVRzeEcwkmhHK5vKMbwrmEVCqVy+VcCK8cRAmNxsfHp6amHjx4kP334MGD/fr187jnp59+eu+99yqVSveP7Ha7yWTyq+QcDofD4bQHUTxCQsicOXNeeeWVzp07Hzt27Oeff37nnXcAXLx48Z577tm4cSPLlGloaPj222937tzp+GJ+fv7mzZtHjx5tt9s/+OCDiIiIa665RowWcjgcDofDEGt+wosvvmgwGKZPnx4fH7927drMzEwAUqk0OjqaEML2OXDgwO233z5o0CDHtyIiIjZt2rRkyRKpVDpkyJBff/1Vo9GI1EIOh8PhcAAQSmlHt6EtFBUVjR49uqioqKMbwrkEpVSv1/MxwisKPkZ4BaLX6/kY4RUFrzXK4XA4nLCGCyGHw+FwwhouhFcKjRYsPGQ/23BVRqqDyAUd/SbfXmno6HZcAZhssPA5mUClAfZwfyxAAf5QAPitiv5WFfy7gQvhlcJ7x2wLDtn6fmNddS6sX34PbLfdvtWW/qXlSG34vvwsdvT+2qpYYRm5ztrRbelICnR0/I/WlNWWhYdsHd2WjuSCjl673pr+peVYGD8UAFaft4/9wTpto7XWFOQjcyG8Imi04IMT9ikZpG8see9Y+ArhkVq6o5w+2UciI1h5NnztsL7IfqqeTkonh6rpzvLwffd9eNK+t5IOiCcfnrTrw7hLMGu77XANjZJiwaHwfSiKmums7bbBCaTBgr8eDHLHiAvhFcEnp+x1JvzfUOn93SRHaukFXZi++5aesKtkWDhYOq2TZM0FagtTM2DFWZoaha+vk0VH4v+dCdN3HwXW5tPJGWTpaGmNCWEbKSk3YHcFfba/9H/7S/9TYD9cE6ZPxU9F1Ebx2XjpnJ6Sf5y2lwc1UMyF8IpgQ5F9SAIZkkCmdyYE+E9BON7rFju+zLPPzJHEyjEzh5Tq6baycLRDhQEbiuz3dZVoIzAzR7I2394QloVC91bSi030zi6SMclkeCJZdjpMhXDdRbudYnpn8nRfiUKG1efD1A4/FdEuGtIjmvypu8Rqx46yYNqBC2HHY6PYX01HJxMAWRoyKIH8pyAc7/XjdbTZiknpBMCNmRJ1BL4LSztsKLJb7Li3qwTA3TkSvRW5YRkd/eqCXSHFzZ0lAG7IlBytpU2Wjm5TR/D9RXtXLekTS7QRGJpA9laG481gsuGXUvu0TgTAwDiikmFXRTDtwIWw4zleR5ssGJHYUnBnagbZV0VN4ZcccKCKAhiaSAAopBgcT8IzCnSohmoj0CeWABicQKQEh8LSDjvK6dgUoo0AgGEJxEZxsDrs7KC3Ymspnd655eUwMokcrKbm8Osf7iinTRZM6yQBIJNgZBLZyYXwvwzWxRuZ1HKvD4gnVjtO1YfdM7+/msbLka1pscPAeHK0loZh3vyhajownkgIAKhk6BFNDoWfAFjtOFlHB8a33AzDEgmA/eFnh+N11GTDmJRLQmi04ffw6xjtqrBLCSakttjhmhRytJbqghch4ELY8eytpElK5GhbrnG/WALgWF3Y3eu/VdJhia2FaIEB8URnQV5jeNnBTnGklg5JcJgBgxPCUQhP1VOjDYNahTBBgWwN2S/CBLIrnKO1FMCAuBY7jEqSoLXrHFYcr0NXLVG21sYekyyx2oNpBy6EHc++Sjoi8dKF6BZNFFKE24QhgxUn6+nQxEsCMDCOAAi32YRnG2iTBQ5PCMDgBFLUTMNtMjUTgP5xl+wwLDEchfBEHVVHIKs1TJIahc7qcBwmPFFH2WABY2QSIUAQ7wcuhB2MyYYzDZd5AFKC3rEk3ITwSC212DHUyQ59YkmEJOyiQGw4cLCTHdi9EW7DhEdqqUKKHtGX7DA8keTraJWxAxvVARytpX1jL4VJAAxLJOE2Vmqy4Xwj7RN7aYsmAhkqciZ4dbi4EHYweTpqp+gWfdnGfrHkWF0HNaiDOFF3WQgIgFyKnjEk3DzCQ9VUKUNPJwFg44XhFh09UkP7xBKZ0/uJecknwmzI4Fgt7RfnrIPoEY18HbWGU77MmQZqtaNv7GV26B6NIBak5ELYwZxroAC6aS+7xv3iSEkzrQl2GaErmfONVC5FJ/VldhgQR47UdFSLOobjdbTv5QKgjUAnFTkdZslTv9fSAZcLQFctAJwPpzHjcgOqjK4C0C2aWOwoaAojO7DeTx9XISRcCP97ONcIAN2iXYUQwPFwcobyGpGlJtLLzIAe0aRET43hNJPkgu5S2pSDLhqEVbGhaiMqDXDxhDJURC4Nr+QpNj7Sz7VDQACca+iYJnUIJ+pohATdo12FsNaE6iCFyrkQdjDnGmiiAjGRl23spgWAvHB6951vpKzL70y2BnaKi2HT+bVRFOhoF43r9hwtCSshzNdRADmX3w9SgmwNOd/YMU3qENgcqn4uHqGWIMw84+N16B5NIi4XK6aLwXIKuRB2MOcaqIs7CCBDRaQEBeH07strpO6eEJtTmK/riAZ1BEVN1GJHF42bR6gl5XqET9VpJoTZbnbI0YSXR5ivo5oIJCgu25ikRHQkzoWTHc420B5uL8nu0S0fBeUUXAg7mLONri4/gAgJ0lXkYlOHtKgDqDSg0dIS83GmVQjD5ZnP0wHwHBql4WSHCzoAyFK72qFrNAkrISzQeegNAOiqJefCaeHSwiaa7RYmyVKTSEnQOgRcCDsSvRWlzbSb24sPQJY6jDxCFudxF8KUKETJwkkAGikA99Ao8xHDRwPydTRJCXWE6/YcDWm0hNH6tAVNNMuTEHaLDqMQcaUBzVZ0dusVySTooiVngzRWyoWwIznfSGlrOpwLWRpSEDYeYZ6nMSEABOisJuETGs3XUbkU6Sq3kKCWoNVPCgcKdNSbJ4RwGh4r0NEstYft3bQoaKKW8JhBUdhMAWR6tkPQPGMuhB1JnhdPCECWGiXN4XKv5zVSKYHHzm+2Jow8wjwdOrulzgKIkyMmMowSR/ObvIUEgbARwnoz6s2eH4pu0cRqD5fnggXGPNohU42iZi6EVz9FzQBcJ88xsjTERoN2mYVTZUTo5y/mNSJTTSI93YzZGhL6B35fJe31tXVjcajPe6HRQ8ooo4u2A4bH/nnGPnG9tTG0ix/ZKC7qaLYnDyBLQ2SSUIeIrXZcv8H6xO5QrxLdIgCe7JCpImh9e4SMU/W03zfWL/NC3TdnqRLuoVEAGSpSa0JzMJLIuBB2JMXNVCF1zQpjsAtfENpo2Iqz9q5rLNeut4b4oS9soh5DHwC6aEitCaFcmXZvJb32J+vpejpnpy2I5e2FcEHnIXWWkaMhIQ6Nbiiij+6ybSujD+4I6e1Qqqdmu2ePMEKCFCUJsQC89rt9Uwn98KT9mb0hndDKpsx79IQyVABQHNpe8pO7bcfr6N2/2paeDKkWXmyi0ZGuE8wYnYJnBy6EHUlxMzJUxOObL0sDIKT1I47V0gd32DJU5EgtXXUupPd6iR7pUZ4FgGWLhTIq+MEJuyoC30+SFjfTVw+H7t3XaEGtyfOLD0CmGoWhnU/56C5b31iyaIj063z79xdDdz+wIWGPQgggQ4WSEArA+Ub6f7/b7u8mmdNTsvi4vUwfsjO3dILdU2cBpKsIAYpD2CH4T4F9ayn9+0jpNSnko9AKYYHOszuI1lhaUTByKbgQtmCjCP3610XNlHXu3OmkIlKCiyEUgG8K7BKCX26QjUoirxy0h2zxTwqUNNN0L3bIVBMgdBpgtWNjsf3GTpKbO0v+2FmyNj909mfv94woz5+mq4jeirpQRa1P1NHCJvpEb8mLAyWxcqwvDJ0dWicRev40XUVCKQA/FVGrHYuGSP7cW0KBjcWh04CCJhodiVi5h49YGCmUHuHKczRLQ57oI7mri+RUPQ1ibTO/XPSSOougesZcCAFg3n6bdqUl8V+WEA9HFTejk1uKICP0Uwm/LaDXpJBkJZ7tLylppiFb8qbGCKMNGV7skBZFAJSGqie+s4LWmXBjJgFwbRop0NGQ1bUpaQaANC92SI8CgFJ9iBrzczEFMDmDSAkmpkq2lIbuuShuBoHX+yE9CiWhMgKAX0ppVy3prCb940i6imwoCmWHwLM7yMhQkZAJoZ0it9x+bRqREtzcmRDg+4shFcLOXsZN0qMICdJYKRdCVBvx9+P2kUnETvH+8dD1+OwUpd49QgDpUaF78Z1toMdq6a1ZEgDjUiQE2FkeKgHQU7S+6N1JUkImCZ0dfiy0K6SYlC4BWpbD3lZ2RdiBdQhKQtUh+LnY3ieWsF4a6xCELFezVE/jFZBLPX+aoSIN5hAFb2wU28rsf0gjAAgwJYNsLrGHbNmHoiaa6UcIQ9SS43W01oRxKQRAJxUZnEBCFiqvN6PB7DU0KpciSRmcjEIuhFh1zm6yYclo6T1dJZ+esYcsZ7LCALPdc8ooIzWKhGxM4sdCCuDWLAIgQYGeMWRnRYjudfY8e/MApATJSlIaqmd+Uwkdn0rYVO7esSRREUIhbAZpFTx3WOg4NMNjBit2lNPrM1pacl06AbClJFRC2OzVCGi1Q2icoYPVtMGMa9NaGjM1g9SbsS9UkZJSPU310isCkKEKXWh0RzkFWoQQwNROZF8VNYSk4F+x90mEjE5B8oyvbiGcsdX2S/uCNhRYfsZ+TQrpHUP+t5+k2YrPQ5Unwq6fD48wNQplofKEDtXQTDVxqNE1KWR3BbWH5OTs5e5tjBAh9IxNNpyqp8MSW4xAgPGpku2hEsJSPY2TQynz/GlaFCGhChEfqKZGG65Na3k5dI8mmWryawg94zTvApAeQs/4l1JKgImtdhiXKgFwICRCaLWjyuirQ5ChIjVGhEaNtpfRzmriGKgbGEesdpwMybpgzBNIVfqyQ9gny0ikX+fbd1W063qcrqen6+msbhIAfWJJFw1p5wGF0yqEvjzCWhNMIclbPFJz2fJv1ySTWlOIFkEtbqZSghTv93paFAmNAJyqp1b7ZcX+r0km+TpaHpKaXiXNXgcIAciliFeEyCM83rJI8qUtQxPIsVAtClaq9y0AQKg848M1tGs0SWyd3ZSoQJKyxThiU26gdgofHYIMFShCNFy6q8LucAcB9I8jAI6G5H5gPWAfnnEnNU+WoXYA7fRaWErI6OSWyzwyieypDNED3zKb3vu7Ly0KFKFwCo02nG6gA+IvbbkmhQAIjSlKmpESddlStC6kqULkEbJnu79Th4CtBXoqJJ3fEj31NkDISI8iofGETtTRmMjLKr31jsX5RhqCRGIbRYXBawoxWj3j0AyPnayjvWMuezz7xpLQCCHr+aX69AgREjvUmlCmx4D4Sy3J0RKVDKHpGJX5s0MnFak3o/3zfa9qIaQEsNN2XY/9VVQbgZ7Rl4SwpJmGJvhe3EyVMsR7mk3PYJe/THx35EQdtdrh7BFma4gmIkQeYYneV8YQgLQoUmMMhWd8rJYqpJctktwrBgBOhcYOzR6qjDqTrkJpqDxCl9XAe8cQix0hWPGgwkCtdl8eoVKGOHkoPCGrHWcbaO+Yyzb2jSUn69r3xhEG6/769ggRkrHS0/UUQE+nDoGEoE8sORaSh6JMT2MiEeVlvADBixBczUIISAja2Un9rYoOSSCS1qs8Mil0nlBxc0v6rzdYQCAEHuGRWhYKu9QWAnSPJmdCMluI2cHHDiHzjI/V0T6xl5X6TFMRbQROi28Hqx0VBj8eYVoUCU0o7EQd7esihLEECMWwEPOEfAgAgAwVKRHfE8rTUbO95Yc76BNLGi2hmNXq1yNMD5VHyG7+ntGXbewfR0ITGi3T+zICgJQoAqD9gxdXvxC243KY7ThSeyk5AsDAeKKUYW9IhLDcZ1YYWoeIQzA8dqSGqiNcl8HrEU3OBGmJE9+U+JxDghBOJTxWi35xlxmBAD1iyGnxBaDCQG3U1xghgHQVKg0QO32/3IBqI1w8wh7RREpwsk7cUwMtLq9fO4TAEzpZRwG4h0YBnBDfDmV6KpMgSel1B5UMMZGh6B2erqcKqWvBo35xpNIQBPnxS5nBz0syRQkA5e22w9UthNL2CeHRWmqywVkIIyQYHE9+C0liWIUByd4zRAAkKBAhCZFH2D/uklvM6BFDCptET5LWW1Fv9hUKQ6t/IPYwYbURpXraL9a1Jb1iyKl6Uc8MtKZB+vaM06OIjaLcIK4dWDy87+UdAoUUXbQkBGOlQjzCdBUJwZjxyXpIyGUhQQB9YglBKPJlSvVIVnpYh8SZZCWpEF+KTtXT7tGuLWH9xePiO4V+PUL2Cm2/Ha5uIWynR8gyoZ2FEEDf2FB4AADKDTTFe48PgIQgRRmKqYTnGtArxvVu6xkNOw3aAtDeqDBQACm+Q4KqUHiELA7c200Ie8aQkmYqdvVtv3NI0GoHsaOC7O3Wx+1+6B1DQhIapTKJnw5ishJVxvZmyfnlZB3trCYuo1PRkchQkRCMnZfqaarPlwOAlKiWx0dUTte79gYA9IgGQrIell87xMohlwahdxjWQnimgWoi4FK+oXs0qTaKXtTRZEOdqSXA7YMQTCU0WFGmp13cqvn1iCFolQfxYF053y++ODkUUtE9QlZdz30VpF4xoK0pA+LBoky+PWP2RhD73Xe2kcbLPQTlesfgbAMVOzBb0izIE7LaUSvyE3qy3jVThtFVGwoBKNP7iQ8jJB6hyYZ8HXUZIASQGkUUUtEXRKw3w2D1YwcCJCtJ2I8Rol3JMucaaFeta7pKt2gAELuqbKWR0tYAtw9CUFwmv4lSTwLQTUskBGdEjgqy13qyTzsQICUEdtBBQjwUc2IZxWLny1QYqJR4XpDLQXKLEIraEK+rw+doickm+uBcqc/Z9IzkkHQIzjXQ7tEe7JClISFYHE2gHcSOk59rpDbqwSMkQJaG5ItsB+YD+PWMk5VBuBmuciFsn0d4rtHD6vDdtAQQPSRYrgf8eUIAUsUvqnKhEfC06k2UDJ1UoieOtnqEfnZLVqJS5Gc+X0fTooh7ictsDZGQFiuJR4UB8Qr49oQSlYSEQgg9LwXFughiV4GvMPgqrcAI1rCQD6qMaLZ6tkOWhpQbqKiTeSx2VBv9jI0BSFaSepELbrAJMx47BNka0T1Cv5MIGSlKUt7uXnL4CqHVjgId7ebm9XfREplE9ClT5QLGxgCkRpEak7iJgi0hQU/rwXaPFt0zrjCAAIkKP/d6koJUGkVtCPJ11OPSP3IpWwxW5AiBv8wpAJESxMpRaRSxJRQoaKIeV0VnKwCIvRZHpdF/ryhJAYjsEbKf6XHRgyw17FTcGRQV/srKMJKVoBD3fij0vjp8lpqIvVpqmb+yMoxkJU+WIWjz4tkXm6jZ3uL/ORMpQWc1OSuyB8C6MH5Do0kK2CmqxRwOuaCjmggkegrKdVYTsadMVRhovAIR/m7DJCUqRfaE8nVeF4PNVIsuABUGmuQzLspIEnlYqNIAvRdPKFNNJERcj5ACVQbqY84AIwQeIVsH1LMAaAiAAjHtwH6a3/shRXw7FDZTlcxzxD5bQ6qNQSjp4gNWS8S/RxiFSmN7CyNf9ULY5p9/rhHAZWVEHHTTiu4Rlhlahnl978b0qUrMzu8FHdwzZRid1KTCIG7spVyAJ4TW0Kh4VrDYUdzs2SMEkKkmhSKHBMsN/jOnIH6IuKBlUVwPLZFLkawUt0NQa4LZ7v9+YImConqETOe8hIiBVkOJhJAMMoRkzLhA55pL6IA9LOLaQU9VMmgi/OzGkqfauWrQVS6E7ag1yqTO3SME0D2aiB8SFOgJEQCiRgUvNFKPcVEAmSpQkcs4lev9zCFhJCqI2Y560TzjwiZqo949QhUKm8QtrFVpoH5DggCSFOJ6hCxOnuWlQ9BZTUQVQqbxgjxjke1wsYlqIxAT6eGjDBWJkIjbIWixg4CBcwRjLrkPCr0visseFlGHCSuNLS9A3wRlTv1VLoSEtDk0er6RaiM8323doonOIm7dBL+z6RnMIxTPCaDex8aAls5goZgT16qE3evsMok3HMLy37yHRonRJmJs1mCFzuJ/oBTie4QXvY8Jse2iJkxWGQEIuh9CYAeP7iAAKUGGStyESTYU4vd+SBY/eaqw2eviwOxhuSDu/UA9Dtm4wELE7XxdX+1C2HaP8Hwj7eopLorWayxy9EOQJ8ReClWieYSVBjRbvYZG2XqYYucFCPGEWKdBPCnKbwkJev60s8h2YAIv0A61JlhES54qaKJJSqi81DjO0qCoWcRVKgV6QghSfoQPLuqot94AgCw1RM0TqTTQKBnU/kKCcimiI0UMEeutqDJ47RXFyREdKbJHaPCcu+BCUKbThK8Q5vsYG1MBgKiJguV6QR5hrBwREhE7v63Zcd7sQEhr5pgYGKxoMAuyQ5LInnFBE42UeJ3P3uIZi/bua0mOEOYZU1HtoKNZ3gWgs5qYbCLOXWtNEhHiEYobGi3wHhKE+FMJKw2CbgYAKVEi2oENB/hYHb6zmoiaPCUwXBSUutvhK4RF3ms9szUCg7LwsTfKDdTv3AkABEhQiOgR+q7sJZciSSlih0C4JyT2WGlJM1KjvBY0yRR5Cl2lsMmUjn3Es0OB95AgxJ9KWCmgqgAjSdlSkkIM6s1oMPuyA5tKKN7qjJVGQSnEEHlOPRsT8eEZp4u8UGilgBRiAJoIRMna2zsMQAgppVu3bqWhWI1LKG0uul1vRpPF66K4sXKoI0RMEtFb0WQR5AmBTaETrdPnt9ZzppoUiewJCbFDggISImJotETvazHYODk0ESJ2CISU12EkiZwxX9TkayWQlqmEokXDKo0tF9ovyUpisomVPOVjEiEjPQp2KmLtw0qDoPgwRPaMW+eQeN0hLUrE9bAaLTDaBA2cA0hQkHZ6CwEI4W+//bZ58+bGxkYAmzZtOnr0aLvOHAzavB4hEzkfz3wnFSkS7RpXGSkgKPwNIFHZsr8YlDRTuRSJ3p86UWcOsEQvIQIgJYgXcy55SbOfOp+ZYkaBAgkJAqKFRhvMaLb6skMnNUFr50kMKgSHBEWtssZCQd6SRCD+umCVBkE3A4AkhYhzqwqbqcz7eAGAtKiW5cPEoErwgDGARAWq2/dyCEAIe/Xq1a9fv+bmZgCTJ0+urKxsz4mDQpunT7B7vZP3e72TSkQPgHVeBHZ2RC2qwgTARzsyVSgU2Q4C73VR55KXNPvyCAF0EnMNvEojjYmEe3U3d9j7USQ7sDCXj8WBtRFQyUT1hISHBEUMlftdHT5NdWk3Mag0CgoJAkhQkDpz24uK+KawCelRROZdItJVxEbF6o6wiyuwQ5DY7vEjL/lhntDpdDt37ly7dm1VVVWXLl2ysrKuu+66dp283bR5jNC/R6gmx4tEEwADAEFjIQASxcwUL/YrAGrSZEGtCXHy4J89wA6BWHbQWdBo8bMWYFoUEW8VOuGekDoCqnYPh3ijZS1An8X+01RERE/IiKEJAkNhAJgTIGj/gCjVQ0J8RexF9QgbzDDZhN4PiQrYKWqMQnuTAVHmr/A3+7Sk2X81uDbAbnKhYTNFe2d+ByCEtbW1CxcuTEpKstvt+/fvLyoqas+Jg0KbhbComUpJyxLwHumkIuUGu8Xuf857G6g2BXCNkxSk0QyTTZDHECglegyK9/XIkC0HCwAAIABJREFUsb5CqZ7GyYP/xqk2UnUEFMJ+V5KS/F4jkgD4yhhipEa1VIAUMoIVKAJn0zOSlGJFCFjmlO+XWqpSXI9Q4MA56zyJlERWqqeJPotdJCgQKUGpOBEC4VUF4OgQmKhA4QyIMr3nctsOWjsEonRHAgoXtX/8KIDXfL9+/Q4cOHDs2DGJRNLU1LRv3772nDgotGOMEKk+vf5Oathpy6sh6DCPMFFwp49CrGFCvyFB1lcQaQmkKqNQdxCtiYJiNIMN+Pv2CFOjCFsTQAyqjUgQbIeEdg+HeKN1dXg/dhDpZjDa0GAW6gnFK0Ag1uUo0/sxAgFSo8TyjCsFVxVA6zukSrRQue+C1+lirphdKawcPyNBQXQWGNtRDDIAjxDAtGnT2B8DBgzQarVtP22QkAC2Nimhj7kTjJYZFM1ey021hyojlUuh9TdhlsH6RFVGX4HctlFvRrPVrwAALcMhoniEAuPDABIVpN4Eqx0+ui9to8TfmBAcdjCI0vWuNmJEktCdExRiCUCpnsbKEeXzlZAWhZ/EGTJgXT2BnlCkBNpI8ToE/tcCTBNtfTThVQUAJMgBcULERhvqTH46BEkKyCRieQuVRqoVNnCO1uhatZFm+FvN2BttfKkkJCQMGzasbd8NIm0uul3U5CsrDCLPqReeFYbWPpEYMwf8DpSitfS7eB6hwBcfgAQFKNpbWtcjxc0A4PsREtUO1YLnjQFIkBORhLCk2U+vCEBqFNFZ0CTCmgMtYZJAOkai2YGm+3ufijdWKjyFGA6PUAQ7lOkp9dc7lBCkKEXzjIUVoWS0LE7QDjtcJoRNTU0zZsx49NFHv/zyy9LS0rYfNVRICGxtmtdYoqc+suPQ+loUaU59tUlopgxa+4ZidH6FhMKiZNBGiDVpt9qI+EBCghDJDs00Vg6lT0+I1cMTY3iswQyzPTA7iOQJlfkLhaHVMxbDGWJdnIDsIMZ4gdWOKqP/9dFSlWJ5hNXGljIaQoiXixUiZn0+vyuiiDenXmChUUb7x4wve/rVavXSpUv79etXUlKya9eumTNnjhkzBoDJZJLLRcgabDdtS5apM6HJ4mvuBAB1BGIiW4JmQafKEMA1jpcTiHOvlwjwCCHmsFC1kQYyNiaaHfSCPCGI4xEyVRPeMUpQkEaLKMlTJXpMTPXnCbXaobvbitbtJHA7iHI5Ko3URv2kzgJIU5E6EwxWP/2nNlBtotGRQnP0IiSIkYvSIfA7h4SRFkVEWrGu0uC1BKY7CZeWq2tjaNT1Mn7wwQd79uzJyclx3rh3797t27ffeeedPXr0aNtpRKJtQuh3vhQjXSVW3YQqo+cV4T0SI4dMghpT8O+2kuaWYX/fu6VGieIJGW1Cl1xgiDccUuqzrAxDIUWsXBQ7MGlPEJyUy575GhP17coHip2iXO//mE4eYZCvQosdAukYHasVL0ziZ7e01jFj4S9rgdQEkjkF0ULEAhfFTYvC9jJRhLDGFMDAeWK7e8mXdTzq6uri4uJcVBDA+PHj58+fv2PHjv3797f9VCLQtgn15cKucXqUaB5hIF4/AeLkonhC5QYaJ/fvWKRGkTIRRijb4AmhdYWa4FLqr6wMI1Upjh1MQCB2aM0LCHYzjDDb4X9sTDTPuMZEpQSxnpYA9EiiOKFRNilCgAAQAKUidJSrjTRe8M0A0ULEZXoaKfF/W6ZFkVpTu9I1vVFtpPGCo5AxckRI2mWHy4SwoqIiMTHR264PP/zwzz//3NQk8lrdgdC26ROsX+93GEAkj9BsR6M5sE5fvJyIkSQicFX0FKUoi3+2zqYXur9IGfMUqDQKWhJLJM+4jR2CYNuhVFgoLDoSUeIUl6k2Ik4ewDTNBAXRW6G3BrkZAXmEYgyPVRtbgh8CSRDHIyzVt6x36BuRav7pLDDZAnhJknYvTnCZEKalpR0/ftzH3o899tjq1avbfrZg07ai28wjFDIOXC5CJb1qI6WBCABEy48QuBagSImCgYbCWMZ8TbDtUG+CySYoPy01ipSLMkYICJ4vBcdwSLDtIDBMAtGm0AU0mRKiJU+V6anUZ1kZBnt7iFHrrtoUaGhUrKzRNAHztZLFqQLPHnPhHiGAxPbV3b5MCLVabWFhISur7ZG4uLja2tq2ny3YtG2MsFxPVTJo/E3jS48iVnvwK+kF6gmBeYQi3OsVwhKUnaYSBpNAPSGI0/ktF7zyQ2oUykTInq0yUoXU/yqsDkTyCIWvgJEWJUoWcaAhwfZnzHukzIAkJbwtyOUgTo4IiShlNgOaXItg1Jv2SJneV+EtByKtC9Y6XhBYxyhooVEA99133xNPPOFjrSWdTswlKQOkjUIoLCSY3lJdLPBm+aR1vlRg11iMsbFyvcCQIEHr4HkQCajQKCNe3lKdLoi0LAUlzBMyWFEX7AsRqCfE4ociCCEgdHFgUaqfVxsDyBiCiB0CpAgwAit6EnQBMNrQZAlUAAjLOwsufsvKMJLEWQakpiVcFMBX2pk05CqEN9xwg9lsnjlzZk1Njfve5eXlDQ0NbT9bsGnbGKFAAWAp9UGvm9CyBlMgRXLjFcEPCeqt0AlbE5HZKujDhNVGKpMgRnByBMQpqiLcE0pp6fwG3Q6BPfAsoyToTkCFgbKK3n5JFqcKfECTa3FZFnEwqRC2GCyAZOUVEhIEgh0qt9hRYxQUJxcpNFoduB0S2veS9DBd5dNPP62uru7du/f8+fNPnz7t2H7x4sUZM2bce++9Qo6bl5c3adKk+Pj4MWPGHDlyxH2HBQsWDG3lmmuucWzfu3fv8OHDExISbrjhhuLiYr+tF88jZHOJgp4vU9MWr58YbWgOal6AcAEQaQpdlRHxgSRHQJzQqPDFgZm3FPQSP4GGwsDsEGzHVGCcHECSgtSYgr/0T8AhQXGKqggvaJIkQocg0BRiiOMZVxkpFVbmTSFFdGTwPcJAEwgAxMtRa2rjGgzwKIRRUVEbNmyYM2fOO++806tXr/j4+MGDB/fu3btbt2633HLLqFGjhBz37rvvHjZsWGFh4YwZM2655RabzTXBtqCgYPz48Z988sknn3yyZMkSttFkMk2fPv2RRx4pKCjIycl54IEH/LS+rWOEqUJWA1cgQhL8GRTVRioJJE0crT2j4HZ+BWYMAYiVI1KE4ZBAQ4IQJ2mowkAjJYIWmWJV0IL/7rti7CBwBYwkJew0yG/eQLMEAbBZ56J4hIKXhRHBEwICFwC0xhKDRWVLmTdBOycrSdB7hzUmKpMgJhCPMF5BbBT15jae0XMBg4iIiEWLFl24cOHvf//7tGnT0tLSrr/++n379j3zzDNCDnr06NETJ0688sorKpVq7ty5Fotly5Yt7rtlZGQMGTJkyJAhgwYNYlt++OGH2NjYhx56SK1WL1y4cMeOHfn5+b5aTwLumZpsqDUJEgAJQWpU8GdQ1BgRGxmoJ9TyxSAi3CMkQKIIS/+0zRNib8wgwtYCFHI1ksRZDLY6kEmlDDE84wA8IQUQ7GGhNmROETZmHFQ7NFmgtwoaMIY4IeI22CG+tcBCEJsR0AoYSUpReslx8sBKNrR2CNrYEl9jAikpKXPnzm3DQU+fPt29e3elUgmAENK/f//Tp09ff/31LrstXbp02bJlXbt2nTdvHqvldurUqQEDBrBPY2NjO3XqdObMmezsbG8nkhAEWmq03EBpayakX8SYUx9oejQcVdaCGg1jMwGEDAMASBIhRbvaiB4xgdqBfdF/TWThCBwwBpCggJQE+Zm32lEX4KRSAIkKHKwOYisAoExPxyQLfPEFP0TchswpAPGKIM+vFZ5CDCBJSZqtaLIEkPHrlzbYgd08YvSSBT4XyUpyuj74QtiGmwFAjQnd2nTGYFfKAwDU1tZqNJeWL4qOjq6udn1w77777scff1yj0fzwww+TJk06cOBA7969hXyRYTAYSkpKin/4AbEZ5JbhABYsWCDEYc2vlQCRWhh1Ov+eRbI88nQDCW6ibGVTREwE0ekCeJEobQSQl9QbdNqgeUOF9TIJkcnNOp2Aoce4iIiyJqLT+RknpJQaDAa7XVACU41RoZFY/R7TGTWVAJGFtc3aNg8FuFHWHJkgpwIvR2ykvFRnCajNvqk2ETuVq6mgu9GBRiKrNsoE3pZms5lSajb7ihnZKGpNimiJoLtBZSeAvDCod2NxnRSIUNr0Ol0A2W8xssjKZgTxchTUSIBIjbDLEU2kQER+TVOWKuC70WAwmM1mqdS1qlNZo0xCZDKzTngWqASQSRRlOpOgJ1kYxfUyQKa0Net0/n9anCyiQi8J8ktSHxktQ4AvSQkQWVxv0Cldr51CoYiI8NNbEUUI4+LinAvQNDQ0xMfHu+wzefJk9kfPnj1zc3PXrl3717/+NS4urry83PcXGUqlMj09fejNNxc00cOBeIUNtXbA1iVOqRFQJLCT1raj0u6sze2nzmrtpCYaTQDx78xIAJYmKDSaoK3FV2e3JSjssdGCflqa2pZfQf3agVIqlUpVKkELJ9aaLanqCI0mgDBQRiwFrHqpSsi1E0ilyTowgQhsRnKUtc4qDajNvim2UcCaERPYlU3V2I02m1Sp8b12IIMJoe+i+RUG2KglM0au0fj3ArrIAVgaaTDvxqZyO2DrHB8V0JVNUtnyGv3flsLR1dgBW3a8oJdDZiwFrE2SttyNUqlULpe7C2Gj3RYbaY/RBvaLYiMtOhop5NoJpN5uU8rsabFqITuna+w1JptSpQniQqF1FmtXbYAvSVDAqidtvC2DvcgpAKBr167nzp0zmVrCFidPnuzWzZfDGhUVxXqs3bp1c5S2aWxsLC4u9v3FNowRtmYJCto5WUnqTEEelKo1CUrNcCY2ElIS7GGAQNZEDPrq8M1WmGyICzxJBO0YBnCHAlVGoenyAJIUQR4WqjUBQGwg8+cgwrAQC4UJTI6IjkSkRBQ7xAdqB3nLF4NFZSDFLsSoLlZjCmAhKgcJiiAX3Kg0BvBySFay5yiYDagJ/CXpCI22DVGEcPDgwV26dHnvvfdsNtuKFSssFgsbIPzll1/mz5/P9vnqq6/q6+vNZvO33367bt26G264AcDNN99cWlq6du1am8321ltvDR8+vGvXrr5aH3jWaLkBEgEllBgpStBg5wXUmGhAtQQBSAhig50XUG6gKcIGSgEkKQnLIwgWbZgvhdYXZRDffcLrqzGSgp001FY7sO8GrRmVgueQACAizKmvMdEICbSBpFKDza8Ndu+QCB6ia00aCuL525JBBiBOHnQ7BNA7TBZhTn1N4HbQRCBC0vZesihCCOCLL7747rvvtFrt+++///XXX8tkMgCVlZXHjh1jO3z00UedO3fWarULFy5csWLF6NGjAURFRX399dfz58/XarU7duxYsWKF77O0odZolYHGRkKgFx/06aKsckQbOn1Br7vdhgWgg9j5bVmFNUABYIlkQbSD8NRZRtCnjrV4QgE+86xD0MF2CGqEoMaI2ACzBAHEy4khqHW3KwyU1U4TAks2Dm7SUE3gmXQQwyM0CA0PoPUlGcQOYpMFRlvAL8l2ZhGLMkYIoHfv3vv27XPZeNddd911113s723btnn84sSJE0+dOiXwLG3wCKuMLVNxhcB8pvJ2rPfoQts8ALSsxBTkTp/wvKyk1snLWUEajmHPbaD3eoQEmohghkbZ0xuAR6ggdSZY7ELflX6paVNIMO5SiDg4t6XwOnOMJEXwBSBQI8ApRBwlC44dAuodRkgQKw+6J4T+cQF/K16Owx7qgLWdCgP6xQUwboKWvlRwrkLLHJLAX5LtySIWyyMMDW0osVYZyOrwKS3XOMBzeKemTR4A+0oQQ4ImGxotQucJwTGXPHidPhbJaUOHILgZ81UGikAKoCe2DIcEzzM2UnkgFbcZYniEShm0gpsR9BBxrSmwituMoIeIhddXYySLYYe2PBRBLsFYaRRaXQHBWBTXhba/JOVXXmg0NLShxFqVMRABUBLSOuUuKLShvhojLqgLULTUOxV8qyUFOy+gbR4hWvIjgtaMlmlbgXYIgtoxCjQpAI4QcRDHCANJjoAIc8lrjIgL3COMC3aHoNIYgEeI/9/em8fJVZX5w99TS1dVd/VeXb1nXyAIjBhIIEQICPzCsAwCorL+ABWj7/tBM+qoo44gyiC8ozNuqANGYAYRhRGRXWMyBCIBEiCQjWydpLeq3rtr6ao67x+n6qbS6a6+95zn3Eqn7/ev7upbdZ8+dc95tu/zPNSh8mQGg7J5k+EU2XTc/iQSaQuHpCBPddOtgxxzCtPdI7SsCC14hKL5FuHQGYlmsgI1OhSAeUXoJ66hjibAYK3PnECtn1gBMCtBGPLmMj1SIUHBK6F8HqyESQCEA2wkRTmiMpqQCw8ApCxiqx6h4gy8MRAPtoRhRLsOlijEAnUB2nXgkFsH3zHGGrUNVhVhhiOasDYLsKGUkiCn4AmxwVEkJWZtjAerDSwCHgS9lPyIaIJX+cxSlvJRQ0oa6o7xaitikLcbjVocwmeAljzVHbc2DoV84oFkSJDUIxzNoC9hzTOmbfraI50vECFionWwRCEWCJFy2nMMMgnS0LQNjVqsI+xJIJWx4PUDqA9QeoTCE5LzCEFXOWA1NwYg7GfdpAaBhCcEtTTA0bAUJ0ceaYgKciQRCMY86TpYmgUoTCiqdUikMTRquagU1CHiSBzc8gw8RBOg+hqEJpMIESuW0I1Bl/U5cXUB0sS5fLhIfkrPlFeElpZffMeWvP6GACPMEUbiXHTNtwrhN1BFw6yyBEHNmLc6jtxArR+9SflhK2NgiTkFoLIEPjdlOiQSlyEFIFtCRyWFtbox5LQFlRMgmFMSLEERIqYqoRNHucV1YKkM2azmqPWO2wKK/abHoNsilRrkIWLZcJHKOkxxRQikrRyKElNOGkpJPUIpUgAMXgCZ8ctLXCi3QlYMkw5b6ZHKCQGo9bGMwrCVMYgkrPf29VHOAuxJcIlcCEhDo7EUhlPWNgVtaLQn6wnJvLeWjkQmcTjoWIdqKSo16DzCSBzM4tdBHCKOo7pEMlwEWftsiitCi+UTXdZDgvUBNjRKNhQ3KkUTx+HQKJnRV2du9pCBOtIBFCohQRAavxY9QgB1fjJPaCSFeFo2ROxHD9EiRBKWNwXtMNgsScR6aBTZsiJKj7CI6yDNlqwhLSPpjnNBBDWPOj/rTSBFxGCQq6VBziCQyx9NfUVoZRd0W5mzJSBKCTuIhjEpeELZt5OgO25tw4Pa6IvGeY3Cs05i/HLhEVrsVBzyk3kA2WJKWbJMb5JmTLxI/Vp6Hsq98LvJngfpolKoEQXHoLvYHmE0wf1umGmkPgYlLlR4yULEEpOi6/zZ3UQCuZoiGAaB1DpMO0XoYta2HG0DIbmmusjZy3R7XmYYrOgPp45UBv1JebIMiNZB2LBWQ6OEQ3Gl6fIAav2gChFbLaYUCNGlhXKekMx7CRssROLczSyHBEHqGcsdDgBq6LqsSYRJcutA6C3I548cj3ByWGo0KkBbSx6NS+aEREtZqmhYt/W5l3V0z7og2kkrABCFiCVCYSD1jOX6qwkQhogV1kH95sBhg0ByHai+ju44anxwW5GClj0rMZfGAOEgDonJ4bTrIH1IChbxtFSEFjvLdMasxUVB2mNemPByBx/L1tQTiAGgc8QaSxC5kBHJs64WCiMjDQnuj9XnIeRHT4ImJinNEgTpIA6JujFkc8ZkIcEyDwJSbY9rfOgjyk51xSxbhz43yr1kmjgStzyXxgDhAIqumDXqLHK1FiRs6gxHb1Km9xbUehFPbUXotkiWiVgPCQpSCYkCELx/aaOPqpZcdHKy+qiFFBhZYyDo5nLkiIoSeFw0ez4ipYfq/CzDaTRQVGoYoUAN3dchQSEGaYi4JyG5CABqfIyDJkQsMfoHonKAiE3dm5TcFABq/YzKSo4mLK+DKEIlOST7kshwGeqsgPQ6TG1FKJEjtJoLKXGhykcTGhWBTTlyBOgIct0xzi0WU8JIA1AIIP4LOYOAZWvJ1aWw3GdOgDAdolI2oMILGAOJTYEse5YqXyAZHsBhElnR1iHkp9kUyNZWSb6XqsHC0ChiFmtpANT64WI0Zpl0ex0Bac94eilCueBD2E/TY166c4QAVd/tHDnC2rvEGUFi/KqQREDnGXeLRqNS6RCSPR+N86DXGk/dgApTfAwkKMQAQnSMeWm6PEj7bkswyCBCxEQeoVyfOYFaH3qTBD1u5BLGgmREEipXSRhDIVc6jRQhz869tHwXqh7zKuw40OXDs4XDFh+1Ci9KXLSekLRBQEYSsVovhZxHSLLnexLyi1BZAjcjWwcpRZjdUOqIxOVDoznylKoM0ocDVb9pMT5CxUoWZGxFSHQVEKBiEcuNqjYgzZ6d+orQ9MX9SYxmZL5jqqYqUYWQIOjy4XK5MYi0EMXB15PgHhcqrfcSFKAiDUnUS4GUMa/CEmRANdE6SFCIQVpCJ91eB3TsWblaGmT7TZPlC1TyJqAIEcvlC0AXKlc8JKXHtE1xRQikTWtCaQUQ9tO02eyRHT0hUONjIxRTxyKyMxGpGPM9CVSXyE+zrvXR8AIiUuSIkJ8xMkUorwBAtw7dMW41Tg7SpioqBoFK6Vg+5EKCAOoCbDiFEeXOU2IlJTpNC1C1YIzIrkOIqJBRur2OQI1siHiKK0LGOMz+21FZrz8cQDROwJiPqnlCVEafROGwABVjXiUkCErPWMYqKnGhooRsHaQ3PIjWYTSD/qTlODno6kqHRpHMyK9DVQncjMITyrbXkY4QqAqgmC+g6jwl0V7HEIAkXBSNczdTCRdJhoinuiIETJcS5jwhy3cJ+1maE1hbip4Q1SSmSBzVvuzSWQIVYz6q5gnV+NgQxWhGudAo6NZB1SP0EzwMormBnGcMCsa8CoUYgIuhqoQgVSmYn/KTH5QFUFwHql7E3XHud1uupQFdo4loApUlMqeTgLS3MLUVoVgubu6/FoQXCdaoCBypR0cjCi2UQBkFkrF8QZgGkNVAAlT8iO44t1pDIkCy57nwCGVzQiBiEYsiaDkFQBIijqqRI0BUQifRcFWAKkScG9kt+XaqHrzd1rsKGAIk0hhUbsEYtd7XJh/SIeKprQjdLgBmg5bSg4+z7UaV+TK9qp4QQGH0SU9FD/kZSVOV3qR8wSyI+BGxFEZSkpEokgEUg6MYzcizJZElDdFE5CSOHo8LVRSxWdFdQW7sjgAJizgqezhQhUZ7k4BCaLSqBC5GES6Sos4i52BQsJa4yuEgHSKe2oow6xGauzgi6/ULO1G9giKinBMCRT5c2iMM+UHSVCUal6+XApFn3G19DLcBEvasODIU12FQOUTcpdbmTd0giKh1mQARizgS52KkhlXQeYS8zCMjgIDIq6nrIYneWwLZdSDYF4qbApBqNDG1FaHokGvSR5GOTIaJBlCosONAFxqNyo6CIjF+RzMYGlXyhEiaiQgPQK61Yy0FY75XdgprvhhQfh5USHokIWLhCUmzJUHEnpU+HKpL4GI0nrHKpgDROkTjkm3eqMqKVPrtQaHRxPGgCM2SZeKSB1+ND14XgUfYI9tVXaDcixIXDWtUMvpBYfz2KIyeEKihoCdIFw6Ldw2NqtaxKNLEQRQqj2Tb68i8l6ScRpEtCaDGT+MJyR0OLiYmYCjeX9VKBhGLWHodxCOk/kUoMshEiHja5QgtskYlFQDLjmOVea+B0QwGR5XIMqCooR4cRSItrQAAZY9QsZcgiLqLqUTkainSIYosQRjroPZYRuK8ogReuTZvFL3ueuI8IDt6whBDJFxVINdWxhCAhDWqqAjVWcRphckPwqRTNAjSHP1JpU2RDRFPt9Co+MbMe4QSTXUF1BsICZ66igIARfRDunAYREzxHDtO3iDIesZqeig7g0nFIKBwSdVYxIBy3+3uuOVBVAZIQqNRtcQ5gBofeC7ULA3pxDkI10HNSlZnEUfjyHBJg6DKB6/yWJie7CGpug7TLzTqAmC2y5r0vEcAYeVa8l5lDwBAjfIAChU9RBIa7U1yqOXGxNsV9XFPQr5uN0tVV10HQDU3Bih7xiqbgiRE3JtQfRhIDIJonNfIeoQkdaU9Ca7yMIAiNBqVLaZEbiyMordAc0hKsamntiI07xEKuqOcJwTRWletfELdA4CssZMP6V6CAPxuBGXnXhrIrkPxPWOE/JJ1u1Qh4qAXPlmWIHIDHRUNgu64pFsMohBxNCE/jTYrhnKoXLTXUfEISbptSMdmBWp86E8qVTepJM5B0WVNuoglH3Is4qmtCM2zRnuTSHN5p1u9uxiVsaP8qCml6Gp9qpUDObak2rOu7BlH4vIPQ4hi9E9PQql4DkC5F17lEHFUgaNBEiJWZ0uqk4YU0xa1PtWRhMMpJNKoUnseanwsw5VmFCsfDqrWYa6oVOUzpmVoNEeWmXz1pTtuC9QpT1/LDSOU/wRQ1FArG30EnpBKw1UB9XSINHUWQA1FUxXFtjLIBaPUSUPS60DFIlbfFFCLVCseDiE/i6UwrNB3W505ZbxdxTDKHQ6Sb1evr1UcPSFQ45NZhONDEU5+pXTHbYE6P7ia8atOlwdQ42PCeJRGJM5F22g5qDPmFRuuCqiPZowodHISTVXUDQLFDQ/lUHk8jaFR+XWopWDMq6+Den2tonWovg49NFZykddBPUQsKNByhYwGanzoS1ob2I5ppAjVvP7s9DWFUsJonJe4ELTe1yYf6n23I3HU+uX1UMivyhSPqo2eEFD3jKNSoycMqDPme+I066DCj1D1hJQZ8yNq02gFKkvgUauvVV4H8SHS988pQmUFALXDIRrnQan2OgLqodGeBBdd1FVQ42OiDMMSprgiBGBOEea4KpI3EnUXKpwo9VAYKJqqSI9cMAQ4RjyhYbXRjCohQVCEiBVHcAgoeoSKobAaH1xMKUxCEgpjQFWJmgJQi9aodxfrUe63B4pcqWIPyJCfJTNvzciXAAAgAElEQVQYUOi73ZNAZUmW+SENuXWY4opQeIQmrlR81tXncRN5QqrRD0WSXsjP+tRypeo5ISjv+QG1GXigiAL1Eq0DgSKUXQePC1Vq/S1JQoKgMAik2+vguAqNqlqHUF4HxeQRZNfhuFCEpnKEXLD/5VCnPH2NyBPKfpT0JyiOggr5s/ODpNGjXDgM5UlMiqEwKLNnRbNs9XVQDBETrINaCZ30QJixYiivg3R7HVCQhtT7zAGo9oGp1VPKjao2UEuwDmSHpNXMxXRRhMqzAOFmSjlCImMn+1HSUDT6RPRGhSyu2HBVQNH4VSQFQDk0Kqxm9XWo9SvNKFYv2wqphcp7iNZB3TNWeRiqS+BW67vdk+B+N0oV+swh112siOtAkistlrcwtRWh+abb0iMXBFwMtWrtRqNxiu9YrYaaq/VUhLLxKxqukpBEoOAZK+bGkNNA0klKupDg4U+TQCSe7RktDUXy1DETGlWyDl0M1WoFviR5EyivQ1S2G7NANkSsVtBZrPzR1FaEFnKEas86gDq1dqM9CclxuPlQrKHuTyKlnBuDQhpAffSEgGLpmCKFGMpjSElqaUBgEPBqNW5CrVo5TZQiJAjlBgvSc2kMKLKISTwhqIXKUxn0KZNlcAyERkWIeJopQgAWPEKl/abSXCaexrDsPPR8KNZQU+TGxOdIvp2kcBjHRmgUCq457TpIGwQqxZQCtWr1GyQhQQA1PjaQlOdwEayD2igoEisZaoeDaK+jcjhUlij13RY1D+rr4HWh3DvNQqPMdGi0W9kjDPnl241GlTWQAZXoR67RqLLRJ73ZlDWQgOJoRsWuAjD6bqtpYhKyDNQ8wrqAkgCKIeKoWlLKgBhAoWIgSnchFlAkT6k0/DtCDL/K4SA/l0ZAmOnSVnJvAhmFLpj5qPEzq9NIprYiNJkj5BRs9XBA3iPsoeihJ6BSQ50j6cnf3edGuULfbZLREwJqnrFSVwEc9oyl1wGgeB4Uc4RR5aL+kJom7k2SPQzSYoj2OorF7LVq5TTqIzgEqqW6iwmoz0eD2iAO8fVRPQ9Wz6iprQhNTp/oT2I0o+QJAQj50JOQbO4uXAcS41fJ6ItxQDkdovCsk4yeEFDxjCMKw+cEQmqTmEQLD5XREwKKgxe64wgrekLZnLHk2yNxTvUwQHYdIsqeEJRDxIoslXwxJLqLCah7hMjW18pqYsJD0rqVPLUVoYsxmCDLRBXGkRuoC7A0l5z/SUWXh9oAigjFo6ay50nqpQRU+BGKLEHk+m4r5AhpQkBZ8pTsOkSVU1O1aoM4SIpKoeYZq1OIoRYiFt2DSTZFtVR3MQH1xDnUQsTiWCM6JC1byVNbEWbHME2mCUnIaSrNZUQorOjEsJ449yl0FRBQ6bvdm+AeteScAZUBFOosba8LFSXyodEeolAYE9EwqaNnOIVYSlUf16qNZuxNkOULIBsaVew5JaASIs6GBCnWQaUFI0kpi0p9bTZvQrIO1q3kqa0IBVlm0v84ojCN1oBKcxkqcgTUBlB0U3ATVJjiYvodwSqoDaDoViZHQKyDQv0GSUgQCiHibJxcmUEGBY9Q3SUVUAmNinVQDY0qhIhzyTklAQSqFTzj7jivLEGJmkIQrQflNCGJS5oVw4eehLUQ8dRWhCYH85Kw1VUGUPQkeJlHvq17PmoVnnXFrgICKmmAXuVptAakPWNO1AA95JcPEfcSFVBDihcgkKtlVL07ZBWAsOdInoeqEriZmkeoHBKELJs6Fy6iUAAKOeMoBXO11seSGQxK9d3uTXAXU51UKhDyszTPLqxJTG1FaLLFGolDpjKAIqrW4C0fuU56MntePTcGoNbP+pKSpCGSglkBac9YvauAQK1fqY6Qbh1kc2MUCeMSFyq8kk8jVTElADG7RzpHqNheB2p9twkJBCEFMnOEgrCj0nBDTCp1URyTIesR+2mhCKMUU9FDPjBpRUjhigmoEAVJyrZqfchwSQF6lCuXDUgbBOpdBQRqfZLsWU7XSQQKoVGydZBlEasX84wRQzZMotpeB2qkIao+c1Dr7aLYcVtApe92T0K1iMWABKl7aitCt7kWa5E4apVTUx4Xqn2SZBmqXAjUeAERitSUhLVlIEqpAAApg4AqFSHdTGRwFKMZsj0vHSImWwe12CxViFiapqHYaVpAJUdI1W8PQJUPHpdkT3wSK1ml73aUoh1/Voxp5xECMOMREjWwkG43ShJ/F5DOymQ4onFVUgAM41f2WaczCCQ9YxK6PICQj/VLtfUimcJ6WAw/G5QaQBGNc7fyNHAohIgJQ4JQ2JsRimdSMUQc8CCg3GcOAMuOzpZ5L1HeBJBN3PQQhs2yQ3IsvGWKK0KzOUIakl7IL0mWIfUIJRVAbxJpTmH0yT7rIotOZRDkRhLKhkYJRiBlp3lYRU82OacqgEBI1heJJLIj5pUFkGQRE4YEoVDVQ+IRQiFErN7fJx9yvV0SaQxQ7E2V2CzVCA45MaaHIiRKTdVJPWSc1NiRbrNJlxMSn2b5jYQ0cSiwZ7MNVwMEIUFIGQQkhWsGpMtbyRSAKm31GAiNUuxNlXWgOhwguw7iMVY/HCpL4JHtu03IICv1oNQzrUKjpj1CEgO8LiBDlqGiKRqo8ck4InQ5IUleQI/y8KN8ZMs6rbdBj8R5wIMy5UhUrWyXNZI+RwakbfDuGEExJRRYxD0JXkoUEgQQ8jPRNdQqSNiSyJbTyLyRUAFA1iOkyhdIx2ZTGQwkyaj1sL4Ox4UinOyyKAUhCkCdH5E4t7rlI6QHH2SJglQeoYS1JUBSsGVAKDMJMSJxhGhqtoBjwCOU5i5RhUmkWcSEiXPkPGOr6yDa69AUcUsTCOhCggBCPslNAbI+nzKNJqgmlRqwGiqf4ooQAJAu6BIOjCJJ5JDV+VkyY7mVXzYkSJkGkOkxn5vBRCCA3LMeJSWJAKgLyBw93XEozh4SqJVlLUUT2ZnmJJBueETlEUpr4miCLFGK3CFudR1IOm4L1MkSCHqIXFIB4ZjKGetUnrHEw0AbLoJ1g2CKK0ITHiHhdyzXXCZKWi8FWQVA2cFIKgqU84TU758TQ9L45UQ5IcmYZDTOK5UL1wwIwotVMTidHpLWxIQMMsgS97vpNkVdgA1I9d2mzhGyUevGevZwIJqJKM0gIyYNOazRfBAqALnmMtFiGzsCkTgPeonavMkl5LPd5emiYQGZplZUIUHp2GyUaPSEgJuh2nr7b5LBZALSrQdpQ6NZx9RipFrkmKk8Qlj3jAdHkUjT5sZkxOiOw8VojHU5+i4VW+dIMaabR1jw/40S5YEhy9AjmXh5hBgBRGSiH2RdXeT6bkdJyREAQj4mQZbpjqmOZTcQDrAuKY+Q0BMCUBewPPuGpOO2cXccCx6hFGkoQnf+5g4Ha++K0sWrBCTXIU7QXicrgNSYtlz+iECArBh+1pewUOZ7/CvCbrpHTUwx7bJ4+Ebi3Kvc4C0fdX6WyqDP6tkX54pTWPMEkPEACDVxVoyAZaNERI1IPCGIdZBk65DcPwuJ8laqGhIAIR9czLICEDVFhOtQWQKf27InJPZymGId5ELEJB1f85HzCK29qytOswgAav0skbbcd5vwgcyK4bNW5jvFFSEAe0OjEu1GCWcPCYSkHNNuIuosgLoA67FibQkQNlwVEE1VLPXdjsTB6QzwOr9lqwhiHUgNgpD1rqck48gFPC5UlVh+GoW1TrsOEt1fI3Huc6NcbUKngFyIOELuCUn13e6OkRF2ciQyq0QK7ncTFDUZsBoinuKK0ARZpifBvS6aZ73EhQrre76HlB4NWduTMCUT9oNbHzrTS1ovBak9T9VWRiAsxVqirRuDSIdY/C5oiUsS7c2idKMnDIT8EqxRMm9MLkRMOIJDIBsatf48UK2DnAA91Nah+DrMG0ZTWxG6zZFlQn4yh0xmz5PnhKQ8QqquAoYAXVbZs3SzqLJiBACLRw9tJEoiNDoqCoeJDSMJD0C8kUoHyDwMIK0pghRxnzBMLabaFp1AIAhx1skyNLU0kO35J+YiEMLqITm1FaEp1igpSS9sfc93x8lOHIFsaNRKUE70EqQKwYdl2bPEoVHrBQyEtTQA6gIslrLWzUQUDtMaRiE/E9+veUTivIyOuCTlEQIa1kEiREzFnGJSNfXRBBe8X0JYXQcORCja8QvUSsVmo0TtoA1YDZtNbUUozvVJyDJEhcMCEnue0NoyZIDF4ANhTghAOABY9Ah5NjdGI4BAziO0IAYhOQIGecqKAOQ0cVhPhyDbVYDOOrTO1iGsZDcg4aB3kRqpdX7LPf8icZrW5/kIB6ylrvsSZLU0kKWt0j6QAEJ+axwuuuzkkUin0//6r//61FNP1dTUfPWrXz377LPHXPDiiy8+/PDD27dvr62tvemmm6666irx+he+8IWDBw+KnxctWvQv//IvBe7idgGT5QijCZxYRfmsb4pYuJ7TNXgz4HOjwmvt6CHPCcGiRziQRCpDnCuV2HLZri5EBrjR73ROuWkBqIsp5cSg6iqQFSBXz2P+vxIF1NXUodHeBNLcQhlANM4JGZsSNGba/mpZMSwaBLRhEjET0WoFRU+C066D8LPNH5K6FOG999772GOP/fKXv3z77bcvueSSd999t6mpKf+Cp556asmSJZ/5zGf27Nlzyy23eL3eyy+/HMBzzz33yU9+cuHChQDq6uoK38Uca5TyWQ8H0B3j5vf8QBLJDHHZAKw3lxGGKpUY1T54XdY8Qh2ekKh8srrnq0rgIYqDSCQpybsr4HAtuYW3REjbm4l6nl4rU5ejCe4hrSkCEPazNEc0no1YTAohM6lHyF6PWA8Jkm4KIcbOfmvhAdCVLjDrUwFo5/MYsHRIalGEnPMf//jH999//+LFixcvXvyHP/zhwQcf/PrXv55/zQ9/+EPxw5lnnrl+/fpnnnlGKEIAK1asWLZsmZkbuRhDQUWY4YgmKCMwRrtRkxNNdYSAYJ0XILSFyQNiUjDrDL2sJiY1+kQvDEseYVeM8uDLC42a/UzaWVQCecR9s2J0x7CggrjhdXfcglEfjaOWtKYIObukK85Nhr5FT05Sg0DGI2wpI7aSwxYdU1oqNazXsYg+R/Tegt+Csa4lR9jb29vW1rZkyRLx65IlS7Zs2TLRxZzzt99+e/78+cYr3/72ty+//PJvf/vb/f39hW8kYusFRsCIcjeqnBCsVwsRNjMcI4YlPdRFyhIEEPYzS3mIHF2T6v5ZWE3Zdsc5lTUAqVFQtKMnBMTjbanHDSGFGLLrQLsIAMIWI/bkRmqdn4l8m3lEqdmSQoxBK11Pcx4hmQBWzXTawWQGLFU3afEIOzs7AVRVVYlfq6urxSvj4oc//GFXV9dnP/tZ8estt9wyd+5czvnPfvazJ5544m9/+1tJyTjOVywW6+zsPH3xh/CFV7/xzW/ds+nhz3/+85/+9KfHXLZ3gAG+II8NDlos/54A5XAD3r09Iw0uUx/Y1usGvKWZESoBBKrc3s0jrsHBQZPXHxzweF0eT3Jw0GI33olQU1LSMYzBwZH8FznnsVgskxnnP82uQ3p4cFCmQ/+EYnjHEaMAOoZ98yv44KD1MvgJUObxHRxIDA6mTF5/aMATcLvTMdPfnDmUun0H+scXI5lMcs6TycNffDyNgVF/hStpXuxJ7p5hgG9/78hgmdmHvGu4pMoLwi8CQFmGAb59PSODQVNi7OtxASWlGbrDgbk5vHsjQw2BSR7yWCyWTCbdbnd3zFfO0lRfRFYMuAHvnshQS6mpvXag3wN4fMkhqiOq2lOya5CZP53aesUXER8ctN6zfGJUub1dMdfg4KDf7/d6Jykk16IIKyoqAIyMjASDQQBDQ0OGUhyDhx566N577127dm1paal4ZfXq1eKHlStXtrS0rF+//vzzzz/6jYFAIBQKPfnE7z+0Dp//f/7fG1r+bzgcFrfLx/AQB1Iza0rLy2nMzxlJDqSGXYHyclPO9BDLAOmZNaXlQUr7t7E83dOWKS83y47oy6RD/kyF6esnF6As/VqEjxGAc+52u8vKyo6+PrsOtcEgRWeDw2IE02/3jBWjACLJ0XOC7vJyMiO8PpDqS7vLy82a0/2ZdDhgQWCzYpROKIZQhD7f4X+5d4gDqdZKn3mxC2OWmwOpIWZ2UwDoHU3NLmeEXwSAWV4Ao4MwK8ZwJLc3qQ6HqgyQHvGUTfqBbrfb5/ONwj2SHm2sIPsismJUZ4D0iHtyMQQGeTrozYSryZ7J5vL0q1ELp9NIHwdSrdUBqi9CoKk83ZPMlAXLzZBytYRG6+vrA4HArl27xK+7du2aOXPm0Zc99thj//RP//TCCy/Mmzfv6L/6/f5QKNTb2zvRXdxu9+yZMwFU19TOmTPnaC0I6rIBHA6Nmr2esMHbkWKwkRSGTduR3bFs4IhMgIA12qqYC0+rBQGEraQBLDEpTMIqUZA2JmnAUlpIBFFpQ8TMYg9eWraOQI0PHisl7fT5AhGjNr0O5BM6BaySuskLncMBROOFMlZjoINBBoPDZS4GpkURejyea6655kc/+hGA9vb23//+95/85CcBRCKRO+64I5FIAHjiiSduv/32Z5999sQTTzTeGI1G9+zZI35+9NFH29rali5dWkj6yVqsZevGKBnSjFnJx3THeamHsoeegNVKvi7S3BiAsJ/1J5E0HUvpjhEzZbJiBFiP6ayM2Jy0e95qsrabrnI5H2G/hTkY5JvC60K1z1o9ZYS6uBaCPOWzoIe6YtzNKPWxIE91mt6VUT2Jc6uHA3mhs6DvmufLRLURKWCaz6GroP473/nOG2+8MWvWrEWLFt16661Cn0UikTvvvDMejwP43ve+197efsoppzDGGGOCMtrV1fWhD32oqampoaHhS1/60iOPPNLS0lJI+sk6yxDO2RIocaHSSrtR8pELAuIU6zS958mNvjo/uBXSkA4PAEA4AG66pp6WOpsVwM/MfwvItvDQYRBYUwAgX4eAhXXoTyKRJi6gNsQwb5d0xbNl14R3hxWPUBuTzppH2BUjfhjqLWpiMZ+ngrSWBrmCEJMGoq46wubm5jfeeOPgwYPl5eUiZQjghBNOGB3NdoL629/+dvS7TjzxxEgk0tHR4fF4wuHwpHeZVBF2xXmNj2wauEC9lT1Pbm0J5Bl9pv63rphZTrk1AeJoHichOA50eAA4vOXQVDr5xdmQIOm5Ux9Al5W60u4YZVWrAREiNimGWId62ufBSoyaPGFxhBimjdTOGCWfHEBlCfxuCwIIO5J8Hcq98LstGOudMZxaU0wac0RDLQ1yDrrJsiK9Ldaam5sNLWgSLperqanJjBaEiYL6rhjxhgdQH0DHiIXyCX0KwKQ+TqTRnyTe8+LTzBsEXTE9HoDfwpbrHOHILR0V6gMsaXo2pOgISvtFCNQFsuWtZtAZ4+VelJLawBatQ4Cu0V0+6gIWZjV3xjjtwwAxq9n8ptC3DqarmzjQFeMNJuxI8whnTycLSWtNDwNMe8ZTu9eoiRwhvSNibc+TVnAbCFtJVQoTlWoqr0C9xWddk0doacvpOHcsCUA4I3qsGFbmgXRRe0LIecYmL9bkCcGiR6jDSrbqGXtcqKYmicAKeao3gWSGPExiLUSs45QGEPKBTRNFOOkYJh0pmYZSdFjIh9O3UAJQ4kKVz/T5m+2vRilAvRWPUMyFJy+ghjEHw5wY4twx2RLIJCytQ45CTCmAgKXslI5wvSXWUoS0820+REm7SQ6XnnWwECbRFBKEFQ6XjoRxZQl8bktWspZwkTAyTBoEU1sRsskUYWeMmC0JoD7A+hKmBqMnMxigjknmi2Hy4NOREyrzIOg1+6yLufCErSsMVHgR8Jh1ArpiqCMlR8BIUppl6wDUSUqBsBUxOvXkC8yzlmhngORDkKfMtDWJp9Gf1LEO1ui7mg4H8xFaobYbSinFYFZisxCntAbrEFaid1NbERb2CNMcvUkNHmEA3NyhI9pzEzbxy0fYX+SIXIPphyzbcVvPOtSZ5m2SU2dh2SPU0koKFruL6chbh60krSNxLubHkiNHIpv8yi494VlL80ppZ4Dkw3ybzS49xKX6gFmzTISLdDDIYIXPMbUVIQAGZPj4/2okjgwn9vqRO/s6THT16shaW8QCGGKY9Qhj2eupBTD7kGUrl3V5xmb3vA5yRK0fXpfpJCV1AZ8B4ema0UOCHEG+DpbSQrStz/NRZ5o8pcMTAhD2s7jpIcnktFUD9QE2bG5kdHYdyHOlpkPE3XHOqSlsBhpKWcd08AgBuF0TtjDQxNIWis3M16zv4EP2UTPrEfrdKKfu6mI+7KCpc4RA2G8+N0Z//opBHObXgXz2kIDHZXb6Gu0UVgOWZhRHElrIEbBSwZbtNK3JMzZnIGpqM4TcGWWGyiC6Cpifn2US5pvy60ucA6g3fUhOeUXomjg02qknFSE2m5mHTHwHmoydetP0BE2pCPMPWTd1L6t8hE1nZbpiXEee0rxB0B1HLfU4cgMm16FLQ1cBWAwRd8e0UEaR82zaTURrxKNLnpqqN11CJ7p/adoUDaajVp0aEuewEhrV6i00BFh/EjETrSinviJkE5ZPtI9wAI0a9jwzt+c79MQkBcw3VenQEAoDUB9g0QRSZjRxnNP298mHyaxMLIX+JH0ICFZis5raDBlimIlUayKqBL0o9Zj1hLq1rUPQi6DXpCcEaFgH8+3NogktiRuBBtPGuo4aEgDhAIulTIWIs3E7Xd4CYK666bhQhBP8m8IwbKROA5S4UO0zdeh0xrigNepAvWleQPsI/SIIATLcFEGjM4aQn7i/jwGRlZm0lrw9xgE0asjXWvEIdYUEATSWsnYTYmjyhGCFMKmpqFSgIcDMeEJdcfquArDS4UHUkOjyjEsZcoZ4YZB3IRaoNx0izsWoNXrGZrbn8a0IebmXfuIBTJ99nTHUa9BAAubbjXaM8AYNz3ouV2rGINDlFiOn29on23LicNThEZqn7+ojiQBoLJ18EZCzDslJIjCdtBZTUzQxp2C6zFcTUUWEGc1oYq0KoNYHj8uksa5lbwrL24xl1hXjXj1dBWAljTX1FeHEOcJDejwhAA0BszlCTQlCmK5gS3N0x6FDEZpPC2ldB5NbLhsn1+ERlrKRFAZNMfQ0rkNDgA2NTi5GR4yXuDR1tzHFj9DXaFSgMcBM5gh1fBceF0J+UxZJtr2OnufBxcy2g9dRaQ3T5imycXItXQVghdg45RWh21UoR2imF7ME6ktNe4TaLF+TVRzdcaS5Fg/ACmlIiysmILbcoeFJxBCaUlOIGCY842QGvQktX4SAWIdJnYBDI9kktw4BzBx85FMAx8CkR3hoWJeV3BgwRdnX6hHC3DqMpDA0quWMMs/W0cHlNlDnZy5mKkQ85RVhAY+wPabTIzSXI9ThigkEvajw4tDkIUEOOB4hOka416WlhMOkRdIZ01gvBSuesQ63GEBjKbrjk5OnxOmsqbgWQEOA9SUQn6zxU3tMl5Vs0iCIJKCjbsFAQ2DyZ/KQtsOh2ge/O5uYL4wuPS6pgNjyDllG155vKmUDk4WhRjOIxjV6hAAaS9mhyZ71Dm2ekMkua8ParE6BCi+C3smPnvYR1AeYjtIFcZ5Ouuf1JSkFTAajNDGnADSWsjSfPFafWwcdIgBAQyn4ZA56LIXehDYrudRkbBa12hhkEKShyawicXo0aVgHZnodtHqEAOrNkaeOW0U4OIqhUV3PuhjCV9gb09oxQaDJhO3Zrs3ogzlNrLWY0hBj0i3XHtPnCTEAh4YnuawzW0ujRQaYLqHr0LcOAZgTAExbTRGARhPrIKwWXR5hIOv9F0bHiEarCEBD6eRiiIRCk7mRopYFMB020+cRwnS585RXhGyC0KjQUpqedWFDHSx49um2fAE0lU2uh/SxBAE0l06enOvQKYBAY2Byg0BfTqjGXBRIH1vHECPgmSQtNJpBJK7FA4ARmzWhiUN+eLUdPGaaqgirRd86JDOITlZBcUgbg0GgPsBGJxPj4AgANGtbh0kD9SMp9CeztosmmOyyNuUVodvFxs1KaCoiFGgWBI2Ch6+mvjb5MKMAOmO8qkRLg2MATaXs4GQHn45piGNgxiPUl69lwjOezCPsime78msRAgBQPxlhsiPGM1xfeAAwV8eiNV9ghqahr6gUptehK840502AyULEHSO81KOl5x/M5Up1J4wBLKxkZuLPU14RuoD0eJpQU1sZgaayyT1CG0KCTWVsJIW+grXkHTGN3lhTqRm2DqAzFAYTW07UkOjzxhpNrENnjFf74NNjkWTFmMww6tBpHYoUrJlQudaDLxyAm03iEWq1krOauKAXwoEOzetQb0KMQyO63GIADQEWjU8yG1LrFyHwzx90bfno5H0Tpr4inKDFmtYlLvOgqmSSs69dT1v3fDSZcEw1VdMLNJcxwTsogM4YXExj3RiAxlI2MFqo135XDGmu8btoMuGS6vaEYIKecEhneNZrroSuQ2dNEQA3Q51/kgjtoRHuc+tibJrxCPuSLJHWGxIUh8PBgpkLreHZRhOsJa3uigCDqXjYcaEIJ8gR6vP6YSIqeGCY1/p09VcTMEPT0FdDAnOauDPGRZ8LfZj06NGdnzPjEXborKUxxDDnCWkTIDB5WkirZZYVYzKDQFBnNe0KM7nSzjigOSTYXMoYcKDg4XBoJBvc0gEz66CVwWAJx60i3D+EGUGN69tcNom1dXAYzdoeMgEzxP12nedOljRUeM9r9gAMMQocwfqq6Q0B+pIYKdjkXmu/PYHGAIvGkZi4hK4jxt1M49fRVDaJJzQ4iuGU9oOvpYy1Fdyb7SNcnxdS6kHFZI2/O2MMmsNFAQ9q/Si8Dod0rkO28XfheJW2PkdWcdwqwj2DfHa5xvs2TVY5cGCYt+jhJefLgIIeYV8SQ6No0aaPs2UkBTeb1mp6gUk9wrYhjhzFSQeaTETDtHZXEGguAwcOTuK0LVEAACAASURBVCzGoRHU6axdm7S9mb72DvloDWa/8Ymg1ROCCZc0V92rTwQAaC1jBybemyKboNMjBCbr8NCurc+RVUx9RYjxc4R7Bvnscr0eYfsIn6iWH8DBYa7bIxSx3wJBOXEctAZ1CSDiS4UNgoM6E/IC4vMLRIHahrnXpdEjzMaoJ14HMQRKt2csQiD7hya84NAw16wA0BkrtCk69CfOAbSWsWiikIOu1SOECfZWZ5xBf0iwpYwV2BTZIkJtyjjsZx7XJGEzfT1PrGLqK8LxPMKBUUQT0KoIm0rZaGbCIUTJDLriGl2xfDEK2J5twwDQqk0Mvxs1vkIuSIbjkH7PuKoElSXYP7ETsH8ILWVa2soITOoRCsqAbk9oRhmAQuuwbwgzNHtColRxIthAlwfQWgZgwqhgLIWehF6PcFICgahbqNAwGCcfLWUo4BEKX02fkepxoTHA2gozGLT1ObKKKa8I3eMpwj2DHMBsbZ4QclHBieydQ8M8w6FbAQBoKi2kh8RZ0KpTjKayQiV03XEkM9pzpQBmBNm+iT2h/UNc6yJM6hEe1E8TB9AaZKygR7h/iM/UmS9onIw8pbvPnEBrkAFom2Ad9uvfFK1BHBgu1NWlI85sUAAtZSwan3A+u26PECZi1O368wUmMeUV4bgeYVYR6vQIhbc3kRLS2rIhH4UVQNsQ97j0RmAKlxIKg9QGg2BmsJAn1DaslzkluroUMUYt4HejLjChJ9SbwMCoXo9QxB4KfBEdMe51oVYzOaKloEco9stMnc9DaxlLpAv1o++Mod4/ed8vRbQUzBm3DYNBb9SqtayQR5jKIBJ3PEIiTKAIAc2KcFaQGTc6GjYqANY+wieqWm0bRnOpqcYK0mguGAXKrYM9BsH4Gz7DcWCYz9CshFrKWAFXTBwHdqzDxIRJ4QlpXYdskrJAsnYIzWXayREiDD7REbxvkAOYqXMdsrHZiQ2CzjizoWYg6xlPsA57Bnk4gFKd9V2tZWib2DMW6WQnR0iDcQvq9wzyqhJdU48FQn6Ue7F3cPxv+YBdB9+scmT4hDZ425D2/FxrEAU0sW3rMKOM9STGnwfSPsJHMxoTpQIzg5hIEwM4MMwrS7TnhADMCE6oj4UC0OoZhwPwuwspgP3DfIZ+67DEhbB/QjH2DXGvS2+4PqeBJlyHgyN6Y5ICLaUAJkwT7tVMJwTQGmSx1IT9Ttttoc6axNRXhEDmKJtDN2VUYFY5m8gjPDjMg16N5fwGRIRnouho23B2T+rDrCDL8AkPnQPDvMQFrd3lBYSBP65BkGUMaV6HmRO7pEIG3ZpYYMbEIWLhqGkNCTKgNcgKeIS6q3sNtAYn9Iz3DqG5TG+YZEbBJGV/EgOjTGuSUkAYoBMRR/cOYZZuRVgwRn0gm6R0QqMUmCg0aociDLK9E7lidh18QgGMewRz4IB+A3xmOQOwd2JN3KI/FIaClQNicbSGwoQAHSMTFrPvH+K6E4QCrWVscHT89rP7Brnfrd0omVE2oSZO2xKjFmgtYxPpoX1DfJZmGWp9KPMUSFJyALplgKip943vEWY49g1xrXRCHGYtTeSSAtCujE3ieFCE6SPXeTSD9wf4vArtt55dnmXlHI2Dw7xZv8UHoKWMudn4EdruGOJp7WFJsZ8nChHbtg4FDALdNSSGAHxi4/fgMLchPowcH2ciz3hGULtRUiA22zHCRzN2xMmR422O+6d9g3rdYoECOWPxlNrjGc8sZ+PuzfYRnkjb4BEWSlLuG+JBL2p1JrDM43hQhGM8wq29PJ7GaSHtz9nsctafHL/l9PuDfI4tlo7IdowbGs3WTug2+sqYx4WJPOMDwzYdfI2lrMQ1gSIc4hX6w9QFYtSiqNSm0GhZIc/YBm9sRjCblD0a4kC0SQEEmSgmHoPRDA6NcN3hAYjKgYK0VRtCowDmVbBdA+O8vscWbywcgM894TrstcUiMYnjUBG+HuEAPqRfEc4qBzCOU9ifRFcM8yps+o5nBsd3yLKGp+bz1+NCcynbN16uVFC39TU2y4eLTWiD7xnMxm+1ooBLetCuolLkjrZx7ZL9Q3acO61lLM3Hr6/dn30gdYsAAPMrGICd/WPFODDM09yO52HGxJUD+4e43613QJuBeRXYO8hTR9kl4gnRHRplQHNpMWPU5jH1FeFRE+o3RXi1D3P166HZExw6uwY4gPmVuu+fxawJSgl39IMB8yvtMAjGPXl7EoilbPIIhRjjRqq39/OF+hdBxKgLsXVsWYf6ACpLsL1vrBjxNDpi3AZvrEAFxX4bPcIFlQCwc2DsOthQRCjQGsyGgo/GviG0lsGeXTGvgiUz2cqZfOwZhIvZ8V0U8Iz3DnEbLBKTmPqK8Kjyidcj/LRaOwgaE5USCkVon0dYjoMj4xh9O/p5Yykr10/Znxlke8fzCIWfqrWVST4WVrJtR3kAyQx2D/ITqrTfXfQyHT9GPWRTUanAgkq2/ah12NHPMxwn6DfOZhRIUg7xyhI7qNQAZpczjws7jloH8Uza4IgU9oxbSwvOq6WDOIWOjo7uHeSNpUzrmGiBOeVs93iHw8AoehPZI/RYwHGhCPMetmQGb/XwxXV2rG9lCWp843ghO/vhYphrl7Ezu5ylMuOYXdv7+UJbvNJZQRwaz/gVgan5dhkEJ1ax3sTYkdy7BngqgxP0e4QQpYTjuaQHbKnfMLCwkm3vH/vie30cwKJqO0KjE7V5s612AoDXhdnlbOd46+B328FUnFPBAIyrA/ZpbviXj6wiPMog2K15OI+B+ZXs0DAfPqrNmw1tDSzheFOEW6I8kcZi/QlCgQWV7L2jwlC7BnhzKdM6kjcfJ1YxAO/1jX19Rz9fYIsCmFXO0nwcTbxjAC5mR4xaILcOR4ixrY8DOKHKnhq+8T3C9wd5OIAyu56HhZXswDAfM3vh3V7ucdlhlJR60FCK94+KScKuanoD8yvGCY1u7eUnVOktIjTujvFis4k0OkZsSpQCaChF0JuNUeXj3T5+oi2bYn4FOMYRQCRTjpHaCRwHitDNcHAEn1qfFp39fvZeptSDFU02/V8n17B3eo/yCAe4bQlC5BTA1iPFiCYQiWOhLc+6yJUeHSLe0c9nBJlff/hFQMQ/3+sdowjBABtyhADmV2DfED+6lHB7nx1JSgMLq5DhY4/g9/owt9yOUBiyLuk4inD3ALfz4JtfyXb2j+218U4vTtLvFgNoLmOlnnFis/uHOAdmlGlvNCrAgLnlY4mjXTF0xXCSPYqwcnzWkm3JWpOY8orQxbB3kP9ye+Yjf0r9tZ0/vCtzy0KXbbUpH6hmXbGx3XV3DXDbEoQAqkrQXMbePdITEjvQHo/whPFcMQA7+/l8/dWcBprLWIUXY9KE2/t5SxkL6k+UAjihiqWP0kCwi61jQNxrDF/GNg8AEyQpO2PoS9r0QGbFqGCDo9l5FwKDo9g/xO1RhAyYVzFObHaPqJ0otUkRAphXycY4ZG/3cgAn19ixDvMqGAN2jpekDHjs6DllElNfEQIAqkqwe5Cf+3SKA6tPtu+fEg/T2z2HnzObaycEFlXh3SM9IXEOLrBFDzUEUOMbKwBsjM0KMOCEqrGR6m19fKF+poyAMAi2HSlAbwKdMZtcc4H5FczFkJ8mTGWws58vqrZJgIWVLBJHz5E1fHbGqAWyvkieDni3l3PgA3atw/xKdrRVJCIW9iTvBeZVYPfgESn8d3o4gA/YYhCUedBUxo72CHcOYG75MTGbXmDqK0LGAHyk2fXeVZ6fLHP/6hy3ne72ydUMOQtLYEuPTayEfJxUzd7rOyIKtKOfl7js6DNnCDDGJe2O2+0BIKsID//KgW193B6mDICFlczFxiZrhW9k58EX8KC17Aif7P1BJDNYZJcSElp/jFMoPHUbaKsGRKj8nTwjdWsfB2wKjQJYUIHdA3xM36v3+nitD2H9M5gMfLCWJdJHGOtb+3g4YJ83NlGy1rYvwgyOA0UIAEvCbEaQffZE1yfn2vofhfxoLD1is23s4gDOsIW2amBRFRNhH+OVt3v5/ErmsWsxFlWxMUnKHfZSRg0xDg3z/lynzW19fGDUjh5DAqUezAiyMR5hThHaug6n1LA3InmeUB+QyyXbAKH1x8Rmt/fxMo991FkArWWsqZS90pWnAHp5mcc+yv78SpbMjG128V4fP9FeBbCkjgHY2J13OPRwe9xBAZGszX9lJIU9g44iJIVQhEvtVTz5OLma5XuEf+vmcytYnebRo2MgHNB3e7O/cuCVTn5m2L41WVTNInF05eVKd2aTlLaJAACn1zEOvNyZ/TrWd3AAZ9fbtw4nVB6VpOzjJS7Y02/PwLJ6tq2Pd+fG32zoZqUefMCWnBCAWUFWclQN37Z+vqDS7lDYWfVHKMLNUX5SNXPZJUS2u82R6TE7k7UCs8pZQwCv5taBA1t77VWEFawzhoG8EWnv9fEMty9GbQbHgyL0uuyz+o/GKTVsa+9hruDGLm6zOwjgpGrGclFZANv7eDSBs2xUAMK429p3hPXtd9vNCjszzPxuvHQomw9Z18EbS+3orWPgxCq2/cgY9fZ+zKmwzzUX+HAj48D6juw6rO1gy+pZiV0yeFyYWzG2lnFbn60JQoEzw+z9AS64bCMpbOjkyxtsT1LmGQTdcUTi9sWoDSwJuzbmFOG2Pj44ilNrbd0UAN6KHnE4wMYYtRlMeUU4M4hzGpnWOcuFcV6TaySFte0cwKER3jbMl9iuCKtKcHINe/Fg9uDb0MUBWxWh2Nv5fJlXuviHQnYrgIAHZ9WzPx/KirGunS9vsFWCE6rYcOqIGLWdSUoDHwqxUg/WdXAA3XH2Ti/Os6ugSGBh5REh4lgK+4Zspc4KiC2woTMD4K/tPJ7GRS32rUN9AHX+w+YpchvEZo8QwJIw29HPxXiAP+7nDLig2T4ZTq9jAP7WPdZKtq3C2AymvCK8b4n7hZXFU4PAiiZW5sHTbRnkEoRLbIxJGriohf1vJx8aBYANnTzkt5Wo0liKWh/ezsVmkxm8HuF2amID5ze53urh3XHsHeRtw/zDNnoAyLGIN+eM394EtvVzG/q/j0GJC0vDbF07B7C2g3PgvCZbZTgtxLb1c2Ms4o4BnuE40S76br4YfjdEdPTZA5lSD+z0CAEsDbs2dB5WAILSbP86LKljPGcf/2F/5u9qmT2dbwXqA5hVzjYeqQjtaWtgHlNeERYdfjfOb3b9cT8H8PgeXu7FB20MOxj4Py2uRBp/ac8A2NDJzwzblgrJYlmD66WcK/ZmhMfTsDNJaeD8JpbheKYt8/AuDuDcRltlEK7YX9qz6/C/nZkMx4ftlUHgww2ut3r4nkH+/CFWVWLHMJZ8LG9gGX44WftyBwdgT+PDfJS4sKye/WY3j6Xw3AF+bqN97R0Ezqpn2/q4MantnV5e4bWVMWSIEQ7gx++mu+N4pZNfNtN2l7SOHeER9h1bcVE4ipAEl7SyPYP8gR2Z3+zOrFrksqd/xxic3cCCXjx3gP+1nb/Xx+0MfQhc1MzeH+C7hxiQtcHPrC/C07W4jp1cw25/NX3X5vQ1c1w27zdx8v4lZxCs7+A+t90UYoFbFrJyL1Y+m374fXxsFrfZ+l5Sx0pch5OUf27ns8qZzYwhgW+d5m4b4iv+lNrez/++1e4H8sww4zhMVPnzIX5WfRGK5/xufPED7mfa+G3/m05zXDbD7nU4o47tHcwma/cM8r2D/PTisTrGhaMICXDZTFd9ALesSwc8+MeTi6EGgRIXLmx2PbAjc8v69Mwg+9QJdn+zF7UwAC+2uwC80sVnl7OGYrSNcDM8daHb50K5F/9xVhG+ixVNrrd7eCQOAOs6+Ol1dnshAi1l7N/Pcm/v5x+qxT2L7ataEwh4cHpdNjab4Vh7KHNeMdxiAMsb2FWzXRu7+E0LXJ+2fVOcXse8LmzoygDYN8Tf6+N2Jinz8dlFrmofntibuWWh64O2KyGRLfpbdwbAU/s5gEtmHFuKsJjZteMG9QG8faX3HzemF4dYyN7CiXzcf7b70uf5q138v1a47T9851awuRXsxXbX9Sfg+QOZf5hVNBtrZpC9fJknkYbNRSwCKxoZB9a2Z1a2ut6I8C+dUrR1uH6eywWcG04XRRMvb2D/39uZkRS29fFowu4kZT5+vMx91Wx29Ry7kwUASj04tYaJNOGzBziA/9NSnHWo8OKJj3hczO4sqcBptSzgwdP7+aUz8Id9mUVV7JhiysBRhFSo82PNOcXxBQ2E/HjpYs/adr6ytTgP2cWt7Ofb2DV/Tg2l8OXiKQDA7rq9fCwOscoS/Of2zPsDGM3gI83FXIdr57mSydTYztO2YEWT6+4tmf96P9MVA4PdtNV81PnxsTlFu/vKVnbX5sw7vfzZNj6rnNlfQ2LgnCI55QACHtwwz7VmZ+b2D7jWdXA7u2CaxDEnkAMVlHpwcWvROvh964Ouk6v4nw/xz5zgsp8jfozA48Jdi93PHuBffS191WzXiuKdPsXFBc3snEb2pY3pO99Mf6SZNZYWW6Ai4fYPuCu8+MSf088cyKwskjt4LODLp7pSHGf+ITWaweUzjzm9c8wJ5GDqosaHp89Lffd0950fKrJzXFx8bpHr/y5wNZexny6bvuvAgPvPdsfTmF3OHj1v+kaeanz48qnud3r5WWH2ncXT93mYU85umu+qLGGPnudeWgw+eWEwXpS4iTLa2trOOuustra2Ygvi4DA45yMjI2VlNk5fPVbBgWQaReEPj0EymeSc+3x2TSY7EpsivLWM1R8z03aKgkQaf9if+YeZLm/O7xgZGfH5fG73MfB8OADg5AgdONABhmNCCxYdi48xlnxR4HPj6tlO7O2YhvP1OHDgwIGDaQ1HETpw4MCBg2kNRxE6cODAgYNpDUcROnDgwIGDaQ1HETpw4MCBg2kNRxE6cODAgYNpDUcROnDgwIGDaQ1HETpw4MCBg2mNqaoI0+l0PB4vthQOjkBvb++rr75abCkcHIHdu3dv27at2FI4OAKvv/56Z2dnsaVwcBi6FGE8Hr/nnns+/vGP33HHHQMDA+Ne8z//8z833HDDqlWrtm7darzY09Pzz//8z5/4xCd+8IMfjI6OTvT5nZ2dvb299HI7UMCGDRvuvffeYkvh4Aj87ne/+6//+q9iS+HgCPzoRz/6y1/+UmwpHByGLkX46U9/+tlnn73mmms2b9581VVXHX3B448//ulPf/qiiy5qbm5evnx5e3u7eH3lypW7d+/+2Mc+9tvf/vYLX/iCJvEcOJgmmKLNhI97ON/LMQUtvUYPHjz4m9/8Zt++fQ0NDStXrgyHw5s3b/67v/u7/Gvuvffeu+6669prrwXw5ptv/uIXv/jmN7+5bt26PXv2vPzyyx6P55RTTjn55JPvuOOOmpoaHUI6cODAgQMH0OQRvv766/PmzWtoaADg9/vPOOOMMamjdDq9adOmc845R/x6zjnnbNy4EcDGjRvPOussj8cDYO7cubW1tVu2bNEhoQMHDhw4cCCgxSPs6Oiora01fg2FQkbkU6C7uzudThvXGBdM+kYDIyMj+Z8AoKGhQaheB8VCT09PW1vb+eefX2xBHBzGvn37UqnUpk2bii2Ig8PYunXr1q1bH3zwwWILMi3w0Y9+9HOf+1zha7QowkAgkEgkjF/j8XhpaemYCwAY1xgXBAKBrq6uAm80sHz58ptvvnnhwoXGKy0tLeFwmO6fcGAZiUQiEok0NzcXWxAHh9Hf359Op538wjGFjo6OyspKcQw60I3Zs2dPeo0WRdjS0tLW1sY5Z4wB2L9//9VXX51/QWVlZXl5+f79+xsbG8UFLS0t4o3r168X16RSqUOHDonXx5Hb4/nP//xPHcI7cODAgYNpBS05wmXLlmUymeeffx7AW2+9tWPHjosvvhjAzp07n3nmGXHNlVde+etf/xpAPB5/7LHHrrzySgCXXXbZa6+9tmvXLgBPPvlkKBQ67bTTdEjowIEDBw4cCGjxCEtKSn7wgx9ce+21Z5xxxmuvvXb33XdXV1cDePHFF++///6VK1cC+OY3v7lixYqtW7d2dHTMnz//iiuuANDU1PSNb3xj2bJlp5122qZNmx544AGXa6qW/Dtw4MCBgykBpq+cpaura+vWrQsWLDCSRsPDw0NDQ/X19eLXRCKxadOmYDB46qmn5r9x//7977///imnnJLPhXHgwIEDBw50QKMidODAgQMHDo59aAmN2oB169a9//77S5YsWbRoUbFlcQAAyWTyrbfeSiQSy5YtK7YsDrJ4880333nnnaqqqhUrVgSDwWKL4wBdXV2bNm3q7OxsbGw877zzSkpKii2RA2CKeoS33Xbb2rVrzz333CeeeOL73//+DTfcUGyJpjueeOKJj3/84xUVFeXl5bt37y62OA4A4NZbb12/fv0ZZ5zR3t7+zjvv/PWvf80vN3JQFFx99dWxWKypqWnz5s39/f0vv/xyKBQqtlAOpqAi3LFjx2mnnbZ79+5wOPz888/ffPPNe/fuFc1oHBQL0WjU5XK98sorn//85x1FeIxg9+7ds2fPFiVM1157bSAQ+OUvf1lsoRxkwTlfvHjxLbfcsmrVqmLL4mAKjmF6+umnly9fLmrnP/KRjwwPD7/55pvFFmq6o7a2VhCDHRw7mDNnjtCCABobG/N7XDgoOlKpVCKRcNzBYwRTTxEePHjQqLJ3uVwNDQ0HDx4srkgOHBzLaGtr+9WvfnXLLbcUWxAHAPDrX//6ggsumDdv3iWXXDLuZB4H9mPqRRTT6bRh5wLweDypVKqI8jhwcCyjt7f3sssuW7Vq1bnnnltsWRwAwNlnn11fX79ly5b77rvvyiuvPP3004stkYMpqAgbGxs3bNhg/NrZ2dnU1FREeRw4OGYxMDCwcuXKFStW3HHHHcWWxUEWc+bMmTNnzkUXXdTe3v7jH//4V7/6VbElcjAFQ6PnnnvuunXrYrEYgDfeeGN0dHTMpEMHDhwAGB4evvTSS0855ZT77ruv2LI4GAeRSKSioqLYUjgApqJHeMYZZ5x++umXXnrpJZdc8rOf/eyLX/ziRBMqHNiG/fv333XXXW1tbZFI5DOf+cycOXO+8pWvFFuo6Y5Vq1a9/vrrCxcuvO222wDMnTv3y1/+crGFmu5YsmTJhRdeWFFRsWnTphdffPGVV14ptkQOgKlYPgEgkUisWbNmz549S5cuvfzyy4stjgNEIpHf//73xq/19fXO91J0PPPMM21tbcavDQ0Nl112WRHlcQDgxRdf3Lhx48jIyIwZM66++mpnPNYxgimpCB04cODAgQMqTL0coQMHDhw4cEAIRxE6cODAgYNpDUcROnDgwIGDaQ1HETpw4MCBg2kNRxE6cODAgYNpDUcROnDgwIGDaQ1HETpwMBbDw8NDQ0PFlkIGb7/99kMPPWTzTdevX//UU0/ZfFMHDgjhKEIHDrLYv3//pz71qXA4HAwGy8vLGxsbP/WpT+3atavYck2IRx555OWXX85/5Q9/+MPNN99Me5fbbrttzsR48sknf/KTn3zjG9+gvakDB3Zi6rVYc+BAB15//fWLLrqIMfa5z31uyZIljLGtW7c+8MAD119//THbB+srX/nKFVdcsWzZMuOVc889l7y/9vnnn28MPlu/fv3zzz9/++2319bWilfmzp17zTXXRCIR2ps6cGAnnM4yDhwgFoudeOKJqVRqw4YNM2bMMF5Pp9OPP/74NddcY7wyOjoajUYrKiom6nA7Ojra398vMXA1k8l0d3cHAoGJGjF3d3d7vd6qqirjlZaWliuuuOI//uM/rN4rHyMjIwMDA7W1tV6vd9KL77777q9+9as7duyYP3++mU+Ox+P5XcR6e3vLyspKSkqOvjgWi/X399fU1Iz7VwcOtMIJjTpwgEcffXTfvn3f/e5387UgALfbbWjBZDK5evXq2traxsbGioqKv//7v9+3b59x5cknn/ylL33p7rvvDoVCdXV1tbW1999/v/jTww8/XFNTs3379vxPXr169Zw5c5LJJIBMJvO9732vsbGxoaGhsrJyyZIlb775pnEl5/z73/9+c3NzOByurq5ubGx88MEHATQ2Nra3t//iF7+oqampqalZvXo1gH//9383/oWlS5fmq3AAfX19DQ0Nd999t/h1586dF198cUVFRWNjY3V19erVq0dHRyVWb9WqVRdccIH4eevWrTU1Nb/5zW8++tGPlpeX19bWLl++vLOz85133lm8eHFNTU0wGFy1alX+DNG2trYrrriisrKysbGxqqrqtttui8fjEmI4cCAP7sDBtMcnP/lJxlhvb2+Ba2699Va3233nnXdu3rz50UcfDYfDc+fOHRoaEn9tbW1taGhYsWLF888///LLL1988cUej2fXrl2c876+vtLS0q997WvGRyUSiVAodNttt4lfv/jFL/p8vu9+97ubN29et27dOeecU1NTc+jQIfHX1atXM8ZWrVr18ssvb968+YEHHvjZz37GOX/ppZdCodDll1/+wgsvvPDCC++99x7n/Dvf+Y7H4xFvFD+3t7cb9/3pT38KYNu2bZzzQ4cO1dfXf/CDH3z66ae3bt3605/+NBgMfv7zny+8UN/73vcA7NixI//Fj3/846eeeqr4ecuWLQAaGxu/8pWvvPrqqw899FAwGLz44otPOOGEn/zkJ6+99tqdd94J4IEHHhDXR6PRWbNmLVq06Mknn9y6deuDDz5YXV193XXXFRbDgQNaOIrQgQN+9tln19bWFrigra3N5XLl64lnnnkGgNBJnPPW1tampiZDL3Z1dblcrn/7t38Tv37iE59obm5OpVLi18cffxzAK6+8wjnfu3ev2+2+6667jE/u6emprKy84447OOf79u1zu9233nrruFI1NzePUV35ivDAgQNut9uQgXO+dOnSs88+W/x8++23V1ZWdnZ2Gn+95557vF5vf39/4BOUYgAABWxJREFUgXUwqQivv/5646+rVq3KXyjO+amnnnrZZZeJn7/1rW/5/f59+/YZf/35z3/OGDtw4EABMRw4oIVDlnHgAJlMxuUqlCZ46623MplMfqTxoosuqqqq+utf//qZz3xGvPLhD3+4rKxM/FxXVxcKhYwpSDfeeON///d/r1279vzzzwewZs2aBQsWLFmyBMBLL72UTqfr6upefPFF48NbW1vfeecdAH/5y1/S6fQtt9wi8U81Nzefd955a9asuf322wHs3Llz48aNP//5z8Vfn3/++fnz57/11lvG9X6/f3R0dNu2bWeccYbE7fJx4YUXGj8vWLDg6FcMLu5zzz03a9asHTt27NixQ7wiFPm7777b3NysKIYDBybhKEIHDtDY2CimxE1EgRHpwKamJuMVxlhjY2M0GjVeGTNbzufziRQggAsuuKC1tXXNmjXnn39+V1fXs88+e8cddzDGAHR2dgL48pe/LH410NraCkCwMQ3SplXceOON11133ZYtW0499dRf/epXfr//qquuEn/q7OwcGhr62Mc+ln99dXU1Cf+zurra+FmQX/JfyV+Zrq6uAwcOaBLDgQOTcMgyDhxg+fLl6XQ63ycbA+HqdXd357/Y3d1dWVlp5vNdLtd11133u9/9bnBw8JFHHkmn09dee634k/iEV155pedI/OlPfwIgOKJCWUrgox/9aFVV1Zo1azKZzEMPPXTllVcapNOKiooLLrig5yhcfPHFcveSQ0VFxRlnnHG0GJ/4xCfsFMPBNIejCB04wA033FBVVfX1r399cHBwzJ9effVVAEuXLgXw9NNPG6+/8sorkUjkzDPPNHmLm266KRaLPf7442vWrLnwwguFwwfgwx/+MIDf/va3475r+fLljLHHHnts3L8Gg8FYLFbgpoFA4Oqrr37kkUeee+65tra2G2+80fjTOeecs379+o6ODpPya8I555yzadOmPXv2FFcMB9McjiJ04ADV1dVr1qzZsWPHmWee+eijj+7Zs+fAgQNPP/305Zdf/oUvfAHAggUL/uEf/uG+++57+OGH+/v7N27ceNNNN4XD4XzVUhgLFixYunTpHXfcsWXLlhtuuMF4/QMf+MB1111311133XvvvW1tbbFYbOvWrffcc8+TTz4p3nX99df/4Ac/uPfeew8ePDgwMLB27VrBtQFw0kknPf/883/84x9ff/31/fv3j3vfG2+8saura9WqVa2treedd57x+te+9rVMJnPJJZesW7dueHi4o6PjhRdekEtGquAf//Efg8HgpZde+tJLLw0ODnZ1da1du/bmm282YqcOHNiBYrN1HDg4VrBhw4bly5cbrBnG2MqVKzds2CD+2tfXd+WVVxqZvJNOOunNN9803tva2rpq1ar8T2ttbR1D6RTVC5WVlcPDw/mvx+Px1atXBwIBY1cuWLDgxRdfNP76uc99zqh29/l89913n/jTtm3bVqxYUV5eDkAUY+SzRg0sXLgQwNe//vUxr2/atGnx4sXGTf1+/+WXX154iUyyRv/4xz8af/3JT34CIL805brrrjvppJOMX7du3ZrfHMfr9V544YWjo6OFJXHggBBOZxkHDo5AT0/Pnj17fD7fvHnz/H7/mL92dnbu27evqqpKkCEJEYvFtm/fnkqlWlpaGhoaxvx1cHDwvffeCwQCs2bNEppvXIhdXZgBOwYHDhw4dOhQeXn57Nmzj/5/j/78TCbjdrsVb3o02tvb29ragsHgzJkzDfKtAwf2wFGEDhw4cOBgWsPJETpw4MCBg2kNRxE6cODAgYNpDUcROnDgwIGDaQ1HETpw4MCBg2kNRxE6cODAgYNpDUcROnDgwIGDaY3/HxUX2Kvb8FzHAAAAAElFTkSuQmCC", "image/svg+xml": [ "\n", "\n", @@ -779,43 +855,37 @@ " \n", " \n", "\n", - "\n", + "\n", "\n", " \n", - " \n", + " \n", " \n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "\n", + "\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/html": [ "\n", @@ -831,46 +901,168 @@ " \n", " \n", "\n", - "\n", + "\n", "\n", " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt = plot(ylabel = \"\\$C_x\\$\", xlim = (0,Inf), ylim = (min(1.5*minimum(2real.(forces[2:end])),0),max(1.5*maximum(2real.(forces[2:end])),0)), \n", + " xlabel = \"Convective Time\",title=\"Propulsive force (<0 is drag)\")\n", + "plot!(Δt:Δt:tf, 2real.(forces), linewidth = 1.5, linestyle = :solid, label = \"Vortex model\")\n", + "plt" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "if probtype == :pitchup\n", + " plot(motion.kin.α.(Δt:Δt:tf)*180/π, 2imag.(forces), linewidth = 1.5, linestyle = :solid, xlabel=\"Angle (deg)\",ylabel = \"\\$C_y\\$\",label = \"Vortex model\")\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, - "execution_count": 16, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -879,7 +1071,329 @@ "plt = plot(ylabel = \"\\$C_M\\$\", xlim = (0,Inf), ylim = (-1,1), \n", " xlabel = \"Convective Time\")\n", "plot!(plt,Δt:Δt:tf, 2moments, linewidth = 1.5, linestyle = :solid, label = \"Vortex model\")\n", - "plot!(plt,Δt:Δt:tf, 2momtheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")" + "if (probtype == :pitchheave)\n", + " plot!(plt,Δt:Δt:tf, 2momtheo, linewidth = 1, linestyle = :dash, color = :black, label = \"Theodorsen\")\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOydeXwURdrHa+47k8nkvshFIAd3ACGKXB4rHriK4AUooruKuu666+p67K4Xrq73BYssCoqKiK4groAIyA1JgISEK/c5OWYyk7l6uqffP56X2mZmEiYk5GCe7x/z6a6prn66u7p+VU9VV4l4nicIgiAIEqqI+9sABEEQBOlPUAiRbtPU1HTgwIF9+/ZVVlYyDNPf5vQaa9euXbRo0bFjx2jI3//+90WLFrlcrn60qu/Zvn37Aw88sHXr1v42pFO+/fbbRYsW7du3r78NQS4RUAiRbrB58+YxY8bExsZOnDhx0qRJqamper1++vTp33//PY1TWFi4fPnysrKyfrTzwti7d+/KlSurq6tpyIYNG1auXHkpiX0wlJSULF++XFgh6C+2bt26fPny5uZmn/CCgoKVK1eePn26X6xCLj2k/W0AMmj44osv7rjjDp7nr7rqqsmTJ+v1+srKyoKCgp9//nnixInXXXcdRNu8efNf/vKX5cuXDx8+vH8N7jnjx48PDw+XSvE16R+WL1++bt26MWPGREVFCcNTU1OnTp0aGxvbX4Yhlxj4hiNB4fV6H3vsMa/X+9FHH917773CvyoqKpqamvrLsIvK8uXL+9sEJAALFy5cuHBhf1uBXDqgECJBcfr06YaGhvDw8Hvuucfnr9TU1NTUVNguKSmpr68nhFRXVx8+fBgChw0bptVqW1paqqqq4uPj4+LiTp48uXPnzvb29jvuuCMuLo6eYteuXSaTKS4ubtq0aUlJST4n4jju4MGDp06damxsNBgMEydOHDFihE+ckpISl8s1duxYhmF++OGH8vLymJiYG264QafTQYSCgoJ9+/ZxHDdt2rTc3Nyur7q0tNThcIwZM0YsFhNCGIY5duyYVqsdNmyY2WzetGlTY2NjcnLytddeGxYW5n94e3v71q1bq6urZTJZXl7eZZdd5h+noKCgpKSkqanJYDAkJibm5+drtdqurbLb7bt3766urrZYLPHx8VdeeWVCQoIwgsfjOXr0KNhpsVg2bdrU0NCQlJT0q1/9KqCd0OMrkUgmTZo0duzYrs9OCDGZTDU1NTExMYmJiQH/io2NFZpUXV39888/NzY2RkVFTZkyJT09XXhIR0fHiRMnjEZjSkpKfX39li1bTCbTdddd53K5zGYzIaSsrAzuPyEEnkVDQ0N9fX1qampERIQwKZfLtXPnzpMnT3Icl5SUNGXKlMjISB8Li4uL9+3bZzab4+Pjr7rqqujoaJ8INptt165dVVVVDMNERkaOHDnSP5shlxo8ggRBeXk5IUSn03k8ni6iBXSH7tq1i+f5FStWEEL+9re/PfTQQ/Sv7du38zxvsVhuvfVWkUhEw6VS6ZNPPun1emnKW7ZsMRqNPinPmjXLYrH4G3D48GGqzYSQ6OjoI0eO2O32W2+9lQaKxeKlS5cKj3344YcJIRs3bqQho0ePJoS0t7fDblVVFSFkypQpGzZsoMpKCImNjS0sLPS5FW+++aYwDiHk8ssvb2hooBHa2tqmTZvmc0Vyuby5ubmLO/zCCy8olUrhITKZ7KmnnhLeq7q6OkJIfn7+t99+K1S+6Ojow4cPC1NzOp2//vWvhanNmTPn9ddfJ4S8/vrrndlw8OBBSN//r9tuu40Q8s0338Auy7KPPvqoRCKh6YtEovvuu8/lctFDdu3aRQi5++67X3vtNeqFfvfdd0kgOjo6eJ5/9tlnCSGrV68WnnrdunW0UgVIJJK1a9fSCA0NDVdddZUwglKpfO2114SJbNiwITw83Oek99xzTxdPBLkEQCFEgoLjOKh9L1iwQFia+7Bnzx5wnD722GNbzmI2m/mzQpicnBwTE/P666/v2LHju+++q6ioYBhm0qRJhJAbbrjhxx9/LCsr++6776AO/tJLL9GUP/vssxtuuOGzzz47cODAiRMnvv/+e1CR22+/XWgACOGQIUPmzZu3ZcuWffv2LVq0iBAyevToRYsWZWZmrl27tqCg4MMPP9RoNBKJpLi4mB4bpBDGxcVpNJonn3xy586dO3funDdvHiFkxIgRQjNee+01QkhqaurHH39cXFy8d+9eMGPcuHEMw0CcBx54gBAyd+7cvXv3VldXHz169Msvv7z55pu7FsJHHnnkgQce+Pbbb48dO1ZcXLxq1aq0tDRCyL/+9S8aB4QwLi5Oq9U+8cQTO3fu3LVr15133kkIyc7OFkomtO8nTZq0a9eu6urqDRs2JCcnx8fHdy2EPM+PHDmSEFJWViYMtFgsKpUqOjqaXuPvfvc7QkhmZuY333xz5syZzZs3w4Hz58+nR4EQJicnazSav/71r1u3bt2yZcvhw4e3bNkyZcoUEEWal1iW5QMJ4ZdffikSiTQazYsvvnjkyJHS0tJNmzbdd999q1atggg2m2348OEikejOO+/86aefysrK1q1bB7WllStXQpyWlhaNRqPT6WC0V1VV1S+//PLyyy8/++yzXdwK5BIAhRAJlhUrVkDVXiQSjRgxYvHixWvXrgWRE/Liiy8SQpYvX+5/OBx78OBBYfh7770HDRFhYFtbW1RUlE6noyLkj9vtHjlypEQiEQozCOHcuXNpiNfrzc7OJoQYjcbW1lYa/te//pUQ8vzzz9OQIIWQEPLBBx/QOBzHwUlLS0shpL6+XqFQREVF+dQY7r77bkLIZ599BrtDhw5VKpVUMy6YM2fOKJXK3NxcGgJCCBIivA85OTmEkGPHjkFIaWmpSCSKiooS3uSioiJomncthK+++ioh5JlnnhEGfvDBB1AHgt3y8nKJRKJUKqurq2mc5uZmvV5PCKFtaBBCQsinn37qc5Y5c+YQQg4cOOAT7iOETqczJiZGLBZv2bKlM4OffvppQsjDDz8sDKyqqlKr1fHx8eDn2LRpEyHkD3/4QxcXjlyS4OcTSLAsWrRo7969s2bNUigUx44d+9e//nX77bdHR0f/5je/cTgcQSYyY8aMvLw8Ycjq1asJIVBOUQwGwx133AG9NZ0lJZfLr732Wo7jaGck5fe//z3dFolE0LCYP3++sEvpyiuvJIRUVFQEaTklPDx88eLFdFcsFs+cOVOY1Jdfful2uxcvXuwzrPG3v/0tIYR+amIwGNxud0FBQXcN8CEtLS03N7ekpMRutwvDdTodNDoBkUgEjkFqJzgwFy9eLHSfjho1Ci6na+6++26ZTPbJJ594vV4a+PHHHxNCFixYALv/+c9/OI678847hd29kZGR9913HyHk66+/FiYIjfhgr/lctm7d2tTUNH369C4sX7NmjUgk8slmycnJ119/fX19/ZEjRwghBoOBEFJYWBhqX44iOFgG6Qbjx4/fuHGjw+HYs2fPvn37Nm3atG/fvmXLltXV1X333XfBpACNMyGFhYUikWjNmjV0QAQA37FVVlbSkM2bN7///vulpaV1dXXCoqqlpcUnzaFDhwp3YfB9Zmamf+AFjHfNyMgQdnoRQmJiYoRJFRYWEkKKi4v//Oc/C6N1dHQIr+jee+89cODA5MmTp02bNmPGjJkzZ+bl5Qk7SgPi8XiWL1/++eefV1RUNDY2chxH/2pra9NoNEI7fT788LHz+PHjhJBRo0b5nGLMmDFbtmzp2oyYmJhrrrlm48aNO3bsAB/1yZMn9+/fP2bMGJogpD9mzBifY8eNG0cIKSkpEQZmZWX5ZIDgARmD5ntA2traKisrNRoNdH8KgVZ+ZWXluHHj8vLyRo4c+dNPP6WkpMyaNWvq1KnXXHON/2ga5NIDhRDpNmq1eubMmTNnznz66ac//vjjhQsXbty48dChQz5NvYD4jOJzOp1ut1ssFoPj1AeDwUAbHO+8884jjzwSFhZ23XXXzZ07Fxox27dv/+9//8uyrL+Fwl0oYVUqlX8g3/25dn0SJ4SAelFTYazj9u3b/ZuzBoOBitMDDzwQHh7+xhtv/PTTT9u2bXvqqacSEhJeeeUV6MzrjLlz527YsCEpKen666+PjY2Fi1qxYsXp06d97sN57QRh9vlEjxASZNG/YMGCjRs3fvzxxyCE0BtHm4M0fVBfIRBis9mEgf7DO4PHarUSQqBrMyDt7e2EEJfLFfB7GIPBAPUJmUy2ffv255577ssvv1y5cuXKlSvFYvGsWbPeeeedIUOGXLB5yMAHhRDpEQsWLHjrrbcKCwsPHz4cjBD6oFQqZTIZIaS+vt5nMKQQt9v99NNP6/X6w4cPCwff19fX//e//70wyy8eMFj0ww8/vOOOO7qOOXfu3Llz55pMpp9//nnjxo2ff/75XXfdFRER8atf/Spg/F9++WXDhg0TJkzYsWOH8HatWbPmgu00mUw+4UG2km+88cbIyMivvvrqnXfe0Wg0a9askclkwkuG9P1Ta2xsJIT4fMhx3qZwF0CnI+0Z9QcsMRqN5720iIiId95556233jpy5Mi2bds++eQTGNJVWFiI8ypcwmAfIdJTFAoFIYR6C+VyOSFE6LLrApFINHr0aI/HAyPyO6O8vNxqtU6YMMHnE7Sed7BdDMAZuGfPniDjR0dH33bbbZ988slbb71FCFm/fn1nMcEHOHv2bKEKWq3WC5tsDMbOgCNXiH+fa0Dkcvm8efPsdvv69eu3bdtWU1Nz/fXXC9uXkL5/avCsz/sRJyEEKkn+LX4f4NvHLjJDZGRkUlKSyWQK8kaJxeIxY8Y8/vjjBQUF2dnZxcXFJ06cCOZAZJCCQogERXNzM4yt8AkvLCyEAgg6fshZD1VNTU2QKcMUIc8++6zH4/H5y263wxmheK2pqREOzfjxxx9/+eWX7l/KRef2229XKpUff/xxaWmpz188z4PDkJz1HAqBz+DcbndnKcN9EM6GSgh56aWXLmxwx8033ywSiVasWGGxWGhgQUHB9u3bg0wBHKEff/yxzzAZYPbs2VKp9LPPPqOjbQkhTU1NH330kUgkEn7T2RmQl2pra7uONn369ISEhJ9//nnz5s2dxYFsBh9c+vzVxRORSqVwz7t4KMglADb2kaBob2+/+eab09LSbrnllokTJxqNRrPZvHfv3n/9618Mw8yePZuOiRg3bpxIJHr//fd5nk9OThaLxTfeeGMX00Lef//969ev/+mnnyZPnvzQQw/l5OTwPF9RUbF9+/a1a9c2NzfL5fLIyMjc3Nzi4uKFCxcuWbJEq9Vu2bLl2WefTUtLgy/9BxTx8fGvv/76gw8+mJ+f//jjj0+cODE6OrqqqurIkSOffPLJX/7yl/nz5xNCUlNTb7rppmuvvTYtLU2pVB45cuSpp54ihMA36QGZPHmyXC5fsWJFamoqzL2yevXqZcuWJSYmnlct/Bk6dOj999+/bNmymTNnvvDCC+np6QcPHvzjH/+YlJTko7WdkZeXl5ubu2PHDvhchM43CyQlJf3hD3945ZVXpk+fvnTp0uzs7JMnTz711FM2m23x4sXBtAjHjx9PCHniiSdOnDgBPZf33nuvv4tSLpd/+OGHs2fP/vWvf/34449fd911Wq32zJkzGzZsmDJlCnzB+cQTT3z33Xfr1q0zmUz333//8OHDXS5XZWXlDz/8sH37dqi3rV69+t13373nnntGjRqVnJxssVi++OKLHTt2ZGZm+g8pQi4p+u/LDWQw0draetttt8H4ciFKpXLJkiUOh0MY+b333hMOkRDOLPP3v//dP3GHw/HQQw+BT5Uik8lmzpxJJ7I5cuSIcBS+WCz+85//DN8srlixgiYFn/QJJy7hef65554jZ0dzUGBM43XXXUdDgp9Zxsf+F154gRDy0UcfCQM//fRTn5nPCCFZWVm//PILRPCfuEur1b799ttdPAWe59esWSMc9RMWFrZ+/Xr4bKC8vBzi0JllfI5dunQpIWTZsmU0xO1233XXXUIb5s+f/8Ybb5DzfUdIgQ8KieDzQSEcxz311FPCJyuVSh955BHh15N0ZpmAhz/22GPCCXq6mFnmu+++S05OFl6LSqX66quvaASz2Xz33Xf7jPhVKpW33XYbRPj66699JgMihOTl5Z08eTKYW4EMXkQ8rlCPBA3HcUVFRbW1tQ0NDVKpNCUlZcKECQGnrySE2Gw2WEAnPj5eqVTCrsFg8FdToLW1dc+ePXV1dWq1OiEhYezYsT4xXS7XL7/8UlFRodVqp0yZkpCQYLFY6Kf3EKempsbj8aSmpgoHX5jNZrPZLIxGCPF4PDU1NWq1mrZWm5ubLRZLQkICHW9ZU1PjcrnS09NhiCnLstXV1Uql0meAor8Z9BT79+8/deoUy7JxcXHDhg3z+a6jvr6+sLCwqalJLBYnJydPmDDhvBONgp179+5taGiIi4ubPn26VqttaGhwOp3JycnQWuI4rqqqqjM7IyMjfR5ZcXHx/v37pVJpXl5eTk6O1WptaWkxGo0wCKVrXC4XzC4bHR3dmfEmk2nHjh2tra3h4eFTpkzxsQpS0Gq1XYxWbW1thZGf8GTb2tpaW1tjY2P9b/jevXtPnTolEoni4+Pz8/P9ha2xsXHPnj0mk0mr1SYmJubl5QnNZlm2qKiooqICblRmZiZONBoKoBAiCIIgIQ0OlkEQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKRBIUQQBEFCGhRCBEEQJKTpUyH8/vvvT5w40ZdnRBAEQZCu6VMh/PLLL/ft29eXZ0QQBEGQrkHXKIIgCBLSoBAiCIIgIQ0KIYIgCBLSoBAiCIIgIQ0KIYIgCBLSoBAiCIIgIQ0KIYIgCBLSoBAiCIIgIQ0KIYIgCBLSoBAiCIIgIQ0KIYIgCBLSoBAiCIIgIQ0KIYIgCBLSoBAiCIIgIY20vw1AEAQJFRiG8Xq9dJfjOIZhhBE4jvN4PMIQnuddLpd/Um63m+f5gKfgOC5IAwLicrkCptxZ5CBjdmFSFwb7I5VKb7rpJrG4N1txA1oIfZ6ZTCaTSCT9aA+CIAMTj8cDhSktVVmWZVmWEOL1et1uN0SjpTYt62k0YaDX66X6JCymhdojVAthOMuyQiXzKcTkcrmwBBeLxQqFQnghEolEJpP5XJ1KpfK/ZIVCIRKJ/MPlcnkX5aSPAQFRKpUBUw6IwWAIMmYXJnWrYJdKpb2rgmQgCyHP88uXL7fb7TSE5nUhUqlUKvW9ioB3VqlU+oT458IeJkgIUSgUPg9JJBL5n4V0ktv8M7dIJAp4oiDPTjq5IgS5YITiIdQJKjNCMaCBbrcbJIEeTttDPM9TrXI6nT4HUsnxT4oqEK0l01eVZnvha07fGvqmCN8O+kqKxWK5XA6Bwndf+HoK319huFQqFSpZMMKD9DsDt3wUiURLliw5bzThO0kJ2Nb2b8ILq4pdJ0hfvK4TDBiT5/m2tjb/mAH9D/7ujs4cI0GenXRyRaQTKQ1YOSCdVFSBgNVVoOtSIKBsB394MAb4IyzjBhTB+KwC5ljA36VG/FonxC8z+OQuoSCRc98j4YFC8RDqBM1RQjHoQnskEgk8O5FIFBERAdHo06QHUsmhekOTQplBeoWBK4RBErC5E7CIR4T4FHmUzoragOUsQKvw/nRduJ+3KyIYbejaAH+EXq8BRTCef7FY3JnqB6yp+LRO/KP5+Bt8vBdCkUO/AnIJgzk7ROnM40oIUavVfWwMgiBIP4JeBQRBECSkQSFEEARBQppeEMLdu3fPnTs3Kytr9OjRzz777MDsgEEQBEGQgPRCH+GxY8dmzpz5/PPPWyyWe++9l2XZl156qefJIgiCIEgf0AtC+Jvf/IZuL1myZPXq1T1PE0EQBEH6hl7uI9yzZ8+IESN6N00EQRAEuXiIgp9T7rysW7fuoYceOnr0aGxsbMAIY8eOPXnyJP2cOTw8vLS0NODn2wiCIAjSN/Tad4Q//PDDkiVLNm/e3JkKEkJyc3Pvu+++22+//f/PLZWiCiIIgiD9S+8I4bZt2xYsWPDNN9+MGzeui2hisVij0fR8klYEQRAE6S16QQh37NgxZ86cVatWDR8+3Gw2i8VivV7f82QRBEEQpA/oBSHcvHmzwWB47LHHYDcxMXHHjh09TxZBEARB+oBeEMKlS5cuXbq05+kgCIIgSN+DU6whCIIgIQ0KIYIgCBLSoBAiCIIgIQ0KIYIgCBLSoBAiCIIgIQ0KIYIgCBLS9NoUawiCIJckXq8Xlln1er1utxsCXS4XbLAs6/F4YNvtdtPZm10uF932eDwcx9EEhX8RQhiG8Xq9wjO63W6fEJ/EhXg8HpZlu7CfmnpehNfSc1iW7dqwC0OpVD7++OMSiaQX0xzQQlhbWwv5T6VSCcOlUqlU+j/LxWKxz5ylMpmsd28TgiADCo7jQF0YhuF5HvQJBAZ0BeSBapjT6SRnBYnqGUgL3aVyBZHJWQkRi8WwVIBIJFIqlfAX3ZBKpTKZDLYVCoVIJKIR6LZPiST8ixCi1+vF4nOccwqFwifEJ3EhQgMCQk09LxKJhC6K0HN8CuqBzMC1kuf53bt3CzMxxaeiIaymAT71L4lE4pNRfDKiv3D6SC99E4Rp+oSIRCIfPRa+NhS5XO6TxeVyuc/Z/XO8j8HEL3P7vwydvTYIcrGhbygoE7yPIFrkrLpAowf+goYIiBbP8xBBGA20jWEYiMyyLLzU8BrSVw9eE3jFZDKZVCqlby78FRYWJpFIaNUZ3hG6S8sB+voHLyHIoGbgCqFIJJo7d26vJAWVR2GIj2vCRzjpq0ih9Uphmj4htFoqDPGRcEJIe3u7j9MDXm9hiL8PxMdg4ufu8HeP+ETwrw341zr9tdM/jn86pPOKpL/qd5Ys0FkV0r/RH8xZ6L9duwe6VW8NWLm5SJzX5eWfLYHz5iih502YSEAvH83qNIfTqid9s+gZIdfRTALyAwJDMwncQMgD0rOoVCoQLXqHhdHgEcOjHETtDGSwEBL5CV5CYUgIVvT8awP+/RD+AuwfJ6Df379aAPh3fnSWbBeJk0CN/mDOQv/1UYUgTxoQ/0rSxQPaNF1E8HdUAP7a71NXEFZEhImAIME29ddRAaMNL1ovocfSM6IfAhmMhIQQIgRrAwiCIJ2An08gCIIgIQ0KIYIgCBLSoBAiCIIgIQ0KIYIgCBLSoBAiCIIgIQ0KIYIgCBLSoBAiCIIgIQ0KIYIgCBLSoBAiCIIgIQ0KIYIgCBLSoBAiCIIgIQ0KIYIgCBLSoBAiCIIgIQ0KIYIgCBLSoBAiCIIgIQ0KIYIgCBLSoBAiCIIgIQ2uUI8gCHIR8Xq9DMPQXZZlPR6PMALHcT4hgMfjYVm2i5R5nne73b1lp9AeocE9RC6XSySS3kqNECKRSIYNG9aLCRIUQgRBQgoQD1AjhmG8Xq/L5eJ5nv4SQtxuN0Tzer0sy7IsS/+CXSJQKY/Hw3EcOVc/aDRCiFgslsvl1ACpVCqTyYQmSSQSnxBAJpNJpV0V0SKRSKFQ9OBmBEYikQgN7iEMw8D96S0UCsXQoUPF4t50Zw5oITxw4ABUlIQ5SSQSKZVKuk3zgfDhSaVSmoEUCgW9ZfRABEEGI6BPbrebYRiPx+NyuWCDYRiXywXy5nK5PB6Px+Nxu90gV/QvaD8pFApQI7lcLhaLoYiAwkGlUkEEkUgETRmqUvAX3aUqRUubzoogZOAzoB8VZG5yrm+BVs3IuZ6BzqpjUK2DbXqgUEGFykrOvgOwDS+J0CThv4BSqfQJCRiNdFLP8qkt+tvThUnCqxBWM+H1JggyIPGXK4ZhhMIGCLdB/CC+UqmUn0WpVMpkMplMplAoFAqFTCZTqVQGgwFUCv6FDXhBAr6YCDKghfDyyy+/SCl3pqzkrFeERvNxwQv/BcCj4pO+fzRCCMdxTqezC0sC2tOFScJ6gLDjgcYXKiX11HcmnzKZjLryfcQ4oAcGKsg+dFYR7szZIjwpRdiI78IA/ypIwNSQC4ZmMJq7IGeCswuqm1ABhV4uiAauQpfLBXnVp03mcrkgk6hUKqpScrkc2mewrdfr6bYwHHb7+aYglyIDWggvHtQTAgQs0y8BhEpJW8adySft6iB+YhywT95f1Mm5bXGf8M6GA/j3Hwgb8V0Y4F8FCZiavz88oCp31t3SmYSft3vGvyuoDwjYHwM9YXRXOAQjYGaggfQa6bXAzQQBAych3B/YBnkLCwuTSCQKhQJ+sU2GDHxCVAhDBGHDLjT7RwMqaMBBcZ0NwOtsBN15B+x1pv0XlYAj9Hxc5UKF7sw9EJq5BQlZUAiRSxn/DldAo9H0vTEIggxMcEgFgiAIEtKgECIIgiAhDQohgiAIEtKgECIIgiAhDQohgiAIEtKgECIIgiAhDQohgiAIEtKgECIIgiAhTS98UO/1ek+dOlVYWOhwOO69996eJ4ggCIIgfUYvCOHWrVvvvvvu1NTUY8eOoRAiCIIgg4tecI3OmDGjqanpvffe63lSCIIgCNLH9IIQ4sI3CIIgyOClTyfdrqmpWbVq1Z49e2BXp9O9/PLLuMAYgiAI0o/0qRBqNBqj0Thu3DjYhRXL+tIABEEQBPGhT4UwIiJi6tSpCxYs6MuTIgiCIEgX4HeECIIgSEjTCy3ClpaW22+/3Wq1ut3uq666KjY2dvXq1T1PFkEQ5KLCsizDMG63m2EYj8cDvxzHOZ1Onufdbu3gaKkAACAASURBVDfP8y6XixACvyzLejweQghEI4R4vV63200ThEOEp2AYBmIGA8MwXq+3iwhSqVQq7YVCWywWKxSKCzs24ErXwSCRSORy+YUdKzy7RCK56aaberdbrRfuqV6vX7p0Kd294PuLIAjSQ5xOp8PhoL9Op9PlcsEv4Ha73W43bEDRrFAo5HK5VCpVKBQymUwikSiVSpFIBL8qlYoQEh4eLhKJpFIpDO6DaMRPURQKhUgkEtojl8uDL7LlcrlY3JWXjmVZlmW7e0/88dHvbgF1gguA4ziGYS7sWOHZu3VLg6QXhFAmk9HxL70Iz/OffPIJzayEEIlEQnMhVIugbgK7YrEYokHGhRypUCggp9Js7Z9TEQQZFLAs29HR0dHRYbfbYcPhcMCu4ywKhUKtVqvVapWAiIgIpVKpUqkUCoVSqZTL5SqV6ryqMwDprRYhIUStVvdKOpcGfTpYpluIRKLrr78eHAtQj+A4jvoloFoEdROPx+N0Or1eL8Mw1JVB3RpCFwf9FxQUJBO2QTKhogeqCTbQ6h4N7BrqPKH4uzvAkiDvg7DKScUeaqawCxUFeEOUSqVMJpPJZPC2D7r3HAlleJ53OBx2u91ms4HO2Ww22IVfjuO0Wq1Wq9VoNBqNRqvVGo3GpKQkrVarVqs1Go1KpcI8j1wAA1cICSFGo/EipQxy6HQ66TaIE7j+qV6CuMIhPM9D/K6RSqWgrxS9Xu/zckLbNEhThf4Eag/Lsk6nE2oGEIH2bYASu1wuhmFAKaEWrDgLDZGfRaFQSKVS0FRoc0O1oAur3G43VXeh0vv3iAjvoUgk4nnevz5B7xhVeuoGoD4oZLDDMAzoHG290cYcSJ3dblepVBqNRqfTgeAZDIbExESdTgeB2O2CXCQGtBBePKAsvuBe38ECHQtAu0YAhmGcTqfVaoUBAm63G2LSNrdQ5wIiVEph09PffU+1jeLfx0BrGEKl9xmVQH3aVDXpeX0a61TOhSH+vfTCQ3xSoOcSNseFXilhVcbH2R6wA2PwOuTpw6IVMnCxkLOVHui1gm2Xy+XxeDweD81y0C0HfXVQR4SmG3gvtVptdHS0Wq0GqdNoNNieQ/qFEBXCEAHK7kujM4COx6OqSVuiPj3/VM6FIf699EI99mnuWywWOJcwZSrJ5Fznts9AwYCjBP0HEwL+VTHa/91FnG55FAKa5GOP8HKELXjh2WmdgPYXgORDHgOzlUqlVCrVaDTQJwceCJVKBf1z2LJHBiwohMjggLbMLqV2vH/jmPZ/dxGnW33MJFAj1aeFKlRWYb84goQIKIQI0m8EbO31iyUIEsqgRx5BEAQJaVAIEQRBkJAGhRBBEAQJaVAIEQRBkJAGhRBBEAQJaVAIEQRBkJAGhRBBEAQJaVAIEQRBkJAGhRBBEAQJaVAIEQRBkJAGhRBBEAQJaVAIEQRBkJAGhRBBEAQJaXD1CQRBEELXFiaC9RrpAtHnRbiGMyBcSET4Ly50NQBBIUQQ5JKFZVmr1dpxFsdZnE6ny+VyuVwMw7jdbo/HI5fLxWKxSqUihMA2IQTWHA7mRD6rQ5NzF5IU/svzvDCmcG1I4bLMYrFYLpfTaD4rNvusKOmz5GRArYVLE+JzCmHicPk+yGSyzlZX7uwQoYVdRyBBrzgtkUiCfCjBg0KIIMigx+v1ms3mtra2trY2s9lssVja29utVivDMGFhYdqzqNXqqKgotVqtVCpVKpVSqZSfpb8sp61Pcu6yzF6vl2EYGs1nxWbhUeRsc5bu+mgt4HQ6fUJ8TiFM3Ov1+oczDBMwvItDgjm2CwsDIpfLH3nkkc4k+cIY0EJYWFhI7x2tLIDDAepHUDWA7WBqHIOOznIqeleQUIbn+dbW1qamJpPJZDKZWlpaLBZLWFhYRESEwWCIiIhISUnR6/V6vV6tVve3sedB+CLjssz9xcAVQp7n29vbOzo6YNflckENCBwOUD8CYBtqQAqFQqFQyGQyhUKhVCoVCoVKpVKpVOqzaLVanU6n0WiCaYP3Im63m7po7Ha70+kE54zb7Xa73QzDQI0J6kS09tSZ74IKJESAegBcskqlgppveHh4eHi4wWAICwvryytFkF4HlK++vr6urq6+vt5kMmk0mtjY2Ojo6BEjRkRFRUVERPRuEwEJKQauEIpEoqlTp3brEHAIgK7AhsvlAsmx2WyNjY0Oh4N2Feh0Or1eHx4ebjxLVFRUr7xLLMs2Nzc3NTU1NzeDr6a9vZ3neb1eD/4ZjUajVCojIyNVKpVCoQANA/87NHyDb91yHOc5i9vtdjqd0AVit9vLy8stFktbWxvLsjExMXFxcenp6UOGDOl19zrF4/GAP8pms4ElTqeTmkddN9CclclkcrlcrVZrNBqdTgfVeawRIxSv11tXV1dVVVVdXV1bW6tUKhMSEuLj47Ozs2NjY9EjgvQiIqGj+WKzcOHCadOmLViwoM/O2Bler9dqtVosFpCK1tbWlpaWtrY2o9EYFxeXnJyclJRkNBqDbzU6HI7y8vKamprq6uqWlpbIyMjo6GioqIK7ph/fW4fD0dTUVFtbW15eXl9fn5GRkZ+fHx8f7x/T6/V2dHQE2YL0eDyNjY0NDQ2NjY2tra2tra0Mw+j1ep1Op9Pp1Go1tMXlcjm4r2klA+or0Ah2Op12u91ms1ksFrPZLBaLo6OjQbbhEfTmjTgX6kK4eKdAugvP842NjeXl5eXl5bW1tUajcciQIfA+arXa/rYOuWQJUSEMCLTk6urqQM88Hk9aWlpGRkZmZmZnLZWGhoaysrLTp0+3tbWlpKQMGTIkMTExLi5uwHppGIYpLCzct2+fXq+fNWtWVFQUhNfX1//pj4+XlZWF6XRms2XBwoVLHn5YOEqN0tjYePLkyfLy8oaGhsjIyLi4uLi4OGhS63S6HpoHmg36Co9gyJAhqampQ4cODQ8P71ZSLMuCPJvN5vb29vb2drvdDo1UGGigUCh4ngcPMwwOpP5z6F4KDw+Hekw/jqQIEVwu1+nTp0+dOnXmzBmVSpWWlgbeC6ymIH0DCmGnWCyW8vLyU6dOVVRUJCYmZmVlxcXFRUZGisXi2traioqK0tJSlmVzcnIyMjKSkpIG0VAdr9dbVFS0bdu2qVOn5uXl2Wy2aVOvfPHZJ2dcOYUQ4nYzz//jny6Wf+vtt+khDofj4MGDxcXFHMcNHz48LS3tonpZAavVWlVVBU9Bo9FkZmZmZmYmJCQEvNUMwzQ0NNTV1UEj1WKxhIeHR0ZGRkREgKqByMFYQZ+2Pjhv6dh6EE7qLVCr1dHnEmRFB5KCEYw2mw3c8rR7mAhG2MOwL/CT055s6OWNjIw0GAy9m7tYloUOeDAGLp/+KxKJlEol7W/W6XQXyWVttVrLyspOnDhRV1eXkpIydOjQjIwMvV5/Mc6FIF2AQnh+PB7PyZMnT506BePTCCExMTHQTElMTOzjQTe9SGtr69dffx0WFlZXVyf1Mr9dtFD477RZN3/19YbY2FiPx7Nv3759+/ZlZ2ePGjUqMTGx703leb6+vv7EiROnTp1qa2uLj4+Pi4uTSqUKhcLpdLa0tLS0tNhstpiYGPgrNjY2KiqqV8QDBm2ZBLS2tup0OqPRGBERAQPxoekM3bQ2m81ms7W3t5vNZolEAhqs1+thEL9Go1GdhQi+BoO+XvisDXqyqbsYLs1oNMbGxsbHx8MFdsvl0N7e3tTU1NTU1NLS0tra2tbW5vF4wB6h+5rGh4/eXC4XdDZbrVZCSEREhNFojImJiY2NjYuL02g0F3xLrVbr8ePHjx8/3tLSMmzYMKhXXexKFYJ0AQph9+B5nuO4gD7DwYjX6121atU3X3/9wtN/yhqWKfzrry+/esX0q7KysjZs2JCYmDhjxgyDwdBfdgpxu901NTUmk4njOLfbrVQqjUZjZGSk0Wjsm0a58JM1aFHBOCCpVKpUKrVabVhYWFhYWC92DIPTvqGhob6+vr6+vqWlJSYmBkaOJCQkRERECGtjXq+3paWlqampoaEBGscymSwmJiYmJgbuktFo7O5HBS6XC/zMNFmVSpWUlJSampqenh6kS9xut5eUlBQXF7e2tg4bNiw7OzstLW0Q+VGQSxgUwlDHbDbfesstLz/75JhRI4Thf3rm7/rIaIPBcN111w0dOrS/zEP88Xg84ASGbwmsVit4Uz0eD/SAhoeHQ9MtPj4+Nja217+l43m+paWlpqamoqKivLxcq9VmZGRkZGQkJyf7N1WtVuupU6dKS0vr6uqGDRuWm5uL+ocMNC6Rlg1ywRgMhgULF37x9TdCIXS7me9/3PrW22/PnDnzkmn+XjLIZLLk5OTk5GTY9Xq9dru9o6NDKpWCq/Nij9USiURRUVFRUVFjx44Fr/WZM2d++umn5ubm6Ohoo9FoMBjgm6WWlhar1ZqRkTF27Nh58+ZhXkIGJtgi7Abt7e2HDh2yWCwTJ07sl66yiwTHcbOu+9XEcWOW3L8oXB92vOzEY08+M2fu7b/97W/72zRkMOFyuZqammCSM5VKpdPpDAZDfHz84O1HR0IErKAFy/Jly5Yt+3DK5ElyueztN98YOWr0P19//dIYWC+RSDZu+n7Zhx/OvecBa3t7alrqS0v/cdlll/W3XcggQ6lUDhkyZMiQIf1tCIJ0D2wRBsV33333738t/2T5+wrF/yvfa2+/12ZzvPraa/1rGIIgCNJDsEUYFO+//967r7xIVZAQ8oeHH5ww7RqWZbHbo+9paGg4evRoeHj4iBEjBv6sygiCDHBw7FZQNDeZkpPO6RQUiURJCfHNzc39ZVIP+e8PP0y7bMKYYRl5OVnPPvmEw+Hob4uCwuVyPfTgb+fOufWnHzev+mh5/uTJX61b199GIQgyuMHWTFCo1CqrzRZ27vdSppaW7s77NUB47eWXtq39+NVpY2N0Izie//zovhn5k3/et3/gz2j1+8d+l5ma/MZLf4VdW0fHbXcvik9ImDx5cr/ahSDIIAZbhEFxyy23vrNshTBkxy97EhMT/Rd9HvicOXNm+btvv3/95BidmhAiEYnuHJUxNUr1749WnPfY/sVutx88ePDB+xfREJ1W+/Lfnn7/vXf70ap+h+O4/fv3r127dt++fcK1W/sLD9d3ww4QpFdAIQyKh5YsKTtdft+S323Z/vPuffuf/8c/n3lx6TvvvtffdnUPr9d78ODB11577Yq0ROm5XzRfnRb/w7ff9JdhQVJTUzM0I90ncERO9unTp/vFHkJIQUHBihUrvvjii9ra2n4xoLi4eMoVly//4N3a8pMrl394xeX5hYWF/WIJ5Y73t9e0dvSvDQjSLdA1GhQymezzL7786aeftm7Z4nQ68sZPePb5lwbXMJkzZ858//334eHhV1999Y9lvmWlWCxqamravXt3fn5+v5gXDBEREc3NLT6Bpubm8P6Y+81msy1cMF8sIlMvz29pqH3rzTduuPGmJ598si9tcDgc8++6a82K94amp0FIRWXV3IULd/7yS89XArlgqouOPmM6vfyZhQPh4yKe52HqV5j33Gaz0RVIGIahk56Ts2tcy+VymHBcp9PB6qFhYWGwkijOhnMJM5iK8n5n+vTp06dP728rugfP8xUVFYcPH66rq7vxxhvT0tLMZvPf//QHL58tFnzm/HNl46/n3V5YWKhQKPLy8i6qSV6vt7m5GSaAhqUPpFKpXq+HybK7WOggOjqa9XqLj5fmZmfRwPeXr7z1llsvqsEBeXjJktmzrp17y82w+7uHfrPowUe/+mrdrbfO6TMbvv/+++uvvYqqICEkNWXIrTff8O2339511119ZoYP8WGS3QeOtbW1xcbG9v3ZbTZbQ0ODcJJxpVJpMBhgAliNRhMdHa1Wq2E1bGFm83q9dEFvp9PZ0dFhNpurq6th9nOHw6FWq8PDw+lcstqzwOLSOGnAoAaF8EJgWZZhGK/XK5VKYb31/rbIF6fTWVVVVVlZefLkSblcnpeXd+ONN4KdBoPhptvmPbnt+6evGKFTyAkh35+o/k9V686HH2EYZuXKlSKRaMyYMb1b/4XVxisqKqqqqurq6sLCwqKiooxGo16vl8lkME90WVlZU1NTRkbGxIkTk5KSAqbz4YfLbr993h1zfj0lf1J7u/Xjz74QSWQvvXpvL5oaDE6ns6SkePlbr9IQsVj8/DN/XvLHp/pSCCsrKoZnZvgEZmcOPXbqTJ/Z4M+VeVl7j5b3WW8lz/Mmk6myshKyFsuy8fHxMTExw4YNy8/PNxqNvdIwhTWrabPSarU2NTXBulqwziVMbgerkcA2CC39VSgUMpkMWpyw/mXPrUJ6CxTCrvB4PGazGebdb2lpgSVeOzo6CCEKhUIsFrMs6/V6WZbVaDRqtRrcKTqdTqPRwJo7dA28izT9I8/zdAk9WLWnubm5qanJ7XYnJSWlpKTMmTMnLi7O56jnXnjxs+FZC/+xlHW7iFh82eVX/Ljzc41Go9Fo7rrrrh9++GHv3r1XXXXVsGHDemheS0sLrDZeWVlpMBjS0tImTpyYnJzcWbPP7XYXFRV98803arX62muvTUhI8IkwbNiw3bv3rPr3v//1yVqDIeKe++6fMWNG8PZ4PJ76+npYINDhcHAcp1AopFIprMkQHR0dpLvbZDIl+82xl5iQ0NTUFLwxPScyKqq+vtonsK6hMTomui/N8OGuWZNeWLO7rtl6UWchtNvtsJDvmTNnNBpNSkpKdnb21VdffZEGcovFYmgIBvyX53mn0wlOV7repMvlstlszc3NsKYVwzAMw8BiWx6Ph2VZyHuwBpZEIoEiBVbmgm25XC4Wi6lqwlsjkUhA2qVSKWRXmUwGG7CqJZhEF90cmDX1gUbvzCzDcVxxcbFKpcrMzOwi2oCaWQYWI4U8Cr92ux0qd1arFfwhLpcrPDycrvIDS7zqdDofVeM4DtQIFl+1Wq2wpFxHRweEO51OsVisVCrBIQO5HLI1za90aTofwGNDCGFZFt4feJfAZqfTCVobFhYG67hGRUXFxMTo9fpgfDU8zweMdubMmS1btrjd7qysrOHDh8fFxQVZgbXb7SaTqaGhoaampra2ViKRpJ0l+C/feZ4/duzY1q1b09PTZ8yYodVqgzyws9Rqa2vLysoqKyubm5tjYmKMRmNYWBj0okHxBAvwtrW1DRkyZOjQoTk5OV2PB7bb7TNnTN/xw3fCQJOp+Z6HHt2yZWuQhjEMYzKZwDns9XqVSiUUtcGvgmsymX517TVb/7NOe3Z1QIfTedVNt2345lv/OkRfcs3jaxRq9X/+/uteT9lms8FahiaTKT09PT09PSMjox87RHuCy+XiOA7UEdYUg5UgeZ6HbXA7wStPzi7jDIcQQliWhWY3FAvk7KqWNHEo2yE1elJh7pLL5cKiDHSX7lLFFYb4lwNQmvkEgrT7X3IXTWEQ/oB/+ZxIIpFkZmb2ri+6F4SwoaFhxowZSqXSbDaPGTPmyy+/7Kxa3V0hPHjwIDxy+uyF0HwAQB6CbeGzhwxB5cTlckFMqIuBLIHvAtay0Wg0Op0O1gfXarXC2+3xeN59841PV/3b62GkCuX9Sx65d/HiIF2ItCYInRBer5euUQ6PAF4A/wNp/oA8BNVA6nhRKpUXrw/fZDIdP3781KlTzc3NOp0uKioKWrpgj1gshqtgGMZqtVqtVovFwvN8dHR0bGxsYmJiUlJSMKuNb92y5atPV7c0N+eMGv3go7+LiYmBcIZhdu7cWVhYOGnSpMsuu6y7Q5N4nq+pqSkuLj5+/LhWqx0+fHh6ejos59vZIS6X68yZM7D8b1ZW1sSJE6kx/tw259b58269esb/+ox/96enLsu/Yn6X2dvj8Zw+ffrEiRPV1dUdHR1RUVHQXyWRSJxOp9VqbW9v1+v1ycnJUMSf96q/Xr/+pZdevH/hXcOGZpw+U/7hv1c//vgf586b1/VRlPb2dqgfwHASkUgEyx1HR0fDYocXtgCv1cFc9vuv756Z9eStoy7gcH84jisrKysqKoK1nGAtw4u9yMYliXB8EMMwsJQm3fV6vXTXv9T1KXIBKM18AkHa/c9ORd0fWkR3Bj2RQqG4/vrre7fc6wUhfPjhhy0Wy+rVq51O57hx45577rm5c+cGjNldIdy1axfomX/dhAg8A4BIJKKVHaE3AOoRNASU48J8BTdefdVwznrfqHS5ROLwsG8eOuFNzV6xes0FJDW48Hq94B+GRjOtnYA/Ry6XQ1MmPDy8W+Umz/OL7rrTdrrkruFJRo2yqLF1xdGqN5avmCYYkWQ2m7ds2dLY2HjFFVeMGDHivMIAqwIdP368pKREoVCMGDEiJyenu0sKOxyOgoKCgwcPxsTEXHnllQFbV83NzbfdNidraMbUK/I77PYv1n+TO2Lka//8Z8CKKs/zlZWVhw8fPn36dGJi4vDhw1NSUoxGo39kr9fb2NhYU1Nz4sSJhoaGYcOGjR07lq64FJCmpqbP166tqChPSUmdO2+evyfc3xioIpw8eZLjuCFDhsTGxur1eqi1sCzrdDqbmprq6+vr6upiY2Ozs7NzcnK6O5Xd3hOmB5btH5tufOfe8TrVhfeHdXR0HDp06PDhw9HR0aNHj87Kyhpco7WRQUEvCGFMTMwXX3wxdepUQsgLL7xQWFi4fv36gDEHlGu0u/z0008rnvz9S1POWb32gR8P//PTL3Nzc/vLqkHNNxs2fP3q31+YOpqGtDpcC74/UFh60qeyX1lZuXfv3tra2tGjR6empiYkJAhdlxzHWSyW2traioqKiooKhUKRnZ2dnZ0dHd2jrjKO4woKCnbv3h0dHT116tT4+HifCDzP//jjj4cPHdJqtTNmzszJyfFPhGGYoqKi/fv3y2SycePGjRgxInjPZ0dHR0lJyaFDhyQSyfjx40eOHNnDERZtbW2FhYVHjhzRaDQ5OTnDhw+PjIzsIj7HcWfOnCkpKTl16lRubu7kyZO71QPXYnU9/Mmh8hbn2PSIWyYmX5kRKRN3w51lsVh2795dUlKSk5Nz2WWXGY3G4I9FkG7RUyF0uVwqlaqqqgoqrZ9++umbb7558ODBgJHnzJmTmpp69dVXw65Sqbz88st7cva+5K9/eSr++J6rM84Zzbj22GnD7Pm/+Q2u23chLJw75zaNOzf2nALuyZ+P/v6d5ePGjfOPbzabi4qKampq6uvrFQqFRCIRi8Uej8dut4eFhcXHx6ekpKSmpvZuiclxXGFh4a5du2JjY6+88kp/OewMq9V68ODBgoKClJSUyy67rLNxsOcFWpMHDx6sqqoaM2bM+PHjg3E4C2FZtrS0tKCgoLm5edSoUWPGjOla//yx2+379+8/fPhwZmbmlVde2S05bLA4/1vSGKZTTk5UDx2SCGPNCCHCZrpYLBZelFgsht4N+DJBqVQKPQ0wLJPuqtVqoYNHo9EIvUc6nU7YgtTr9UKXWkAbJBLJlClT0O8aUvTUyQCTNdOcp1Qq7XZ7Z5Hr6+tLS0vpzBcKhWL9+vWDZUQTz/P+tVkREXk5X/84EiQWi8UQ6VukhitkFoslYHyDwTBt2jRCCM/zVqvV6/XCFyxhYWEX7ysuiUSSl5c3ZsyYw4cPr1u3TqvVjh8/Pisrq7PGmcfjOXPmTFFRUXV19ahRoxYvXtzDcYwikSg1NTU1NdVisRw4cGDZsmVxcXGjR48ePnx41w1EjuPKy8tLS0vLysoSEhImTJgwbNiwC+tZ0Wg006dPz8/P37t37/Lly0eNGnXFFVcE6SyNC1ctzE+FbZvNBhs8zwufMsdxVquVENLR0XHw4METJ05kZGSMGDECChaGYYSlCowRo7sOh0M4GKSjo0PYC2Wz2YTdWpWVlcIOLbPZTLe9Xm97ezshRCKRZGdnd9E9jFx69FQIDQaDXC6nH8+2trZ28RXt0KFDB69rNH/qtNXbf7jq3BbhjkbL0sHTqB1oZOXmHqs6mqA/Z1BocbPlyfN9tiESibrbKvKhrq7uz797tPhoEfF69cbIvy39x5VTp3YRXyKRTJgwYfz48SdPnjx06NCmTZvi4uJSU1P1ej18GwPTl9TW1tbW1iYkJOTm5t5yyy29+60YzAo0ffr0EydOFBUVbdy4MS4uLiUlJSoqCr7bYVnW7XZ3dHQ0NjbW19fX1tbGxMQMHz582rRpwY+r9Hq9nYmlQqGYOnXq+PHjd+7c+e67706YMGHSpEkXVpEViUQ+HbcikWj37t1lZWVjx4694447BuMsvsjgpRf6CCdPnnzPPfcsXryYELJgwYLY2NhXXnklYMxB3UfI8/x106flydwLRqRLxSI3y71XcMoSm/LJF7gM0AVSVVV144ypy64dHx/2/46vL4rLD0vCP9/w7UU9b21t7azpV/45b2j+kFhCSF17x5M7jj74zN9um3d7kCl4PJ6qqqqqqqqOjg6n08myLAwzjomJSUtL69YX3IWFhbt27PAwzOQrrpg0aVLwB3o8nurq6srKyra2NpvNZrfbYcCnWq2OjY2Nj49PTEwMfoRLSUnJE48sqaupFhFiiIx6/tV/Tu5ysj2LxfLzzz+fPn16/PjxEyZMuGDd4nm+vLz84MGDtbW1PUwKQS6YXhDCdevWPfroox988EFtbe1TTz1VWFiYlpYWMOagFkJCiNvtfvXll9av/YznWIlcvnDxA799+BEcw9YT9u3d++gDi+OU0iiV/Ghj2+hJ+a+/9/6FDdkPniWL78trr5qe/r+xoB1uz7yN+46cON2XE2WxLLt4/l1NpcdmJkRIJaLtdWYSlfDp+q/7fqnhI0eO3HPrzS9PHZUdE0EIqbbY/rSt8Lk33736mmu6PrCtrW337t2lpaXZ2dkjR45MSkoK/gY2NDSUlJQUFxer1epx48b1fCgQglwwvfNB/RdffPHll19qtdolS5aMHz++s2iDXQiRiwHHcRUVFY2NjdnZ2REREX1wxvEjsr+4Q1B5hwAAIABJREFULs9n/Y0H/ntoxXf/7cvv0Jc+//fWnzctGT+chqwtrmhMznnz/Q/6zAbg5muv/k2SBlQQaLE7f7u9eF/R0WAOt9vtRUVFR48eZRgmMzMzOTk5KSnJfxIWjuPMZnNdXV1lZWVlZSV0xeXm5vZwcC+C9Jzeac3MnTu3s28HEaRrJBJJRkZGRobvnJkXFf/qn7fPF9Fbt/aztdedM7/5vNzUG9b90Nd2EFJRXp6dd6UwJFKj4pwOhmGCcfNqNJr8/Pz8/PympqYzZ84cO3Zs8+bNbrdbp9PRb0VgriWYWj0lJSU/P7+7I1cR5OKBbj0k5JiUf/n2ijPCL2GsLqbJ4Q7+04hewct6FNJzxuiLCFFJJUHKTy8SsA7AdT5qpjNiYmJiYmImT55MCGFZ1mq10vGcSqXS59MFBBk4oBAiIceTz/3tqssnS8Xi6WkJhJAqi+2Jn4qee+kffbySjlSucHhYtex/76CX550c1/fL+OXk5h6qbcpL/N8HA7XtHboIY0/6v6VSad84uhGk52AFDQk54uLitu7e+wOjvnbttqvX/PiHX8peX7Xm5ltu6WMz7lx4zxt7ioUhKw6fmHXT7D42gxDy/Kv/fO6X4zsr6mG3qL75wc0H/vHWO31vCYL0C70zWCZIcLAMglC8Xu+vZkxzNNVfkxwlEYu2VjeLI2I2bd3WLwu719fXP/OnxwsOHSI8nzl8+POv/rPrlWQQ5FICXaMI0j+IxeJH//hEW1ubh2E8Hs8su33GjBn9ooKEkPj4+I/WfNYvp0aQfgeFEEH6B1hUWavVzp49mxCyevVqOg8ngiB9CQohEopUVVUVFBSwLOtyuSIiIqZOnXqxv+L3Z8eOHVardf78+bB74403fvTRR3FxcZ3NR4EgyEUCB8sgIQTP86dPn16zZs23336blJSUk5OTn58vl8vff//9vXv3wgzyfWNGQUFBUVHR3Llz6chMvV5/6623fv3119XV1X1jBoIgALYIkZCgubn56NGjR44c0ev1Y8aMGT16NP2mLS0tbfTo0bt27dq5c2dmZub48eMTExMvkhler7e4uHj37t0SieSOO+7waYYmJyfPnj17/fr1SUlJ06ZNwxX4EKRvwFGjQQHLxHR0dDgcDofDASu5wEr3sFiaVqtVq9V9/CEa0jUsy9bV1Z06daqsrIxl2ZycnK6X4nO5XIWFhYcOHRKJRDk5OTk5Ob04+1dTU1NpaWlRUVFERER+fn56enpnMT0ez759+/bv35+QkHDZZZelpKRgvrqoMAxD12aSy+X41X8IgkLoi9PpbGtra2trM5vNZrMZNhwOB6x0o1ar1Wo1LNrJcRzDMC6Xq6Ojw263O53OsLAwvV4fHh6uPxecTbhv8Hq9ZrMZFiGqq6traGiIjo5OTU3NysqKjY0NXk7q6+tLSkqOHz/OcVxqampycnJ8fHx0dHS3FmuFJfdqampqamrKy8u9Xm9WVtbIkSO7WKdMCMuyR48e3b9/P8Mw2dnZmZmZSUlJvVtGe73etrY2k8nU3t7udDodDodKpQoLCwsPD09OTh4sC4V2TUdHR1tbm/Usdrvdbrc7HA6Xy+V2u10uFzlX/EAUxWKxXC5XKBQymUyhUEB9V/gL+IRgfWXwEqJCyPO83W632WxWq9VisbS3t1ssFovFYjabeZ6POIvBYIBfnU533lwOrcb29nZIDTYgfZlMptPpwsLCNBqNTqfTaDQgqBqNRqVSqdXq/ho0P7jgOM7j8bjP4nA4nE6nzWaDtQBbW1vb29t1Ol1sbGxcXFx8fHxSUlIPb2xbW1tlZWV1dXVjY2Nra6vBYDAYDOHh4VqtFh4cIUShUPA8zzCMx+NxuVxWq9Vms7W2tra0tKhUqoSEhOTk5JSUlAte6NVkMpWWlp48ebKlpQVSi4mJiY2NDQ8P71bJy/O82WxubW1tbm42mUxNTU0tLS1hYWExMTF6vV6tVqtUKrC/tbW1rq4uJiYmIyMjKytrsEwK6vF4Wlpampubm5ubW1tbW1tb29raFAqFwWDQ6/VhYWHwAkJ1lmpYwHtIcxrDMAzDgGRS7RRuQ1Z0Op1ut1sqlYJ8AnK5XCaTKZVKmUwmlUphQyKRqFQqEFqpVCqTySBQLpfDL7ZH+4VLTQg5jhNmVpfLBcWl4yzQerPb7Wq1WqfTwTJy0IwLDw83GAwXYzk0KK/BuQo4HA6omTqdTqfT6fF4aDVTLpfTV4i+KvCOwfsjkUgkEgm0MqEeKpVKpVIpfZH6S1Z5nv941apVK1d02GxhYfoHHnzotrlzgy+sLRZLY2Mj1EisVqvT6YSChmEYWHKW1tPhFyoTWq2WNsSNRmO3Gm3dgmVZcA9YLBZYhhDWSXe73RKJBJ6UUqmETGU0GiMjI3u3UeV2u6urq2tqapqamkwmk81mA38DVKdUKpXwufM8Dyu5g8eivb29o6ODGgaTgkZHR3c2iRrLstXV1SdPniwtLVUoFFlZWcOGDYuLixs4jR6v19va2gqKbjKZTCZTR0cHXF1UVJTxLH3pjKHaCUWQx+OBuhFsuN1uj8fDcZzT6QSh9Xg8LMtCoNvt9nq90B6F1xl6XgghoNaQweguOfvuwwYYQEMgBQiEEoNuU6GFUgW2RSKRMK/SU1M6qzFcMgxoISwpKYFsxHEc+CEhr8A2zVWQmVwuF8Mw8EShuqdSqeAXKu+03NRqtRqNZkDVvLxeL9VvqITCFcGl0Uuml8+yLMuyhBCXy8XzvP8tAqVUKBSgoFBKqs4ClWIosjUaTc+zOMuyUql0/p13RKnEf3ngznCdtsXc/uy7q2T6qHe6XFSopaXl9OnT5eXldXV1EokkLi4OWl06nQ5MBdmTSCT0bUcAjuPA8QBueahOCSPQ/A91BZ1OdwG1BJ7n6+vry8rKTpw44XQ609PTU1NT09LSgl/yvrdob283CWhpadHr9SDn0dHRMTExBoPh0iis4e2G15kQ4na7eZ6HooDukrPvPmzAgTSElg+EECgx6DbtDQUZhm2e5+n06ORscSQ0iZ6C4v8+CpVVGBgw1ykUioAlsI8k+/+rVColEsk111zTuwX4wBVCnud//PFHj8cDtxKaO3CbYBvCqedBpVJ1dtNDEOrbgbYUNK2gfUC7SWw2G7RsoEUFfmCj0RgVFRURERFMPquoqPjz478/feqUVCJ2MZ6MpPh1b/5VGOGGh/7yj7c/yMnJ8TnQarUeOXKkqKjI6/Wmp6enp6cnJSVptdpevANIr2M2m8vLy8vLyysrK+VyeVJSUkJCAvhpe7eawjAM9NODh7O5ubmlpUWpVEZFRUWfJSoqCrve+wsf4QSEikuBOrp/CtACDjJlCii0QqHIycnp3UrPwBVCpG/gOA66M2nR09zcbLVaIyMjoactMTExJibGP9tVV1ffNOvaNx+ZP3lUFiHkuWWfjcrNmfOracI4H321iY1I/u2DD9KQpqamHTt2VFZW5ubmjho1qi8XwkV6C57n29raamtr6+rqGhsbTSaTXC6HbnXojYM+VGiSgnOC1lChZASHBwA1M+g7sFqtZrPZ4/EYDAaj0Qg1s+jo6F73MyOIEPyOMNSRSCRQhKWmptJAlmWbm5th7OWBAwesVmtycnJqauqwYcPo2jqvvfLy3xbNARUkhCjkMpnMtzkuk0qcZ/11NTU1P//8c3Nz8+TJk2+++Waszg9eRCIR9MCNGjWKEMLzvM1mg4qU1WqtqamBXnDQOZA92iyA7ivw24PnVqPRaDQag8EwZMgQcE6gbwDpY1AIkQBIpdK4uLi4uLhx48YRQhwOR3V19ZkzZ1atWqVSqXJzc8eNG3dw//6X7/gLPSQvK2PTnoOzZ04RprNlf9HDTzxjMpm2bdtmMpmmTp2am5uL7utLDJFIBGMyU1JS+tsWBLkQBtCAEWTAolarhw8fPmvWrMcee+yGG26wWCzvvPOO0+ViBd7/qyaOPlVe/e6nX4Prn+W411et6/AQs9n8ySefpKWlLVmyZNSoUaiCCIIMNLBFiHQDkUiUmJiYmJg4c+bM48VH/7PzwLyrryCEeL38hu17UhNiXlvx2YdffGfQh1ntjtFjxk6cnC8SiR566KGL8VEKgiBIr4BCiFwIKpXqn2+8dfX0qWKReHreiHlPvpI3PH3OtIk3Txn/+dY9Ryobnnjq6ZycnKysLPzsAUGQAQ4KIXKBREZGbtux64W/Pffs4ieXPnjH7CkTIHzm+JHvf/3jqbLSu+66q38tRBAECQbsI0QuHIPB8M8339ZoNFQFgftumL5508b+sgpBEKRboBAiPcLtdmvVvs5PuUzKcWy/2IMgCNJdUAiRHqFQKBwuN3vu5BFmm12t7usF3xEEQS4MFEKkp8yZe/vz//6aTlHEctwf3//0/gcf6l+rEARBggQHyyA95c9/efqpJ/44/dEXp4/N8XDctsPFt91+193zcSI9BEEGByiESE+RSCSvvPZ6Q0PD4cOH5XL54/8YZzQa+9soBEGQYEEhRHqHuLi466+/vr+tQBAE6TbYR4ggCIKENCiECIIgSEiDQoggCIKENCiECIIgSEiDQoggCIKENCiECIIgSEiDn08glyAsy7rdboZhXC6X2+1mWZZhGLfb7fV6XS6X1+t1u92EEJfLBfFdLtf/ZsZhWZbt3kSpLMt6PJ4e2iyVSmUyGWzD2lUSiUQul9NduVwukUikZ5HJZGKxWC6Xi0QiGkEsFtN0cAGsgDAM4/V6PR4PPOWAeYDjuOAfqEKhEIlEPiFi8f/aGMIHIXzKEomEbiP9yyAWQp7noThjGIbjOK/XyzAMOZuhPR4Px3FQQtGYTqeTEOJ2uyECy7I+iZBOXgx4eYKxSpi5xWKxQqGAbZ+iTVhmiUQieJcgDv2lISqVCuLA4VAO9so9HFw4nU6Hw+FwOGDDKcDlcsEvKJ9IJJLL5QqFQqlUyuVymUwml8tBSODGwkLB4eHhUIRBIJzlAm6vsHS7YIRqCpmQ4ziapQkhDMMwDCPM2JDneZ6HCJCxffK8TCaTSCQBxRJ0FHIp5FuZTCaVSiGPKRQK2FUqlcINiUTSwyvtyS1iWdbpdHo8Ho/H43a73W43bLtcLrg5UOOhETiOg12oDHm9XrhkuCIiUClhHuiWRMFt9wkRFhe0SCHnPmWh3ArPKMxO8Ixgmz5EajDd9smBPtosvDRyNkt0dqx/BCIouLqOFjA1Gj6QS62BaxnP86tXr3a5XDS70Eoc5DzQBvJ/7d1rbBRVH8fx2Z29tVvSciugJChEQqAEyiWYJhJo5OYlUdAQiGiMpSqIUV8IMZJo1ISgiTGK+kIhUYMhYtJE8YUQFUESEpUEhBikKpcIhcaWlm27M7M7z4vzcJ55Zq/tbne6e76fF83Odnb2vzPnnN+Z2e1W00SbloviqIuD5EwaTdPE8FdbWyt7gvyVGCW1DB1DdJ58ynY2bnnmoaUMbc4xSw5nIqe7urq0mzEsHtXf3y/GNfFwMRyIFxiJREQblaO8HLNkAIjbQiQSCYfDYuArwkEqnkQiEYvFbty4cePGjb6+vt7e3lgsJu7puykYDEaj0erq6urq6qqb6uvrxY2Iw0h7dR4SwSnbkggDZ8MTrVS0W9M0+/v7u7u7nfkxMDAgc0VsLRKJiJ4l+oXoVnLSpmma7FaCayAWRGsXRHdwnanLc3dZhkgL2bbD4bBo1eLOYDBYU1MjmreIc9HOxaKsdtj3+JA4xw1nWMr5vaZp8iAKmfJVS8lm55xe07Senp6E41vyU69niKPsKk+WkWW1tFvLsrKQ5bhkCuDW1tbi9vGRG4Q+n++ee+4xTVPOleQkbiQ3aF3XnUeourp6mJ5IDGFioiDOFcT1QDlmiQuD8qcgTpjEcCOGDJEc4kban3K4GdqlNjGWiTM2eSbX19cnQ07csCwrGo3W1NTU1NRUV1ePGjWqrq7u1ltvjUajIvyi0eiIPegjmTjP025GVOHEnEyMd2LAlRM17Wa8yUXBNRALznrEqbk845EXSMTZqoix1CuQlcQ1bigly/W2tAE8HPtq5Aahpmnjxo3zuoSRy/nu0RCI1BTkFUXxs6en59q1a/J+Z4iKSYl4CyTLVTIZ0mIaGA6HxRlbVVVV9U319fVTp04VOScm8kPfFygh1wU6oECp53xO0Wgp/qHbiA5CDB9xyX6wjUxclRVvgeS81iEvoBWjXgAYLgQhBkHEJycEACoJb7oAAJRGEAIAlEYQAgCUVoT3CC9fvvzRRx+dOHHCMIyvv/668A0CAFAyRTgjvHLlytWrV2fOnPn9998XvjUAAEqpCEHY2Nj47rvvPvjgg4VvCgCAEuM9QgCA0nypX32UqrOz88iRI6n333333aNGjRK3f/nll8WLF8disSzbmTdv3tmzZ+X3CESj0XPnzvGVIgAAD+X1YZmOjo69e/em3r9w4UIZhPloaGhoaWlZt27df587ECAFAQDeyisIZ82a9cUXXxT+ZH6/PxqNjh49uvBNAQBQFEV4jzCZTHZ1dfX29tq23dXVdf369cK3CQBAaRTh7wivXbvW1NSkadqkSZMWLFgwefLkw4cPF75ZAABKoAhBOGHChPb29sK3AwBA6fHnEwAApRGEAAClEYQAAKURhAAApfEf6oH/Y5pmIpGQi/F4PJlMOlcwDMN1j1MikTAMI58nikQiPp8v0291XQ8Gg647g8FgIPC/Puv3++X3NAEYsvILQsuyLMuSi4ZhOIct1yDlGsWSyWTqIDUwMJD2e+Zs247H40OoMBgM6rqeer+u665hKxAIOMe1qqoqeTsUCvn9/z1flyNm2sFRBeIYiZ/imIqf4nDH43Fxv1hH0zRx2zRNy7LkcRSLmqORyOaRSCRM0xTP5Tp84XBYHgjBeWhSpR7l7C8q02+dJUnyJQiu9uxqHs6gdb6oQCAgV3M+xFV5JBKRt0OhkHOfuPaA3+/P/hVRzk05X4uz57qkzidcO8SyLOeis+O7Hut6otQtu4YUV5GZfpWnfNpDlglNavOT96fOopxH1int/s+0cqbmnWn9TNvP+Sgtw6vI+djhmP+N3CC0bfu9997r6+tzNVNXeGTvoq5mlHYPZpqY+3y+oX0DXE9PT9oenrMH9vf3y9vOji3vd44FsvHJPSAHNefAJFeTL1PuIudqzr2adlzL0tadRA5JMmnkkC13gniBYjiTWSVeqdiIDD9ZvPgpjqn4KV6L6E6iZjGZqKur8/l8oiPJX8nTKbkHZPOojBmGKyoyNSdnhDgf4mqfzkNpGIbzV9evX3fNL7NPGV2tQsg0XxRS88N1jAKBgHPiWFtbK3u667GuESPnfNRVZKZf5SmfKwRpJ+hC6gUJeX/qLMo1OZDS7n/LspwtROru7k47P8u08Uzbz/koLcOryPnYUCj07LPPZmk8QzByg9Dn8z355JPJZDJLM1WZbHzynFgOas6BSa4mzz/kmJhIJGRPcEZy2nEtS1t3cuWlDGk5BdF1XYxfYuQSo5IrxsRGZOxlmTPCSdd15+iQ59wFwy0ajXpdAnIY0QHD+x9ZOE/1vK0EAMoanxoFACiNIAQAKI0gBAAojSAEACiNIAQAKI0gBAAojSAEACiNIAQAKI0gBAAojSAEACiNIAQAKI0gBAAojSAEACiNIAQAKI0gBAAojSAEACiNIAQAKI0gBAAojSAEACiNIAQAKC3gdQHZWJZlWVba+03TTPsQ0zQTiUSmDdq2PTAwUJQastB1PRgM5r9+MBgMBDIeiFAo5Penma/4fL5IJJL2IeFw2Ofz5V9AKRmGkUwm5WIikTAMw7noPLLxeFyu7DyyzgaQTCblFpLJZDwedz7ctu18nkjTtP7+/uylCnk2oSE0Gxe/3x8KhfJfPxQK6bqeZYVMrUXL2paEQTXpSCRSePMb7q5qGEaWgcIrVVVVea6ZT/MIBALZj1rOjfj9/nA4nP1ZcrYNXdfzacl5jlrBYDAcDtfX1+dcc1BGbhDatv3BBx/09fWl/irLAQ4EAllCJWeHH+wG00odZLMzTTNLB047HGtZRwpnALgMNqRde2xQw0faMly57upprvLC4bBcORgMyoHe2QCcndnv9zuHkrq6Otm1XL0xdT+kjkFppyB5NqEhNBsXZ8DnI+ehyZIrOVNnUE16YGAgU/PL33B31ZzzBk+kzsYyyad5ZDlhyHMjyWQyZ0k524ZrDppJllHLyTRNXdcfeeSR4h6+kRuEPp9vy5YtXldRaQYb0q4hclDDx0g+MR35/H7/oJJgsLEBQBq5QYjhoOv6YGdS+V+uAYByxIdlAABKIwgBAEojCAEASiMIAQBKIwgBAEojCAEASiMIAQBKIwgBAEojCAEASiMIAQBKIwgBAEojCAEASivCl2739vZ+8803J0+ejEQi999//9y5cwvfJgAApVGEM8JXXnllz549NTU1sVjsrrvu2r9/f+HbBACgNIpwRvj666/L/9RTW1v7/vvvP/TQQ4VvFgCAEijCGaHz/9UZhhGNRgvfJgAApeGzbbtY2/rzzz8XLFjQ1ta2ePHitCs0Nzfbtj19+nSxGIlE3nzzzVAoVKwCAAAYrLwujf7+++8NDQ2p9x86dGjJkiXi9tWrV++7775t27ZlSkFN02pqasaOHTt//nyxGA6HA4EiXJsFAGDI8sqhGTNmWJaVZYVr1641NzevW7fuxRdfzLLamDFjlixZ8thjjw2uRgAAhk0R3iPs7u5euXLlmjVrtm/fXvjWAAAopSJcmXzppZdOnz49ZsyYZcuWaZo2ceLETz/9tPDNaprW29vrPBNNJpOGYeTzQMuyTNMc2pMODAwM7YHFEgwGdV0vzROlXpqOx+PJZLIo2895vJLJZDweT/urRCKR9ghmOrJpj1qW7cfj8UzvjhuGkUgkMhad+enylM/286Tr+jC9xV6yRojsfD5fJBIZwgMDgcCg3ngKhUKDOuL5V+X3+8PhcJ4r67oeDAazrxMMBmfPnu3z+fLcZj6KEIRbt2594okn5GL+rzk727Y///xz54jj9/vz7PaBQCDn3sxkaM2uiEzTLNZAmfOJUq94h8Nhv7843zeU83hl6SGZ+kMgEHB+SlkaPXr0oLYfDoczdaR8RoRCGslgR5wsEolEnlPDwSpZI0R2tm0PbdZlWVb297NcBjs/y7+qZDLZ39+f58qZZsBOuq43NDSMuCCcMmXKlClTCt+Oi8/na21tLfpmgUrCXysBheO7RgEASiMIAQBKIwgBAEojCAEASiMIAQBKIwgBAEojCAEASiMIAQBKIwgBAEojCAEASiMIAQBKIwgBAEojCAEASiMIAQBKIwgBAEojCAEASiMIAQBKUysIjx8/vmvXLq+rqBA7d+787bffvK6iEiQSiccff9zrKirEsWPHPvzwQ6+rqBA7duw4c+aM11WUglpBePbs2ePHj3tdRYU4evToX3/95XUVlcAwjH379nldRYWgjxfRkSNH/v77b6+rKAW1ghAAABeCEACgNJ9t2yV7skWLFp0+fToUCpXsGV1M0zRNs7q62qsCKkksFguHw4FAwOtCKsH169dra2u9rqISGIZhWRZ9vCgqo4+3tLTs3Lkz+zolDcK+vr6BgQGfz1eyZ3SxbduyrGAw6FUBlcQwDA/nNBWGnVks9PEiqoxmGY1Gc76KkgYhAAAjDe8RAgCURhACAJRGEAIAlEYQAgCUVt6fix2y9vb2tra29vb2cePGbdiw4Y477vC6ojJz4MCBAwcO1NXVbdq0afLkyV6XU65M0zx48ODhw4f7+voaGxs3bNjAxx0L9+233544ceKFF15gZxbi4sWLH3/88eXLl6dOndra2jp69GivKxpGip4Rbt68ub29fc6cOb29vXPnzj158qTXFZWTvXv3trS0NDY2xmKxO++8s6enx+uKytXPP/+8ffv22traWbNm7dq1a82aNV5XVPYuXLiwcePGbdu2mabpdS1l7PTp042NjZ2dnQsXLuzs7Ozo6PC6ouGl6J9PWJYl/0r04YcfnjZt2o4dO7wtqYzMmTNn69at69ev1zRtyZIla9euffrpp70uqiw52+H58+dvu+22jo6O+vp6b6sqa6tWrVq9enVra2ssFuPP6oesubl56dKl27dv97qQElH0jND5XQnd3d2VfdZfXL29vSdPnmxubhaLzc3NR48e9bak8uVqh8FgsKamxsN6yt3u3bsnTpy4fPlyrwspb/F4/PDhw8uXL3/nnXfeeustFb5bv2KDMJFI9KXjWm3//v2nTp1qaWnxpMhydOXKFU3Txo0bJxbHjx//zz//eFpRJbAsa8uWLc8//zwnMUN2+fLlHTt25PwyLeR04cIF27Y3bdo0MDDQ0dExb968in/zqGI/LLNv376nnnoq9f4rV67IseaHH37YtGlTW1vb2LFjS1tdGQuHw5qmmaYpzmYMw6iqqvK6qPKWSCQeffTRmpqa1157zetaytjmzZtfffXV8ePHnz9/3utaylsgELBt+7nnntuwYYOmabFY7O23396zZ4/XdQ2jij0jXL9+fU86MgWPHTu2du3affv2NTU1eVtqeZkwYYKu65cuXRKLly5duuWWW7wtqawlk8mNGzdevXr1yy+/rIDvdfSKYRhtbW0vv/zytGnTFi9erGlaQ0MDF+2HZtKkSbquy8/ST58+veKv+lRsEGb366+/rl69evfu3UuXLvW6ljITDodXrVq1d+9eTdP6+/vb2toeeOABr4sqV7ZtP/PMM2fPnm1ra+PEuhDBYPDcuXMHDx48ePDgZ599pmnaV199NX/+fK/rKkuRSOTee+89cuSIWPzxxx9nz57tbUnDTdFPjc6dO/fixYu33367WFyxYsUbb7zhbUll5MSJEytXrmxqampvb58yZUpbW5uu614XVZYOHTq0bNmyGTNmRKNRcc8nn3wyc+ZMb6sqd+Lzt3xqtBCnTp1asWJFU1NTZ2fnv//++90Nhb2rAAABOklEQVR338mPBVQkRYPwzJkz/f39cnHMmDEyFJGPrq6un376aezYsYsWLfL7Fb2uULienp4//vjDeY8zFDE0hmGcOnWqsbGRllmInp6eo0eP1tXVLVy4sOK/mkDRIAQAQGDGBABQGkEIAFAaQQgAUBpBCABQGkEIAFAaQQgAUBpBCABQGkEIAFAaQQgAUBpBCABQGkEIAFAaQQgAUBpBCABQGkEIAFAaQQgAUBpBCABQGkEIAFAaQQgAUBpBCABQGkEIAFAaQQgAUBpBCABQGkEIAFAaQQgAUBpBCABQGkEIAFAaQQgAUBpBCABQGkEIAFAaQQgAUBpBCABQGkEIAFAaQQgAUBpBCABQGkEIAFAaQQgAUBpBCABQGkEIAFAaQQgAUBpBCABQGkEIAFAaQQgAUBpBCABQ2n8AigQnIcRitm0AAAAASUVORK5CYII=", + "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" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = -2.5:0.05:U₀*tf+3\n", + "y = -2.5:0.05:2.5\n", + "\n", + "# Generate streamlines in a frame translating with the plate (i.e. windtunnel frame)\n", + "plate, ambient_sys = states[end]\n", + "fs = Freestreams.Freestream(-U₀)\n", + "\n", + "Plates.enforce_no_flow_through!(plate, motion, (ambient_sys,fs), tf)\n", + "\n", + "streamlines(x,y,(plate,ambient_sys,fs),ratio=1,ylim=(minimum(y),maximum(y)),legend=false,title=\"Streamlines and vortices\")\n", + "plot!(states[end],color = cgrad(:RdBu,rev=true))\n", + "#plot!(size=(400,400))" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xwake1 = 0.5*tf;\n", + "xwake2 = 0.75*tf;\n", + "w1 = induce_velocity(xwake1 .+ im*y,(plate,ambient_sys,fs),tf);\n", + "w2 = induce_velocity(xwake2 .+ im*y,(plate,ambient_sys,fs),tf);\n", + "\n", + "plot(title=\"Wake streamwise velocity profile\",ylabel=\"\\$y\\$\",xlabel=\"\\$u\\$\",xlim=(-2,0))\n", + "plot!(real(w1),y,label=\"\\$x = \\$\"*string(round(xwake1,digits=2)))\n", + "plot!(real(w2),y,label=\"\\$x = \\$\"*string(round(xwake2,digits=2)))" ] }, { From 89016d255e2847a21f2a259237c2076b7ff781e2 Mon Sep 17 00:00:00 2001 From: Jeff Eldredge Date: Tue, 29 Aug 2023 15:23:39 -0700 Subject: [PATCH 10/11] Updated the airfoil in uniform flow notebook --- .../notebooks/Airfoil in uniform flow.ipynb | 1346 ++++++++++++++++- 1 file changed, 1315 insertions(+), 31 deletions(-) diff --git a/binder/notebooks/Airfoil in uniform flow.ipynb b/binder/notebooks/Airfoil in uniform flow.ipynb index c19d2e9..9717ad7 100644 --- a/binder/notebooks/Airfoil in uniform flow.ipynb +++ b/binder/notebooks/Airfoil in uniform flow.ipynb @@ -32,7 +32,6 @@ "outputs": [], "source": [ "using Plots\n", - "pyplot()\n", "default(grid = false)" ] }, @@ -161,7 +160,85 @@ "outputs": [ { "data": { - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nO3deXxU5b0/8OcsM8lkTyaTZLKShCQQIggBCSibLOLSVlu11oLr7dVrtfV1XXv701rbXrWLt1ZbxXqvfVlXXMCltKCgICgCYQlbNgJZJslk9n05y/P74+AYsyAwQ2aS83m/7uu+Dk8ezvk6Hf3kOed5nsNQSgkAAIBasfEuAAAAIJ4QhAAAoGoIQgAAUDUEIQAAqBqCEAAAVA1BCAAAqoYgBAAAVUMQAgCAqiEIAQBA1RCEAACgaokVhDab7Te/+U28qwAAABVJrCA0mUxr166NdxUAAKAiiRWEAAAAYwxBCAAAqoYgBAAAVUMQAgCAqiEIAQBA1RCEAACgaghCAABQNQQhAACoGoIQAABUDUEIAACqhiAEAABVQxACAICqIQgBAEDVEIQAAKBqCEIAAFA1BCEAAKhabIJw06ZNF1988YwZM37xi1+Iojjkpx6P59Zbb21oaDj//PNvvPHGY8eOxeSiAAAA0YtBEHZ2dl599dW33377q6+++o9//OP3v//9kA6U0oaGhr/85S9///vfdTrdJZdcQimN/roAAADRY6LPpIceeqilpWXt2rWEkH/+85+33357Z2fnaJ37+/uNRqPVatXr9cN/2tTUtHr16gMHDkRZEgAAwGnioz/FoUOH5s+frxzPmTOnq6vL6XRmZWUN6dbV1WW329esWXPZZZeNmIIAAABjLwZBODAwEIm97OzsIS0RP/7xj1taWlwu1yuvvDLaqRwOR0tLS2VlZaTlv/7rv2699dboiwQAABhRDIIwMzPT6/Uqx8qBEodDvP/++4SQTz/9dOXKlS0tLcXFxcP7ZGdnV1RUfPDBB5EWo9EYfYUAAACjiUEQlpeXt7W1Kcetra3p6emnuPO5YMGCnJycI0eOjBiEhBCNRlNRURF9VQAAAKcjBrNGV61a9dZbb5lMJkLIU089df3117MsSwhZs2bN9u3bCSHHjh3r6elROq9du9bhcEyfPj366wIAAEQvBiPCefPm3XHHHdOmTdPpdJMnT37nnXeU9rfffjscDl900UUdHR2rVq2ilIbD4fz8/DfeeKOgoCD66wIAAEQvBssnFIFAwO/3n+KmqN1uT0pKSk1NPcVJsHwCAADGWAxGhAqdTqfT6U7RIScnJ1bXAgAAiBXsNQoAAKqGIAQAAFVDEAIAgKohCAEAQNUQhAAAoGoIQgAAUDUEIQAAqBqCEAAAVA1BCAAAqoYgBAAAVUMQAgCAqiEIAQBA1RCEAACgaghCAABQNQQhAACoGoIQAABUDUEIAACqhiAEAABVQxACAICqIQgBAEDVEIQAAKBqCEIAAFA1BCEAAKgaghAAAFQNQQgAAKqGIAQAAFVDEAIAgKohCAEAQNUQhAAAoGoIQgAAUDUEIQAAqBqCEAAAVA1BCAAAqoYgBAAAVUMQAgCAqiEIAQBA1RCEAACgaghCAABQNQQhAACoGoIQAABUDUEIAACqFpsg3L59e11dXWpq6vz581tbW4f81OPx3HTTTSUlJcnJyfX19Zs3b47JRQEAAKIXgyAMh8NXX331/fff73a7V6xYccMNNwzpEAqFqqurt23b5na7f/SjH1155ZU2my366wIAAESPoZRGeYp169Y98MADykDQ7/fn5ubu3r172rRpo/VPS0vbtGnT/Pnzh/+oqalp9erVBw4ciLIkAACA0xSDEWFra2tdXZ1ynJKSUllZOfzuaMT27ds5jqutrY3+ugAAANGLQRA6HI60tLTIHzMyMux2+4g9+/v7V69e/eSTT2ZlZY12qkOHDjGDPPvss9FXCAAAMBo++lPo9fqWlpbIH51Op8FgGN7NarUuX778lltuufXWW0c7VXZ2dl1dHW6NAgDAmInBiLCmpqapqUk59vl8HR0d1dXVQ/o4nc5LL7105cqVDz30UPRXBAAAiJUYBOGll14aCoWee+45v9//6KOPzp49e8qUKYSQl19++YknniCE+Hy+ZcuWGQyG6667rrGxsbGx0el0Rn9dAACA6MUgCDUazfr16//2t7+VlJTs37//73//u9LucrmsVishZGBgQPn/t31p37590V8XAAAgejFYPhFDWD4BAABjDFusAQCAqiEIAQBA1RCEAACgaghCAABQNQQhAACoGoIQAABUDUEIAACqhiAEAABVQxACAICqIQgBAEDVEIQAAKBqCEIAAFA1BCEAAKgaghAAAFQNQQgAAKqGIAQAAFVDEAIAgKohCAEAQNUQhAAAoGoIQgAAUDUEIQAAqBqCEAAAVA1BCAAAqoYgBAAAVUMQAgCAqiEIAQBA1RCEAACgaghCAABQNQQhAACoGoIQAABUDUEIAACqhiAEAABVQxACAICqIQgBAEDVEIQAAKBqCEIAAFA1BCEAAKgaghAAAFQNQQgAAKqGIAQAAFVDEAIAgKrxsTqR1+u1Wq0lJSUcx8XqnBANSuWwGCKEyLIkSGFCiCQLoiTynIZnea1Gx3Majo3ZFwAAYJyKzX8Hn3nmmYceeigvL08QhPXr10+fPn1Ih3vvvff9999va2t75pln7rjjjphcdOKhlAbCXn/I4wu6AyGPL+gMhP2CGJJlWZJFURZkWZJkUZIlSiVRFmVZpJSKkkCpTAmRZIFSSggRJYEQQhiGYzhCCEMYlmUppQzDMgxDqUwplaksU4kQyrEaluV5ltNwSRyn0fBaLZ+s4ZK0mqQkTYpWk8yzGg2fpOGTeJbX8ElaPon7qkWj4bXx/dAAAKIUgyDs6el54IEHdu3aNW3atMcff/yuu+7aunXrkD4NDQ3XXHPNPffcE/3lxjVK5UDY5w+6fSG3P+jxBl2egMMTsAeCnkDYFxZCHMexDMswjCTLkWD7hnMSwoxyMYmKJ4/lUf+6KAlEEsKEEOIdsQPH8gzDKGlKCEMpZRhGppIsU0plmUocq2EZlud4DZekS0pPT8nKTMlNS8lKTcpI02WlJmckaVK+8Z8CACBeYhCEb7zxxoIFC6ZNm0YIue222x566KHu7u6SkpLBfa6++mpCiFaritFDWAy6fFZ/0OMLuf1Btyfg8PgdvpA7+GXUcQxPGIZSSRAF+vWMEqXRI2sUI6dg7Ejyl2kqjdZBkAgRpFCA+NwBu9nZSQhhWY5nNZRQWZYooUkaXUpSelpydlaqPj0lO02XnZqckZqcmZKUdu7/CQAATiUGQXjixImqqirlODs7W6/Xd3Z2DgnC0xcMBhsbG5VjhmFqampSU1OjL/KcCoS8VrfJ4jT1O05Y3aZgOMDzGkKILEuSJFLytVGdKMkiEeJU6diRZSksf5WcgZA3EPLa3L2dhOFZDctyhBCZSpIsajW6VG16qi4zM0WfkapPTcpI1WWmJWelJKezDJ43A8A5F4Mg9Hq9ubm5kT+mpKS43e6zO5XD4ejp6bntttsiLT/96U9Xr14dbYmx5vbbrW6TxWXqt5+wufskWeQ4XpTCsnxyPBcWRhk9qR1DCBFlgchf/SoQCvtDYb/da+4mhGVY5U6sTKkkCxpOm6xNS0vOTE/NydTp01KyUpMz03XZGSnZGEcCQKzEIAjz8vLsdnvkjw6HIz8//+xOlZ2dPXny5D179kRfVQzJVHZ6B6wuk9nZZXZ0ObwWlmUYwgpiKDLa++r+IURBprIshSN/DIuhsBhy+23E3sEwDM9qGZahMpWomK7L1mcU5mUV56QXZKflpeuy41g2AIxrMQjCGTNmPP7448pxS0tLOByO3Ckdv7wBZ5elxezoHHB2ufx2nuUJYSLJd+YP8iBalFJBCkWeU7p8VpfPesJ8mOc0sizJlKbrsnMzjPlZJdnpBTnp+anJmXGtFwDGjRgE4Xe/+9377rvv17/+9WWXXfbggw/eeOONGRkZhJCf//znWq32F7/4BSFk586d3d3dAwMD+/bte/PNN+fPn19UVBT9pWPO6bV09DW1mPb6Ak7CsOKXo5PBj7sgcQx+EunyWVw+ywnzEY7jZVkihGTocnIziwxZxdlpeTnpBSlJ6XEtFgASVAyCMDk5efPmzb/85S83bNiwaNGihx9+WGmfNGkSz588/86dOz/77LPa2lqXy/Xmm2+WlZUlVBDaPeZjvfvbew/4Qh5CqShP/MksE5Uki5Hb1Hav2e7t7+hrYllelkXCMKlJGfqMQkNWcU5aviGrGNEIAERZFhbvGr7S1NS0evXqAwcOjMG1KKVWd+/x/kPNPXvCYkiWRJli2KcKHMvznEbJy5Ojxsyi7PR8jBoB1El1O2zJsmSyHWvv3X+8/xAhjCiFZYonfuoybNRoPtZ3gGN5SZY4lstMzc3NLDZkFuWkF+RmGHlOFYtfAdRMRUE44Ozaf+yTLksby7BhMURIAg2FIb4kWZJkiRAiyaLFZbK4TG2clmVZURTSdJmF+spCfUVeVmlWau43ngoAxh1VBKHLZ/vsyPu99g5RDFPkH5wGUQorM1Tdfrvbb2/r3c8QQgiTm2EsNlQZs8sNWcVaPjm+RQJATEzwIAyG/XvbPzrStUuWJdwChbMmSSfnT/U7OgecPRp+hyCGkjS6gpzywpzygpzy3IxChsEaf4BxacIGoSgJTcc/3dv+MaUyVrtDDMlUCgkBQkgg7Dvef7Db0sIQVqZSZqqh1FBlzKnIzy5N1ib6voAAEDEBg5BSeqyvacfhd0VJEAdtUwJwDjDil4NFu6fP4ek/0rVLkkWO5fOzS0sNNYbM4rysEmVvVQBITBMtCHusbdsOvhMIeQVEIIw5SmhYDBJCJFnstrT02U+wDCvKQlZKrlFfUaivKNRX6LRp8S4TAL5m4gQhpfI/d/+tz34cEQiJgYnckLB7zQ7vQFvvPkkStXxyfnZZce7k/OxSfYYRb9gAiLuJE4TbD7/b5ziBFITERAkNC0FCSCDsPWE+3GVp5hhOplJmSm5hbmWRvjI/uwzL+QHiYoIE4ZHOL1p6GiNPawASnCxLMpGIMlj0DbT27JWpmMSnlORVleZNLcypTNamxLtGALWYCEHYZz/+2dH3kYIwTlF68smiKLmbuxuP9R6UqazVJJcaakrzppQYqrFgEeCcGvdB6PHb/7n7RaQgTBjK7f1AyNti2nu8/7AoCekp2eX5tcWGamNOOceO+39nARLN+P6XKiwG3/vieQEpCBPSlyNFl8/adGLH0e7doiTkpOeXGqYY9eWF+gpMtAGIifEdhP9qfMkf8lBsGQMTnSxLITlACLG4TDaP+eCJHTKV8rJKywtqi/RVOen58S4QYBwb30Foc/dJEnaNAXWRZTEsi4SQXtsxs7OTJZsYhjFmTyo31hXpK9NTcuJdIMA4M76DkCHY3RFUTZJEiYiEkE5Ls8l+jBCGZVhjTnlZ/tRSQ02aLiveBQKMA+M7CPGMBCAiMmWsc+Bor+3YDvpeZOppce7kJA3WYwCMbJwHIcvGuwSARDRo6mnjCfMRURJSkzOKc6uLciuxHgNgiHEehBgRApwaJcq7Mtx++9GuL1p798qylJ2WNyl/WmleTV5mMcPgt0lQOwQhgFpQQkUxTAixufucnoGDx7dTQktyqyqN04sN1UkaXbwLBIiP8R2E+owCb9AuYuIowBmSqCSJEiGko/9Qj7VdksXs9LzKghll+VOxGAPUZnwH4ZIZ16777M8O74AsS/GuBWC8UpbtW129To9lb/sWjuVK86aU5U8tNUzR8Np4Vwdwzo3vIOQ5zbfm/uitT//kD7lkSuNdDsD4JsoCIUSQSJtp3wnzEUkW9RmFVYXTywvOw0oMmMDGdxASQpK1qd+Zd9tb2/8UEoKEIAsBYiDyhuEBZ5fd0/dF8780muSK/LpyYx22doOJZ9wHISEkPSXnirk/eu/zZ7HpKEDMKcsTxZD3aPeutt59MqVF+oqy/Nry/Gm6pLR4VwcQAxMhCAkhhsyiFfWrNza+LOLFvADnhkzlsBgihHQONJtsx3Ycfi8zNXdy4YxJ+bU56QXxrg7g7E2QICSElBhqFtZdte3QO5RSScY8UoBzSBkm2j39jW3Wvcc+5lnNpPzaioK6Qn0lz2niXR3AmZk4QUgIqS6eVZJXs69985GuXbIsyXgrBcA5JskikYlIwi3duzv6DmJ+DYxHDE2kyZZNTU2rV68+cOBAlOfxBpy7Wv51rP+QLIsJ9Q8IoAY8pyGUYn4NjBcTakQYkabLuvj862a4+3Yced/i7BalMMIQYMxE5tcc6d7VatpHiVykn1xVdH6JoRp7f0MCmphBqNBnGL/d8O/9jhPbD73n8lsEEfNoAMYUpbIgKfNrjvbaO2RZ0mcUTimZXV4wTafFjFNIFBPz1uhwXQPNOw6/Fwh7w2IYyw0B4ojntJTK2el5U4pnlxfUpSZnxrsiULuJPCIcrDRvSomhpsfa2mrad8J8mCWcIAZlJCLAmFPWOFldvZ97N3x2dENmSs6U4jkVheel67LjXRqolFqCkBDCMEyJoabEUEOpbHZ0tfbsbe/bTykRpTBFIgKMOUkSCSEO78Du1o27Wzcla1NriuurimZmpRniXRqoi1pujY7oZCKa9rb3HqCUilJYJpQZm2sDwDAcyzMMk6xJrSmeNamgzpBZFO+KQBVUHYQRwxMRY0SAOGIZluM4ntVWFJxXVTSzIKeMEPyOCucKgvBrKJV77cfbTHuP9R1kCJFlScQmNQDxw7Isx/A8r60qPH9y4fl5WcVIRIg5BOHIKJWt7r5++/Eua6vZ3ilTmWXYsBjCjFOAuGAYlud4juUrjdOrCmfmZ5cxDBIRYkNFk2XOCMOwhswiQ2bReeUXEUJ8QXe/40SPpa3XdswTdHKsRpRCCfU7BMDERqksiGGBhI90ftFq2k+pXGaYUl08qySvGtvWQJQQhKclNTmj0ji90jidEBIWgwPO7l7bsR5Lm9Xdx3MaSRaxzTfA2KCECmKQENLRf7DL2kqIXJJbU1NcX2KoZlkkIpwNBOEZ0/LJxblVxblVF9SsFCXB4urptXX0WFotLhPLspRSAa+CAjj3Iol4vP9Qj7VVprQsr6a6qL7YUMWx+C8bnIHYfF0EQfj8888lSZo/f35SUtKIfQ4dOtTT0zNr1qy8vLyYXDQR8JzGmFNuzCmvr1pKKbV7+vscJ/rtxy0ukyfg4FmeMKwghijegwFwzlBClRclHus72DXQQgkt0k+uKakvNUzBO6HgdMQgCF0u1+LFi5OTk7VarcVi2bZtW25u7pA+d99997p162bOnLljx45XX311+fLl0V830TAMo88w6jOMdWXzCCGUyi6fzebps7p6+50nHO6BsBTgWa1MJWVLYgCIOeV+TOfA0T57hyRLRbmTa0vnlhpqcNcUTiEGQfjcc8/l5uZu2rSJYZjvfve7Tz311K9+9avBHY4ePfp///d/LS0tRqPxb3/727333psI80LPNYZhs9IMWWkG5ckiISQsBu3ufpunf8DZZXGZXD4ry7IswwtSUJYxZASIJWWM2DXQ3GfrIAwpz6+bWnqBMWcSVl/AcDFYPtHQ0HD77bffdNNNhJC333774YcfPnz48OAO//3f/7179+5169YRQvx+f1ZW1pEjRyZPnjz8VImzfGJMULffYXP32dy9Zle3zd0XDHt5LolQEhYD8a4NYGJhGA2n5Vi+pri+prg+J70g3gVBAonBiLC7u7u0tFQ5Li0t7e7uHtKhp6enrKxMOU5JSTEYDD09PSMGoSRJLpfrzTffjLTMmTNn0qRJ0ReZkJiMlJyMlJzygmnKn0VJsHvMNk+vxdlj8/S5/PZQ2M9zGoYwoizIshTfcgHGMUoFMSSQ0MET2w937UzRpk0tnVtdNBPvvgASkyAMh8Mazckn0lqtNhQKUUoHr3UNhUIpKV+9jVOr1QYCI494fD7fkCDU6XQTNwiH4jlNXlZxXlbx1JILlBaZSt6Ay+23OTxmi6vH4bV4Ao6QEOBYTklHrGUEOCOyLMty2C3aG9s+amz9KDM1d0rJ7Kqimcna1HiXBnETgyAsKCiwWq3KscViKSgoGLLjg9Fo7OnpUY4ppVartbCwcMRTZWRklJaWrl27NvqqJgaW4ZRRY3FuVaRRkkWXz+bwml0+m93Tb3f3uf12SijH8pTKoiRQIuNBCMCpKXPWbJ6+XS0bdzb/Mz+7bEpxfYVxOiaaqlAMgnDevHmffPLJVVddRQj55JNP5s+fP7zDXXfdJcsyy7J79uxJSkqqqamJ/rqqxbF8Tnp+Tnr+4MZAyOv0WZw+i8M7YHP3Ob1Wf8jNsTzHcpIsiBLW+wOMTJlo2ms7ZnX1bDu0vjy/dmrpXGNOObZwU48YBOFPfvKT+fPnT5o0SavVPv300x9++KHSnpeX99JLL61cuXLlypVpaWk333zzypUrH3vssbvuuis5OTn668JguqQ0XVKaMac80kKp7Ak4XT6r8n8Or9ntt/tCLoawPMdTSgQphNmqABHKRNP2vgPHzUdYlptSVF9TMlufYYx3XXDOxWbT7cbGxhdffFGW5RtuuKGhoUFp/MMf/nDllVdWVlYSQmw221NPPdXd3b1o0aIbb7xxtF+1VDZrND5CQsDtt7v9Nrff7vQOOLwWT8AeDPlYluNYjlIqSgLeQgWgvApKy6dMKZ5dU1KfkaKPd0VwruDtE0DIoFk5/qDbG3TZPWaXz+IJOENCgGd5hmElWZAwbRVUSdmwLU2XVVfWMLlopk6bFu+KIMawIx8QMmhWzpD2sBh0++0ev93ttzu8ZofH4gk4gmEvx/IMwxEiCaJICe6vwkSmbKnv8ll3tWza2fyvguyy2rKGsrypmFYzYSAI4VS0fHJuRmFuxtdm+VJK/SH3yYAMOJxeq8s34A04Q0KA43iW4WQqiSLur8JEo0yrMdmOmZ3dhMql+bW1pRcU6SsZho13aRAVBCGcMYZhUpMzU5MzB8/NUYz4ADIQ9nEMHkDCxCFKYUJIR39Tt6WVZUil8fzqopkFOZPiXRecJQQhxFKSRqe80HhwoyxL3qDT43d4Ag5lBaTbZ/OFXIIY5jkNw7CyLAmSQBCQML5QorwHqrlnV5tpb5JGV1vWMKVkTkpSerwrgzODIIRzjmW5jBT98El3kix6Ak6P3+4JONw+q9074PHZfSG3IIU1nIYwjCRLEt7UAQlPlmWZhAUpvLdtS2PblvzskunlC0rzalgGr7wYHxCEEDccy2el5malDn1plygJnoBDeQD5ZUDafCEPpbIyPUGUBGX+AkBCEWWBENJr67A4exiGnVI8u7asISvNEO+64BsgCCHh8JwmOy0vO23oC5xDQsAXdCvzdJzeAbvH7PbbvAEXwzAcyzMMI4ghGe9AhgSgTKs51PnZ0e5dKckZMyoWVBXO1PAjv7Qc4g5BCONGkkaXpNEN2VuOjLZFQNiv4TQsw0myJEphzNCBsSdTWZbCLp/186Mbdhx+vzi36rzyC4tzJ2Mr4ESDIIRxb8QZOl89gPTbXT6r3Tfg9tl8QbdMJQ2npZRKsoj7qzA2BOUtwZbmXtsxrSa5btL8KcVzdElYmJ8oEIQwMY32ADKyRYDH73B4zA7vgCfgCIS9LMtzLCfLEl5uBecIpVSQwoIUbmzbvKd1s1Ffdl7ZRSV5NSyWIcYbghDUZcQtAsig+6sunxU7zME5pbwBqsfSPuDoIYRUFZ4/bdK8nPSCeNelXghCAEJGv7/qC7ojTx9PTs8JuhjCYH8AiF5YDFJCjnbvajE1piZnzqhYUFU4S8Nr412X6iAIAUbFsfyIW7CeevgoyoKM4SOcHubknBrZ5bPuPLrhsyMflBmmTi27AHNqxhKCEOCMjTh8HDx51eExO3wDnoAzHPaznIZlGFmWRGwOAKekvBCxo/9Ql6UlWaurK7uwuqRep02Nd10TH4IQIDZG3l6OSt6A0+23u302l89q9w64fVZf0E0JVTYHwNpHGIISWZBCQiC0u3XTrtaNBTmTZpQvKDFUY2vvcwdBCHAOscyX28vlVg1uP/XaR5lKyuAA1EzZp8Zkbbc4exiGTCmeU1s2LzMV7weOPQQhQByMvvbR4fbZ3H67y2d1eM0uv90XdLEMx7M8ZYggBmUZw0fVCYtBQsihzs8PdX2elWqYUbGwouA8vA0xhhCEAImCY/msVENW6tCtKf0hjzJ2dHmtdk+/y2fzBp0ntyYnDHYGUAnlf2Wbu2/7oXWfHlxXXVI/fdJFmcNWysJZQBACJLqUpPSUpPSC7EmDG0VJUNLR7bc5vAMO74DHbw+EvtwZgMqiFMbOABNSWAwTQo507mzu3m3IKJpRsWhS/lQ8QYwGghBgXOI5TU56wZBV2JRSX9B1cmmH32b39Lt8Vl/QJcmShtNSQiQxLFEs7ZgIKKWSJPY7Om3732A5rq5s3rSyeXgV4tlBEAJMHAzDpOmy0nRZhfqKwe3KzgAOj9nuNWNuzgQjSCEikQPHth7o2JqfNWnm5MVYg3imEIQAE19kZ4Cy/KmRRplK3oDr5P1Vn9XuHXD5rN6AkxCCpR3jjiiLhBCTvX2gsVvDaesmXTitbG6SJiXedY0PCEIAlWIZ7pv2zVFurmLb1fGDEkEMCWJoX/uWvW0fleXXzpy8ZPjOujAEghAAvmbEpR2CGHb7bcrw0e41OzwDnoAjFPZxrIblOFmWBCmEXVcTh/Jm4I7+g50DzRm67JlVF1cU1HEs/oM/MnwuAPDNNLxWn2HUZxgHN8pU9gacbr/N7bM5fVabp8/tt/mCbpawLMdTWRZlzFyNJ0qpKIXtXvOnB9/ZdvCd2pIL6sovTNdlx7uuhIMgBICzxDLsyZuro+ybE9mU3OWzybLI4dFjnCiToQ51fna4c6c+s3B6+UUVBXVYcRGBIASAGDuNTcn7Hd6Br72yQwojHc81SZYIkcyOzq0e87aD6+rK5tWVX4hNvQmCEADGxine+Dh8XQfP8QzBxJxzRdmz7cDxbfs7thbnTj6v/KLir4/p1QZBCABxM/K6DlnyBl2RHcktLpPTZ9TJWXMAABhmSURBVMGqx5hT3gvWaWnutXck8boZFQumlMxV52uBEYQAkFhYdoR1HbIsuQN2l8/m9lntXrPdbfYE7MGwj2N5huUkWZAkkRBCsZL8TFEiiGFBDO9q/XBX68aqwlnnlV+UnZYX77LGFIIQAMYBluWG70guU9kbcLh8NpfPavP02T39bp8tKASUO6uiLMrYjvy0CWKIENLcs7u1Z68+w1hftbQ0r0Ylv1cgCAFgvGIZVnndY4mhOtI4eMccq8tkdfedfO6ozMqRBRnPHUcny7JMZLOz68N9r2k4zfkVi2rL5vLcBL9fiiAEgAllxB1zIs8dHR6z1d3r8Fo8flsQc1ZHJ4hBQQzubv1wV+vG6qJZMycvmcALEBGEADDxRZ47Dp4eKcmiy2dzeM2RFR2R9Y6UUkEMUdVvliNIIUJIS8+elp69+dmlsyYvmZDzSxGEAKBSHMvnpOfnpOcPbgyGfS6f1emzOn0Wm7vP5bV4Q06GsizHEUoFMazCdFQWIPbaOyyNXanJ2bOrllUY61iGi3ddMYMgBAD4SrI2NVmbmp9dNrjRF3S7fFaXz+rwDtg8vS6v1RfycJyGZRhJFNTyikdKBVFwege2HXx7++H108sXTCtrmBgvuEAQAgB8g9TkjNTkjCFvefQF3cpt1ZNTcvy2oBDQcFqGYSb2NnLKOs697Vv2tm0uy6+tr1o2ZFQ97iAIAQDOhpKOg1vCYtDlsymbrFqcPXav2RNwMIThWI1MRWUB+4Sh/ON09B/qtDTr042zKpeU5U8Zp8stEIQAALGh5ZOHbyMXGTgO3iVnwsxWpVQWxbDZ0fnRvtc0vPb8ikW1ZQ3Ki53HEQQhAMA5NHzgGJmtqrz62O7uc/lthBCO5Sg9OVFz3BGkkCCFdrd9uLttU3XRrJmVS9J0WfEu6nQhCAEAxtSIs1W9AacyW9Xm7rV5+lx+eyjsV1ayS+Nn4Hhye5ruPS09e0pyq2dOXpqXVRzvor5ZbIJQFMX33nuvq6trwYIF9fX1wzvIstza2nrkyJEZM2ZUVlbG5KIAABNGmi4rTZdVlDs50iLJotNrcfmsDt+AxWlyeM2egINjOZbhJVlI5CeOkiwSQk4MHOm2tmfosmdXLy8vmJbIrz+MTRBeddVVFotl0aJFl19++W9/+9sbbrhhSIe5c+d2d3cHAoHHHnvsjjvuiMlFAQAmMI7l9RlGfYZxUBv1BJxOr8XhNVtdvVZ3ryfgkGWJ4zSyLIlSOG61joRSIkphu9f8cdObnx5eP7tq+ZSS2RybiLchY1DTzp07v/jii+PHj6empi5cuPDOO+9ctWoVy34t/Ddu3JiTk3PxxRdHfzkAALVi0nXZ6brswXurKm88dnj67Z5+m6ff7jH7Q55Bk3GkuM/kFMSQIIY+P/qPnc0bpk+6aEblQi2fHN+ShohBEP7rX/9aunRpamoqIWTFihX9/f3Nzc21tbWD++Tk5IzytwEA4OwNf+OxLEtOn1WZjGNxdts9/Z6gg2U4juUFKRyvPceVAWvT8U+bTmw/b9KFMyoWJM5i/BgEoclkKiwsVI41Go3BYOjt7R0ShKcpGAxaLJYnnngi0rJs2bIRHzoCAMCIWJYbMhmHUtntdzi9Aw7vgM3Tb3OZ3AEHoZTjeErlsXzRsSCFKSFNx7c1Hf90aukFMyuXpCSlj9nVR3NaQWg2m+fOnTu8/fnnn1+xYgXDMJR+tfne4OMzRSmVZdnhcCh/ZBhGlsfHXCkAgITFMGxmqj4zVV+WPzXS6A95HN4Bp9didZtsrj6X3yJKohKNgngOHzcyhIiSSAg50vnFkc5dVUXn11ctje+rLU4rCA0Gw/bt24e35+bmEkKMRmN7e7vSIoqizWYzGo3DO58OnU6Xn5//+OOPn91fBwCA05SSlJ6SlF6k/2oav7IzjvK4ccDZ4/ANBMN+DaclhAhiMOZ7jSuTS1t79rb37ivSVzVMvTQ7LT5btZ1WELIsW1w86lqQ5cuXr1mzJhAI6HS6LVu25ObmTpkyhRBisVgYhlHCEgAAEtzwnXEia//t7v4BV7cyE+fLaAxRIkc/E0emkiyRLkuzydael1XaMOXSvKySKM95ppho7mRGXHLJJcFgcPHixS+88MIvf/nLf/u3fyOE3HTTTUlJSWvWrCGE/PGPf/zss8+2bt1aXFxcWVl57733XnDBBcPP09TUtHr16gMHDkRfEgAAxFxkJs7gaOQ5niGxmKTKEJ7VZKYaLqheMfgu7rkWmyAUBGHt2rUmk+miiy6aP3++0rh7926O42bNmkUI2blzZ3d3d6T//Pnzi4qKhp8HQQgAML5Isqg8a7R7+i0uk93THwh7eZZnCCtIZ/kWDg2vyUjJnTvl0lJD9Rgs/4hNEMYKghAAYLyLjBodHrPFZXL4BnwBJ2FYnuUl+QzewqHhk9KSMy6c9p3i3CpCSGdn56M/e6DpwH6O4xYvXfazRx7NzMyMScEIQgAAOOdCQsDhMdu9ZrfP+tXC/6/uqY46cNTwSRkp+tRAyc//4+4HZxbMLcyWKd1w3PZCq/Nf23YUFBREXxuCEAAA4kCSRZfP6vRZXF6rzdNvd/e5A3ZKCc/yMpFFMUxJJJ6YP9/z9+fnTy7J0EX++ocnrLtz6v7yf3+LvpJE3PYNAAAmPI7lc9ILctK/NqQLhH0ur8Xps9i9Zpu7z+O3+0OecEhgguHBKUgIWVqmf2bjCOv6zgKCEAAAEoVOm6rLSS3ImTS40WIzv5L8xpCeLMNIMdpxJXHfiwEAAEAIMejz/ZT3hsXBjYcs7slVVTE5P4IQAAAS3f0PP/LTbR22wMm93445fP/vC9ND//3bmJwct0YBACDR/eCHq1LT0v795z/TyGFBoun63DVvvDNjxoyYnBxBCAAA48C3v3Plt79zpdfr1Wq1Wq02hmdGEAIAwLiRlpYW83PiGSEAAKgaghAAAFQNQQgAAKqGIAQAAFVDEAIAgKohCAEAQNUQhAAAoGoIQgAAUDUEIQAAqBqCEAAAVA1BCAAAqoYgBAAAVUMQAgCAqiEIAQBA1RCEAACgaghCAABQNQQhAACoGoIQAABUDUEIAACqhiAEAABVQxACAICqIQgBAEDVEIQAAKBqCEIAAFA1BCEAAKgaghAAAFQNQQgAAKqGIAQAAFVDEAIAgKohCAEAQNUQhAAAoGoIQgAAUDU+Jmfx+/3PPfdca2vrBRdccOONN3IcN/insizv2LFj8+bNVqu1trb2pptuSklJicl1AQAAohSbEeH3vve9Dz/8cO7cuc8+++x//ud/DvlpX1/fLbfcIknStGnT1q5du3jxYkEQYnJdAACAKDGU0ihPsW/fvkWLFpnNZp1Od/z48WnTpvX09OTk5EQ6SJLEMAzLsoQQv9+v1+s//fTT2bNnDz9VU1PT6tWrDxw4EGVJAAAApykGI8Lt27fPmzdPp9MRQsrLy41G4549ewZ34DhOSUFCSCAQEAQhKysr+usCAABE73SfEYZCoeGNGo2GZdn+/n6DwRBpNBgMvb29o53nrrvu+t73vjd58uQRf+rxeLq6uq699tpIy6233nrJJZecZpEAAABn6rSCUJKkwbc6I55++ulbbrlFq9WKohhpDIfDSUlJI57nwQcfbGlp2bJly2gX0ul0mZmZ11xzTaSlqqrqdCoEAAA4O6cVhBzH+Xy+0X5aVFS0adMm5ZhSajKZiouLh3d75JFHNmzYsGXLlszMzFGr4fkhQQgAAHBOxeAZ4eWXX75v377jx48TQj7++GOWZefOnUsIaWlpaWxsVPr8/ve/f/311zdt2pSbmxv9FQEAAGIlBusIjUbj/fffv3DhwgULFnz00Ud/+MMftFotIeTFF19sbm5ev359W1vbfffdV1FRccUVVyh/5Xe/+92SJUuivzQAAECUYrB8QnH48OGWlpaZM2eWl5crLf39/aFQqKysLBgMHj58eHDnysrKESeOYvkEAACMsdjsLEMImTZt2rRp0wa3FBQUKAfJycn19fWxuhAAAEAMYa9RAABQNQQhAACoGoIQAABUDUEIAACqhiAEAABVQxACAICqIQgBAEDVEIQAAKBqCEIAAFA1BCEAAKgaghAAAFQNQQgAAKqGIAQAAFVDEAIAgKohCAEAQNUQhAAAoGoIQgAAUDUEIQAAqBqCEAAAVA1BCAAAqoYgBAAAVUMQAgCAqiEIAQBA1RCEAACgaghCAABQNQQhAACoGoIQAABUDUEIAACqhiAEAABVQxACAICqIQgBAEDVEIQAAKBqCEIAAFA1BCEAAKgaghAAAFQNQQgAAKqGIAQAAFVDEAIAgKohCAEAQNUQhAAAoGoIQgAAULXYBOGuXbuuueaaFStWPPPMM5TSIT/1+XwPPPDAFVdccckll9xzzz19fX0xuSgAAED0+OhP0dfXt2LFit/85je1tbX/8R//QQi58847B3cIh8OZmZl33nlnUlLSc889d8kllzQ1NUV/XQAAgOgxwwdwZ+rXv/71nj171q9fTwh5991377vvvtbW1tE69/X1FRYWWq1WvV4//KdNTU2rV68+cOBAlCUBAACcphiMCPft2zdv3jzleN68eW1tbR6PJz09fUg3l8vl8XieffbZCy+8MCcnJ/rrAgAARO+0gtDn8x07dmx4e01NTVJSktlszs7OVlqUhOvv7x8ehN/+9rcPHjzI8/y6desYhhnxQg6Ho729ffbs2ZGWu+++e9WqVadTJAAAwFk4rSA8evTobbfdNrz9zTffrKioSEtLCwQCSovf7yeEDE9BQsjWrVsJIevXr7/00kvb2try8/OH98nKyioqKlqzZk2kpbKy8nQqBAAAODunFYSzZ89ubGwc7adlZWUdHR3KcUdHh06nMxgMo3W+8sorMzMzDxw4sGLFiuE/ZRhGp9PV19efTlUAAADRi8Hyieuuu+6tt96y2WyEkDVr1lx77bUcxxFC3njjDSU+TSaTy+VSOm/ZssVisdTW1kZ/XQAAgOjFYLLM4sWLr7zyyqlTp+bl5cmyvHHjRqX9T3/601VXXVVfX793794bbrihsLAwHA673e4XXnihuLg4+usCAABELwbLJxRms9nhcFRXV7PsyVGmIAgsyyqjw3A43NHRkZycXFxczPOjpi+WTwAAwBiLwYhQkZ+fP2T+i0ajiRxrtdopU6bE6loAAACxgr1GAQBA1RCEAACgaghCAABQNQQhAACoGoIQAABUDUEIAACqhiAEAABVQxACAICqIQgBAEDVEIQAAKBqCEIAAFA1BCEAAKgaghAAAFQNQQgAAKqGIAQAAFVTaRC2t7e//vrr8a5i/Hn77bebm5vjXcX489hjj0mSFO8qxpm+vr7//d//jXcV48/GjRt3794d7yrGGZUG4b59+9555514VzH+rF+/fs+ePfGuYvx5/PHHfT5fvKsYZ5qbm1955ZV4VzH+bNy4cfv27fGuYpxRaRACAAAoEIQAAKBqCEIAAFA1hlIa7xq+8vnnn1988cWFhYXn+kJ+v9/r9ebl5Z3rC00wFoslJSUlNTU13oWMM52dnaWlpQzDxLuQ8SQYDDqdzoKCgngXMs7Y7Xae5zMyMuJdSKK4/vrrf/WrX526T2IFISGkvb2dZc/5OJVSKgiCVqs91xeaYARB4DhuDP4HmmBCoVBSUlK8qxh/8LmdBVEUGYbhOC7ehSQKo9Go0+lO3SfhghAAAGAs4Vd7AABQNQQhAACoGoIQAABUDUEIAACqxj3yyCPxrmFM9fX1/elPf3r33XdTUlLKyspG69bb2/vaa69lZGTo9fqxLC9hdXd3P/XUUx988EFmZmZxcfGQnwaDwQ0bNrz88subN2+WZbmysjIuRSaCPXv2/PGPf9yxY0d5eXlWVtbwDmaz+emnn16/fn1SUtKkSZPGvMAE9fHHHz/zzDN79+6tqakZvj6nr6/v9ddff+211xobG0tKSkb8YFXIYrE8/fTT77zzDs/zFRUVp+j2yiuv6HQ6g8EwluWNI+oaEbpcrrlz53Z3d5eUlFx11VXvvffeaD1/9KMf3XvvvTt37hzL8hKWxWKZM2eOzWYzGo0rV67cvHnzkA4vvfTSE088odVq09LSbrjhhm9ctTNRffrpp0uXLjUYDB6PZ86cOX19fUM6eL3eefPmtbe3l5WVXXvttW+99VZc6kw0b7755ve///2ysrL29vaGhobh+7LeeuutW7duLSoq6u7urqur279/f1zqTCiBQGDevHnNzc2TJk364Q9/eIq3CNxxxx333Xff1q1bx7K8cYaqydNPP71o0SLl+K9//WtDQ8OI3V588cVbbrmlvr7+pZdeGrviEthjjz12+eWXK8f/8z//s2zZsiEdAoFA5Hj9+vVGo3HsikskV1xxxWOPPaYcX3311Y888siQDs8//3zkW/fSSy/NnDlzTOtLVOeff37k37WGhoa//vWvQzoM/oL94Ac/+OlPfzp2xSWqF198cfbs2bIsU0pfe+218847b8Ru77777ve///1Fixb95S9/GdsCxxN1jQi3bdu2YsUK5Xj58uVffPFFKBQa0qe/v/+3v/3t7373uzGvLnFt27Zt+fLlyvGKFSu2bdtGv778NDk5OXIcDAbT0tLGtL6EsXXr1sgHtXz58uG/gw/+JJcvX75v3z632z2mJSYet9u9f//+U39uQ75g6enpY1dfolK+S8p2RcuXLz948KDdbh/Sx2az3X///U8++WQ8ChxP1BWEfX19kbvkeXl5lNLhN69+/OMfP/LIIzk5OWNeXeIa8rmFw2GbzTZiT5fL9fOf//yBBx4Yw+oShdfr9Xg8gz+o4d+uwZ+kwWBgGGZ4H7Xp6+tjGCbyseTn5/f29o7W+aOPPvrkk09uv/32saoucQ3+LuXk5PA8P/y7dPfdd99///1jsGnleDfRgvDjjz/mR9LS0kII4XleFEWlp3IwZJe1119/PRgMXnvttWNfeXy9//77I35uJpOJnMbnpggEAldeeeXChQtvueWWsSw+QWg0GoZhBn9Qwz+lwZ+kJEmUUuzzp9FoKKWRFxcLgjDatmr79+9ftWrVyy+/XFRUNIYFJqjB3yVZlmVZHvJd2rBhQ09Pz8033xyP6sYZPt4FxNiSJUsiX47hioqKIr9s9vT08Dw/ZN/tV199taWlZfbs2YSQo0ePPvzwwz09PT/72c/Oac2J4Fvf+tbpf25paWnDt/QNBoPf+c53ysrKXnjhBXXuLp2UlJSTk2MymZT5eyaTafhv4kM+SZZlsam00WhkGMZkMpWXlxNCTCaT0Wgc3q2pqenSSy997rnnLrvssjGvMREN/i719vZSSod8bi+//HJnZ+ecOXMIIa2trcePH+/t7VXtRLZvENcnlGPt9ddfr6urC4fDlNJHH330W9/6ltK+Z8+erq4uSmlbW9ueL02dOvXRRx/t7OyMZ8WJ4YUXXpgzZ44oipTS+++//wc/+IHS/sUXX5hMJkppKBS64oorrrnmGkEQ4llovN18880/+clPKKWSJC1YsODPf/4zpVQUxc2bN/t8PkrpunXrqqurg8EgpfSJJ55YsWJFfAtOEMuXL3/iiScopcFgsLq6ev369ZRSr9e7efNm5VvX3NxcVFT06quvxrnQRPLBBx9UVlYq04iefPLJiy++WGnft2/f8ePHKaUdHR2R/5rNmjXrwQcf7OjoiGPBiUxdQRgKhRYuXNjQ0HD99dfn5uY2NjYq7XPnzn3yySeHdMas0Qi/33/BBRdcdNFF1113XV5e3uHDh5X2urq6559/nlL61FNPEUJmzJhR/6VQKBTXkuOjtbU1Pz//2muvXbx48cyZMz0eD6XU6XQSQo4cOUIpFQRh6dKlc+bMWbVqlV6v37lzZ7xLTgiff/65Xq9ftWrVnDlzli1bpvw6dejQIUKIy+WilM6fPz8jIyPy7brnnnviXXL8iaK4YsWK+vr61atX6/X6HTt2KO1Lly599NFHh3TGrNFTU93bJ0RR3LJli9PpXLJkSeRR85EjR/R6fX5+/uCeR48ezcvLw4J6RTgc3rJli9vtXrZsWWQm0aFDh/Lz8w0Gg9ls7unpGdx/1qxZ6rxB6nA4Pvroo7S0tIsvvlh51iVJUmNj4/Tp05Wpj6IofvLJJzabbfHixUO+cmrW39+/detWvV6/ZMkS5RVCgUDg4MGDs2fPZln26NGjfr8/0jkrK0vNmzZESJL0ySefWK3WhQsXRu6LtrS0pKenD7kt39ramp2djQX1o1FdEAIAAAw20WaNAgAAnBEEIQAAqBqCEAAAVA1BCAAAqoYgBAAAVUMQAgCAqiEIAQBA1RCEAACgaghCAABQNQQhAACoGoIQAABU7f8DOhNTpIUQKqQAAAAASUVORK5CYII=", + "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" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] }, "execution_count": 5, "metadata": {}, @@ -241,8 +318,8 @@ { "data": { "text/plain": [ - "1-element Array{PotentialFlow.Blobs.Blob{Float64,Float64},1}:\n", - " Vortex.Blob(1.1366451802687625 - 0.2541446283167967im, 1.0, 0.07255528139019102)" + "1-element Vector{PotentialFlow.Blobs.Blob{Float64, Float64}}:\n", + " Vortex.Blob(1.1366451802687647 - 0.2541446283167959im, 1.0, 0.0725552813901911)" ] }, "execution_count": 8, @@ -470,7 +547,881 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAYAAAByNR6YAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deXxU9b3H//eZTDLZ95CFJUAIO4IJxrCJVNG2Xqsit1VbFW/LbS8utbVeq22v2EW9tj9+VdT7qxW1t9e1LhdbUFG5IiAQIOyrEAhbSMi+zWQmM+f3x5CBmIQsHJIBXs/HYyRzzvnOfAbGmXe+53u+X8M0TVMAAACwjK2vCwAAALjQELAAAAAsRsACAACwGAELAADAYgQsAAAAixGwAAAALEbAAgAAsBgBCwAAwGIELAAAAIsRsAAAACxGwAIAALAYAQsAAMBiBCwAAACLEbAAAAAsRsACAACwGAELAADAYgQsAAAAixGwAAAALEbAAgAAsBgBCwAAwGIELAAAAIsRsAAAACxGwAIAALAYAQsAAMBiBCwAAACLEbAAAAAsRsACAACwGAELAADAYgQsAAAAixGwAAAALEbAAgAAsBgBCwAAwGIELAAAAIsRsAAAACxGwAIAALAYAQsAAMBiBCwAAACLEbAAAAAsRsACAACwGAELAADAYgQsAAAAixGwAAAALEbAAgAAsBgBCwAAwGIELAAAAIsRsAAAACx2VgHr4MGDeuCBB5Sbm9vlNuvXr9fVV1+tvLw8TZw4UQsXLpRpmmdTBgAAQFDpUcBatWqVbr75Zg0bNkwLFixQTU1Nl9qtXr1a06dPl2EYKigo0KOPPqr77rtP9957b0/KAAAACErdDlhr167VkSNHlJiYKK/X2+V2pmlq3rx5cjqdmjFjhiRp2rRpkqTnnntOa9as6W4pAAAAQanbASs/P1+33HKLHnrooW61Kygo0NatWyVJsbGxkqT4+PjA/ldeeaW7pQAAAASlHo/Bstvt3Tp+xYoVgZ/DwsLa7F++fHlPSwEAAAgqvXYV4Y4dOwI/txfO9u/f361TjgAAAMGqe91QZ6GioiLws83WNteZpqnKykqlpKS02dfY2KitW7dq8ODBioyMDGx3OBxyOBznpmAAAIAe6rUeLI/H0+O2u3fv1qRJk5Senq64uLjA7YknnrCwQgAAAGv0Wg9WYmLiGfcbhqGEhIQzHrNixQpNmDAhcJ/eKwAAEIx6LWCNHTs28HN7Y62GDx/e6cD56OjowBWIAAAAwarXThG2zH0lSS6Xq83+6dOn91YpAAAA51SPA9bpY6q+2iP1wQcfKC0tTVlZWSosLJQkTZo0SWPGjJEklZeXS2odtO68886elgIAABBUehywNmzYEPj5+PHjKikpCdx//vnnVVpaqqKiosAEooZhaNGiRQoPD9fKlSsl+ScflaS7775bkydP7mkpAAAAQaXbAWvJkiXKy8vTnDlzAttcLpfGjh2rWbNmSZLmzZun1NRUDRkypNVxl19+uVasWCG3260JEybo/vvv14IFC7Rw4cKzfiEAAADBwjBN0+zrIjpTWFio3Nxcbdy4UTk5OX1dDgAAwBn12iB3AACAiwUBCwAAwGIELAAAAIsRsAAAACxGwAIAALAYAQsAAMBiBCwAAACLEbAAAAAsRsACAACwGAELAADAYgQsAAAAixGwAAAALEbAAgAAsBgBCwAAwGIELAAAAIsRsAAAACxGwAIAALAYAQsAAMBiBCwAAACLEbAAAAAsRsACAACwGAELAADAYgQsAAAAixGwAAAALEbAAgAAsBgBCwAAwGIELAAAAIsRsAAAACxGwAIAALAYAQsAAMBiBCwAAACLEbAAAAAsRsACAACwGAELAADAYgQsAAAAixGwAAAALEbAAgAAsBgBCwAAwGIELAAAAIsRsAAAACxGwAIAALAYAQsAAMBiBCwAAACLEbAAAAAsRsACAACwGAELAADAYgQsAAAAixGwAAAALEbAAgAAsBgBCwAAwGIELAAAAIsRsAAAACxGwAIAALAYAQsAAMBiPQ5YTU1NeuyxxzR27FhNnjxZN910k/bu3dultgsWLJBhGG1uCQkJampq6mlJAAAAQcHek0amaeo73/mOFi9erFWrVmnKlCmaOHGipkyZopUrV2rkyJFnbP/aa6+1u/3mm2+Ww+HoSUkAAABBo0cB691339XixYsVFhamyZMnS5KmTp2qjRs36sc//rE++uijDtvu2bNHe/bs0YgRI9rsu+OOO3pSDgAAQFDpUcB68cUXJUkxMTEyDEOSFB8fL0latmyZSkpKlJ6e3m7bV199Vb/+9a/1k5/8pCdPDQAAEPS6PQbL6/Vq9erVkqSwsLB2j1m+fHmH7V977TU99NBDSklJ0bRp0/Too4/q8OHD3S0DAAAgaHU7YB06dEh1dXWSJLu9/Q6wjga7r127Vvv375fH41F5eblWrVqlX//61xoxYoT+67/+q7ulAAAABKVuB6yKiopTjW3tNy8vL293+7vvvqvQ0NA2251Op+bNm6c333zzjM9dX1+v2trawI0rDgEAQDDqdsDyeDw9frKnnnpKbrdb1dXV+uyzz3TPPfcoIiIisP+Xv/zlGdtPnz5dcXFxgdsTTzzR41oAAADOlW4HrMTExE6PSUpKOuP+uLg4TZ8+XQsXLtTOnTt1ySWXSJL27dvXqofsq1asWKGamprA7eGHH+5e8QAAAL2g2wErKysr0Ovk9XrbPWb06NFdfrzBgwdryZIlCg8Pl6QzzoMVHR2t2NjYwI05swAAQDDqdsCy2+2aOnWqJMnlcrXZbxiGrrjiim495oABAzRjxgyNHz9e0dHR3S0JAAAgqPRoqZy5c+dKkqqqqgK9WC1ha+bMmcrIyNAHH3ygtLQ0ZWVlqbCwUJK0f/9+Pf7449q4cWObx7Tb7Z2OwQIAADgf9ChgzZ49W7NmzZLX69WaNWskSQUFBUpMTNTChQslSc8//7xKS0tVVFSkV155RZL0+OOP6xe/+IUuu+wyPfDAA2psbJQkrV+/Xvn5+Zo9e7YFLwkAAKBv9Wgmd8Mw9MYbb2j+/Pm66667lJSUpOTkZK1Zs0bDhw+XJM2bN0/r169XZGSk5syZI0maP3++3G63Pv30Uz377LNatmyZbr/9dk2fPl2PPPKIZS8KAACgLxmmaZp9XURnCgsLlZubq40bNyonJ6evywEAADijHp0iBAAAQMcIWAAAABYjYAEAAFiMgAUAAGAxAhYAAIDFCFgAAAAWI2ABAABYjIAFAABgMQIWAACAxQhYAAAAFiNgAQAAWIyABQAAYDECFgAAgMUIWAAAABYjYAEAAFiMgAUAAGAxAhYAAIDFCFgAAAAWI2ABAABYjIAFAABgMQIWAACAxQhYAAAAFiNgAQAAWIyABQAAYDECFgAAgMUIWAAAABYjYAEAAFiMgAUAAGAxAhYAAIDFCFgAAAAWI2ABAABYjIAFAABgMQIWAACAxQhYAAAAFiNgAQAAWIyABQAAYDECFgAAgMUIWAAAABYjYAEAAFiMgAUAAGAxAhYAAIDFCFgAAAAWI2ABAABYjIAFAABgMQIWAACAxex9XQCCR7PXo7rGSjU21anBVev/s6lWjS7/rdnnkdfnldfXLJ/PK6/PK5/plc/nlc0WotCQMNlDwhRmdyjUHq4wu/9+qN2h8NBIRYXHKio8TlERcYoOj5MjNFKGYfT1ywYAwHIErIuUp7lJJ2qOqrz2qMprjqms+rBqGstlmmbgGMMwZMgm0/TJlHmGR/NzqaHNNsOwqSVC+Uxfq302I0SRjmhFR8QrOiJBcVFJSohOVWJMquKiUhRiCzmr1wgAQF8hYF1EXO4GHSzdqaKSbTpSvk8+0yvJkGEYMr8SfiTJNE2Z8p7Vc/rDWft8plf1rhrVu2pkVB2STqvDMGyKjUxUUmy6EmPSlBidpsSYVMVGJspG8AIABDkC1kWgorZE63Z/qMMn9siUKUPGaT1SZqteq75iypROq8M0fappKFdNQ4UOHN8RCF42I0Qpcf2VljhEqfGDlJowSFHhsX1VNgAA7SJgXcAaXXVau/sD7T26UYZhC4SqrpzuCx6tA6DP9Kq0+pDKao4EQlekI0ZpiYOVlpCp1PhBSo7tr5AQ3toAgL7Dt9AFyu1x6f21f1JNY4UktXsK8Hx2+utpbKrTgZLtKirZLsmUYdiUEtdfA5OHKyM5S2nxmQQuAECv4lvnArV8y1uqaSg/z3qreu7012maPpVVH9aJmqPauO9T2WwhSksYrIHJ2eqfPEzJcf1lM5ihBABw7hCwLlDHKvZfNOGqIy29XD6fV8cq9qukokjmng9lDwlT/6QsDUjO1oCUbMVHpTBdBADAUgSsC1SIjX/ar2oJnM1etw6V7VZx2W5JpqLD4zQ4bYwy+41UeuJQ2UNC+7ZQAMB5r8fnSZqamvTYY49p7Nixmjx5sm666Sbt3bu3S23Xr1+vq6++Wnl5eZo4caIWLlwYFFeyXUhys6/q6xKCmj9s+d9z9a4a7SheqyUFL+nlZfP1wfpXtPPQOtW7avq2SACwmMfr4/u2l/Som8M0TX3nO9/R4sWLtWrVKk2ZMkUTJ07UlClTtHLlSo0cObLDtqtXr9bMmTM1ZcoUFRQU6O9//7u+9a1vac+ePXr22Wd7/ELQ2tjBk1XvqtHm/Z99ZVoGtKfldKLX13yyd2uXJCkhOlVD0sYoM3W0+sUN4FQigKDndDfreJVLGYkReuLtbfrHhiPKzohVdnqMXl95QPHRDv36lgnad7xWSTEOfWfqEIXY+GyzmmH2IMq+8847mj17tsLCwuRyuWQYhu6//349/fTTuuaaa/TRRx+12840TU2YMEFbt27V7373Oz3yyCOqrq5WQkKCJOmLL77QpEmT2rQrLCxUbm6uNm7cqJycnO6We1ErqTygNbuWqKz6sH+qhgvsasLe0PL3FumIUVbGeA1NG6u0hEwZDJQHEGSKjtfpu//vSpXVuJSeEKGSKme7x9lDDDV7/V//38zJ0KVDkzQuM0GXZSf3ZrkXtB71YL344ouSpJiYmMBv9PHx8ZKkZcuWqaSkROnp6W3aFRQUaOvWrZKk2NjYVu0k6ZVXXmk3YKHn0hOH6KbJd+vwiT3afWSDikt3yetrJmx1Q8vfU2NTnbYf/ELbDqxSeGikhqZfoqz0cUpPHMLs8gD6TLPXp1f+b78On2hQabVTZTUuSeowXPnbnJpsemnhUS0tPCrDkP6/H03S1eMzeqHqC1+3A5bX69Xq1aslSWFhYe0es3z5cn33u99ts33FihWBn9tru3z58u6Wgy4wDEOD+o3UoH4j5fG6dbhsr/aXbNXR8i/l8jSePIbA1RUtf0cuT6N2HS7QzkNrFWYP19C0sRqafon6J2dxgQGAXvXUe9u16NN9kqSQrwxjyEiM0LFKp2IjQzVpRIo+2nRMUY4QSYYamppbHWua0k9eKlB8lEPzbxmvqy4haJ2Nbn8THDp0SHV1df7G9vabdzTYfceOHaeeuJ22+/fvl9frVUgIvQHnSmhImIamj9XQ9LEyTVN1zkqVVB5USeVBHavYr9qTE5NKks2wtVmgGae0hC13s0t7jhZq95ENCrU7NCx9goYPuJTTiADOqXqXR8ernNpYVBnY5vWZGp4RqyMVDbpybJr+885cHS1vVGp8uGIjw1Tn9Cg8LERFx+v0+ucHVOt0a3HB4UD7xiavGpsadd+f12nD/3O9IsL4hbGnuv03V1Fx2hewrf0vj/Ly8h61NU1TlZWVSklJabd9fX29amtrA/cdDoccDkeX6kZbhmEoNjJJsZFJGjEgV5Lk8bpVVVeqitoSVdQdV3nNUVXUlcjT3BRo5w9ep67Cw6mw5Wlu0u4j67Xr8DpFOmI1YkCOsvtfqsSYtD6uEMCFZM/RGn3vj6tUWd+kpJhTZ4RiIkO16J7JykiMDGzLzji1XmtMhH8amhH94zT/1gmSpKmjU7V8a4k+LDwa+FR3eXwaf//7euCGMfrhtSPO/Qu6AHU7YHk8nh4/2dm0laTp06e3uv/oo49q/vz5Z/WYaC00JEz94geqX/zAwDbTNOVyN6i6oVw1DSdU01Cu6voTqqwvU11jpXymN3CszbD5J0C4iHu+To3ZqtXmohXatP8zJUT304gBEzUsY7yiI+I7eQQAOLM/f/ylKuv9v/hW1Ll1Q95AZaZE6brcAUqLj1BVfZPio8JkGIZeW3lAT723XRFhIfr9nRM1dVS/Vo81Kz9Ts/Iz9cw/durpf+wKbPf6TD313nZ9K2+g0hMihe7pdsBKTEzs9JikpKQetTUMI3BFYXtWrFihCRMmBO7Te9U7DMNQhCNaEY5opScObrXPNH1qaKpTXWOlak/e6horVdNQrtrGCjndDa2Otxk2maZ50Uwb0XKRblV9mdbt/kBrdy9VWsJgjRw4UVnplyjUznsYQPdFR7T++p46qp9m5WeqpMqpa3/zsQ6eaNAlmQlacOdEzX9zs0xTamhq1k9fXq+Cp65r9zHv+6fRuik/U7OeXK7KenfgU/r+RQX6w5zLNDA56hy/qgtLtwNWVlaWIiIi5HQ65fV62z1m9OjR7W4fO3Zs4Of22g4fPrzDcV2SFB0dHbj6EMHBMGyKDo9TdHic0hOHtNnf7PWo3lmtOmel6hqrVOusOhnAKlTnrFST5/SrXAzZDOOCHffVEipLq4p1vOqgVm5frOz+EzRy4GVKjR/EHFsAOrWtuEo//2uhqhvcGpYeoxM1Ll09Pl035A2SJP35k706eML/i+3W4iq9+cVBnT4ZU3WDW5Lk85l65NVCLS08quz0WD33r5crLT5CA5Oj9JvbcnT/S+vkbvY3XL+vQv/+lw16/YHWZ5FwZt0OWHa7XVOnTtXHH38sl8vVZr9hGLriiivabTtjxozAz+21/eopQJz/7CGhio9OUXx0++PqPM1u1Z0MXbWNlapz+v+sbjiheme1mr2nTiu3DBg/308/tgQtr8+jPUc2avfh9YqLTNLozHwN75+jCEd0H1cIIFj97JUN2nf85IVmtYY+nj9Tn+8s01urD2pW/iC5m9v5fDQUGDIbEmKTz2fqw01H9c7aQ5L8QWzB+zv11B3+sbhfz+mvv0RP060LPg+021dSq3qXR9HhLCXWVT26PGDu3Ln6+OOPVVVVFbjqryUwzZw5UxkZGfrggw901113KSoqSn/729+Uk5OjSZMmacyYMdqxY0dgIPzpQevOO++04CXhfBJqD1NiTKoSY1Lb7DNNU02exsCpR/+tQjUN5appKFdjU71OH2h/Pl712BIWaxortGbXUq3dtVSZqaM0amCeBqYMZ34tAK1UneyBkqRmn6n7XirQzsP+Zb0+2XpM2RlxrY73+kz968zh+vMnX8owpBH9Y/Xjlwu09WBVq+Oc7tZTNuRkJSkvO1kFe/3f1RV1bt36h8/1zs9nKMzO1dFd0aOANXv2bM2aNUvvvvuu1qxZo6lTp6qgoECJiYlauHChJOn5559XaWmpJP8Eojk5OTIMQ4sWLdKVV16plStXSvJPPipJd999tyZPnmzFa8IFwjAMhYdFKTwsqtWg+xZeX7PqnNWqa6xQTYM/fNU2Vqi64YTqGqvk9TWf9ljnQ++Xv2+ruGy3DpbuVERYtMYMnqRRA/MUFc6pcQDSvd8cqcfe2iLTlK69NEOfbC0J7Fu5q0wNziaF2PxjXQ3DUExEqK7LHaC/fLZfHq9Pu47WaNfRmlbrEUY57Loxb5CKSus0NDVGkhQaYtN//3ia8n72D9U6/WcSdhyuVlFpnUb2bx3i0L4eBSzDMPTGG29o/vz5uuuuu5SUlKTk5GStWbNGw4cPlyTNmzdP69evV2RkpObMmRNoe/nll2vFihX62c9+pgkTJshms2nBggW6//77LXlBuHiE2OyKj0pWfFSyBn7lDGTLlY+1jRWqaaxUXWOF/9Rj/QnVNFbI1WrwfXCN/WoJgU53vTbu/UQb936iwWljNDZzsjKShjJWC7hILfrkS72+8oAmDk3SPdeN1KThKbrmN5/ocLn/88zn9eqLbYeVkpwgj2nTxKwkzZmRpQ37K9Tsa31hkWEYks2UZGhcZoJ+9Ke1kqQ7Z2Tpl7MvkSSF2W0aPTBea/eekCTZDENHKxoJWF3Uo7UIextrEcJqzV5P4JTj6aceq+vL1eCqbhW2gmHer5aZ9uMikzR28BQNH5AjR2hEn9UDoHdtKqrUP//+s8D9aydk6Lkf5utIRYOe/scuvbN6v5rdTWoZ0V700u2yh/h77qsb3Jr1+890tLKxzePGhIeqwelpFcAK/vObSoj2X+F8otal6Y98KJfHf2FaTESo1v/hnzhN2AVM0YqLkj0k9Axjv3xqcNWqpqEicNqxpqFcVfUnVNtYKa/vKwPve2HaidPHaq3e+b7W7l6q7P45Gjd4spJi2677CeDCUl7n+sp9/xxYA5Ki9NQdudqxv0Tbi/3HTB6VFghXkhQfFaa3fnqFlm8/rpiIUFXWNcnj9Sk1LkIThiTqhieXq6reP7bLEWqTIzSkVVt386mr/uucHjmbmhVmb3+pPJxCwAK+wjBsio6IV3REvPorq9U+0zTldNefCl8NFapuKFd1fZlqGivU7D01APVc9nx5fc3ac2SDdh8uUEZSlsYPmaZB/UawNA9wgZo6qp/GZcZrW3G1QkMMff/qYYF9f/54r6Kio3T56AhdOSZVc64eGdi36b0PtfGtJUofNUw3PzxPIaFtrwJc+P08/er1zfJ4fXp41jhFOk5Fg9AQm26enKm/rS6WJIWHhaim0a24KAJWZwhYQDcYhqFIR4wiHTHtTLraEr7KA7fqhnJV1ZWq1lkpn6/1jPdnO+arpVerpKJIxyr2KyYiQeOHXqERA3KZwBS4wESE2fX8D/P1yqf7NCglWlNHpWrB+zu16UClVu88Hhi0fuW4/oo6OZXCgXWb9MLseTJ9/s8Kr6dZ3/rNAyouKdf8Fz5QbGS4nrjnW7p8eIqWPTqzw+dOiz81i7vL7dVfPyvSL/75knP4ai8MBCzAIq3DV+tJV1tOO1Y3nFB1/QlVN5xQVV2ZqurL1NhUe9pj2CRTMtX18NVyerLOWaVVOxZr3e4PNTozX+MGT2ZZHuAC0eBq1h1/XKUDZfWSpL+u2K+iMv/g9hB7iJo9/qumi0/ul6QjW3cHwpUkHd68U06XW5PmPi+3QmV3ROijA4uVkhirCYMTVFrt0rjMBD1009hWY6xivjJrfGwkc2F1BQEL6AWnn3YckJzdal+z13Oyt8sfvqrqy1RVV6rqhhOnTTXR9SsdPd4mbS36XFsPrNSIAbm6NOtKxUUln4NXBaC37DlaEwhXknSwrF7+GUT9v9wZhqHQEEM3XD4ocMzIr01WRFyMnDX+iUkn3HiN3lixW/akgbJ5mxUeEyczJEyl1U59uMm/qsamA5VKinFo3tdPLfB8eXaybIbUMg4+Ioz5+bqCgAX0MXtIqJJi09sMVm/p9aqq9/d0VdefUGXdcVXVl7ZaYqi9042mTMk0T84Uv0FZ6eOUM+xrSopN17aDFXK6m3VZdj+mfADOEwOToxTlsKuhyf9LV0ZipI5U+j8HUmIduvcblygnK0nDT5toNCUrUz8vWKztS/9P6aOzlXjZZZr3208UHpsg47TZ3b/qSEXrNWS3FFfp9FkeNuyr0A86PqOIkwhYQJA6vddrYMrwVvtc7saTwatUVXWlqqw7rsq6Ujndp37DPT147S/Zqv0lW7Vi+1Ct3nVqPEV4aIguG95P914/Vvkj03rnhQHotpS4cL187xT95f/2y2uamjIiWc0+yeXx6fqJA5SW0P60LanDhyp1+FBJ0qpdZXK6/WNBDcM4+YuY/7gwu03uZp/C7DbdmDeo1WNkpcWcvtqOcrISz8VLvOAQsIDzUHhYpNITB7cZaN/kcaq6pcfr5NWNlXWlqm2skKfZaBWuJMnl8WrljhKt3OGfDToizKacrBT94NrRmnFJf9ls9HABwSInK0lFpXV6+H8K9WHhUaUlRGjxz2coKTa81XHltS795u1tqqpv0vemDdE1l/aXJI0eGKfkGEdgioeWkJUU7dB7D83Q5gOVGtk/ToP7tV4P9ePNJa06uxKiuIimKwhYwAXEERqh1IRMpSZkttru83lV3VClZ5d8JKe743FcTrdPq3eVavUu/zJXoSGGhqTF6Mb8obpterYSv/JBDqB3vbfuUMtcojpe5dSaPSf0T5cNDOz7/eIdqqxvkil/gFr7Zbnuv65eN+YNVEZipN786RWa88flOniiQSFhDpmmlDcsSVEOu75+Moh9VcXJQNaizulp9zi0xqQ5wEXAZgtRYkyyXrr/awrvxgBVj9fU3qO1euqdzZpw3980aM5fNW7eG7r9D5/oww3F8pw2ASGAc2/Iab1LhqFAb1NFXZN+8domldc1yecfghmYuuGPS3bpuseXa/uhag1MjtLbP5+pf87rryi7TaZPWrLxmOYsXN3u8zV5vNpWXBm4HxsZqlmTMts9Fq3RgwVcRKaMTtfeF27TrsOVWvDeFq3cXqJGd/dCUk2jRyu2l2jF9uOS/B/ySTEO5WX30y3Th2nqmDTZQ7jKCDgXHr75EtlshopPNGjGmDQ9/Gqh9h2v01Xj0uTx+lpduHL6QngNTc16r+CQRvSPlc1m06++O0lv//Tvgf1bDlap3uVRdHjrKRgOltXrYNmpQe82w1A8k4x2CQELuAiNGpioP983I3B/3Z7j+q+lO1Swt0z1zuYztGzLNKXy2iYt3XhYSzceluTvGk+McWjC0GTdNHmIrp4wQBEOPm6AsxUVbtevb71UkvTTl9dr15EaSdKHm45p6uhUrd5dJkP+JXRsNqn4xKlw5POZmvTzpapu8Oj6iQM0IiNGe475p3AYkRHbJlxJ0taDVa3ujxrAQs9dxSceAF0+Ik2Xjzh1FeH+khq9+NFOfbrlqMqqna0u0e4Kn/xrpX2y5ag+3XI0sD0mIlTD0mN0Tc5A3Zg/VBnJURa9AuDi4/pK7/MVo/ppe3GVqhvcKq1u1B/umKiHXy1UvatZEWEh2nSgUtUN/vFTf99wRAt/kKdtxVUyTekHM8LiTZQAABklSURBVLPbewo9+c62VvcfvWX8uXkxFyACFoA2stLj9MScSYH7TZ5m/aOgWK9/vk87DlYF5uLprjqnR5uKKrWpqFL/+fYWSf6B9Knxkbp0WLKuvyxTV47PkCOUjyagM/d8c6Q27K9QZX2T8rKT5XJ7Vd3gXw+1yePTcx/uUb3L//+q0+1VeU3rBaMTosP07zeN7fDxtx+qUq3z9MXtpYRoriDsKj7FAHTKEWrXzVOydPOUU4tfl1U36r01B7R4zUHtL6mR09OztRU9XlNHKhp0pKJBf19XHNge6bBrYHKUJo3qp+svH6JLs5IVYuO6HKDF6IHx+vy3X1dlfZPS4iP0QeHRVvtTYh3afdqmGePStHzrcZXVuvSdKYOVPzzljI9/z5/WyXta9/VPvjVaKVxJ3GWGaZrd7PzvfYWFhcrNzdXGjRuVk5PT1+UA6MCJ6kb9bVWRPth4SPtLatXg6llPV0cM+cegZKbG6PIR/XR9XqbGD0lWSAjBC5CkhUt3afnWEo3LTNCDN47Rr17frC92n9DErCT9Yc5ERTrs8nh9Cu3k/5nPdxzXXQtXtxoov/KJb6h/YmTHjdAKAQvAOdXgcmvp+kP6R0Gxth2sVFV9U7fHdHVFVLhdA5KjlDssRd+8bKAuy05VeBid9EB31TS4NfnnSwOzvkvSt/IG6o/fz+vDqs4/BCwAvc40TRXuK9fitQe0audxHa1oaDNgt0famXjeEWpTv7gIjc1M0FXj++tr4wcoKbb9ZUWAi12z16d7XlirZZuPBbZFOuza9vQNrF3aTfx6B6DXGYah3OwU5Wa3HgPibPJoWeERfbDxkDYXlau8xiWP9+x+B2zy+HS4vEGHyxv0wcYjktZJkkJsUlykQ5mpMcof0U9fG99fucNSGOeFi9qfl+1tFa4k6V+uyiZc9QA9WACCXkWNU0s3HtKnm49qR3GlKutcav7qmHoLP/8ddkMpcZEaMSBOU0en66rx/ZWZGmvdEwBB6PXPi/TLVwtbrTt41SXp+vPdU/qspvMZAQvAeau81qmPNx/RJ5uOaGdxpU7Unn2P15kYkiLDQ5QaH6UxgxI0bWy6po1OU0ZSdKdtgWD2wcYjeuDl9adO1RtSXGSo3nzwSg3PYHLRniBgAbjgNLg8WrmjRB8VHtbmogqVVNbL5fbpXH7Y2QxDEY4QpcVHaszgRE0ZmaYrxqYrI4nJVBHc3v7ioP79lQ2tttlshpb+x9WEq7PAGCwAF5yo8FB9PXeQvp47qNV2n8+n7cWV+qjwsNbtLtP+47WqcbrltaDXy2eaanB5tf94nfYfr9P7a0/N6WVIinDYlRIXrhH945Q3MlVXjknXsIw4xragTy343+16dunuVtvCw0L02K2XEq7OEj1YACCppr5Jn+8o0f9tPaKtByt1rLJRja7mbvZ69SwsOew2xcc4NKRftHKzUjRpdKryhvdjRnucM1X1TZr77GoVFlW22ffUnImaPXlw7xd1gSFgAUAnistq9dm2Y/pi53HtPFSlE7VOOd3tzVxvfW9UiM3fI5eeEKERA+KVN7yfpo5K05B0ehfQM2+sLNKTb29rtQyOJIXabVr4r5frmgn9+6iyCwsBCwDOwpdHq/XZ9mP6YmepvjxWo/Jal1xu7zkd73W6MLtNcVFhGpAYpbGDE5U3op/yh/dTvwRm3EZrXx6r1f0vrtOuIzVt9vWLC9d/3jlR08emtdMSPUHAAoBz5MBxf8/X2j2l2n24WidqXT047Xh2wkNDFB8VqgH9ojV6YILyR6Qqd1iK0ghgFwXTNFW4v0JPvrNNG/ZXBLaf3tc6akCcXn1guuKjwnq/wAsYAQsA+kBpVaPW7inVqh0l2l7sH/NV72xW87lYR6iF0fZuqD1EcZFhykiM0KiBCRo/JEn5I/ppcGqMbEy6et7y+ky9tapIL326T/tKavXVf3xDks2QHpl9ieZclS2bjYstrEbAAoAg42xq1rbiCq3YVqLNReU6UFqnirqms19OqN3v0DN/sdpDDEWGhSgpNkKDUqI0ZlCiLh2apEuHJislniWHgonXZ+rjzcf0+sr9Wv9leau1BP1O/VtPzErS7+dM1ODUmN4t8iLCJSoAEGQiHHblDU9V3vDUdveXVjeqYE+Zvth1XNuLq3SsokG1To/cbaa3P3vNXlO1zmbVOut0oLROK7Yfb3OMPcRQlMOu5LgIDUqKVHb/eOVmJWt0ZoIGJkczFcU50uz1qbisXh9uOqIPC4/qy2O1aurkPTAwOVK/vvVSXTEmjV6rc4weLAC4wBSX1mrVzuMq3F+uXYerVVLdqLpGdwez3J/7L1lDUoghhTvsio0IVWp8hDJTY5SdHqdxQxI1on+8UuMjCGKdOFhWr/VfntCmogpt3Feu4hMNavL4Ov0nNAxpWFqsfvHP4zV5ZD+F2jn12xvowQKAC0xmaqwyU2P13RnD2+wzTVMHSutUuL9c6/aWac+Rah2rbFBdg0dNzedmtntTkteUGlzNanA1q6TKqc0HWuZfap0ObIZ/uoBIh12xUWHqFxeuAcnRGpgUpez+scpKi9XA5GjFRF6YA7LdHq/2HqvRlgOV2lxUoS9LanWs0qmKuiZ1d3heeGiIrrokXfO+OUqjB8afm4LRIQIWAFxEDMPQ0LRYDU2L1ewpQ9s9prq+SRv2lWtT0QltP1ilg2V1qqxrUoPLo3O41KMkyWdKTR6fmjxuVTW4VVxWr/Vflnd4vGFIoTZDjjC7Ih0hio0IU2KMQylxEUqKDVdGQoQGpUQrJS5CaQkRSooJV4Sj7776GpuadaSiQXuP1mjPkRp9ebxWh8rqVVbjUl2np3k77+ELDw1RTlaibp02VFNHp3FlYB8iYAEAWomPdujqCf11dQcTTpqmqaMVjdpcVK5NReXae6xGh8rqVVnXpMYmj87BULAOmabk9ppyOz2qc3pUWu2SSk4/4syhxDD8RxiGP3yG2AwZhiGb7dR2m80mm+HfbhiSTYYkM3CVZeAZTMmUKa/PlM/0Dzpv9vrU7DPl9fq3nYszsv0TIzV1dD9dN3GgLh2apOjwUOufBN1GwAIAdIthGBqQHKUByVH6p7zMDo8rr3Zq15EqbSoq154jNTp04mRPTaNHTZ7mc94b1hWm6T+F2fKfZq/ZTgg6/Wq8TgJbZ3vPImQZkqLD7Ro5IF5jBsXrqvEZmjSyn0IYrB6UCFgAgHMiOT5C0+IjNG1sxhmPO1Ht1J6jNdp7rFq7j1TraHm9Smtcqq53q7GpWe5mb6/2ip07XU9XUY4Q9YuP0Kj+8coZlqQJQ5M0on8cvVPnEQIWAKBPpcRHKCU+QlPHdL5Mi9fn09GKRhWX1elQWZ32Ha9TabVTJ6obVVnvVp3TI6e7WW6PTx6veaqHKigYgXwVYjMUERaihGiHBiVHadTAeI3LTNCYzARlpkTLHsKVfuc7AhYA4LwRYrNpUEq0BqVES2PSu9XW5W5WVb1blXUuVdQ1qbyuSQ1Oj+pdHjU2NavO5ZbL7ZPXZ8rr8we05mavPD75zyXKf3rUkOSTTo65OjUrut1mU0iIIUeoTQ67XVEOu2KjQhUfFaZ+8RHKSIxSRmKk4qJCFcIs+Rc8AhYA4KIQHmZXeqJd6Ymsw4hzjwgNAABgMQIWAACAxQhYAAAAFiNgAQAAWIyABQAAYDECFgAAgMUIWAAAABYjYAEAAFiMgAUAAGAxAhYAAIDFCFgAAAAWI2ABAABYjIAFAABgMQIWAACAxbodsGpqavTjH/9Y48aNU35+vu68806VlJR0uf19990nwzDa3EaPHt3dUgAAAIKSvTsHO51OXXvttVq/fr0OHDigtLQ0ZWZmavXq1Vq9erVSU1PP2N7r9eqtt95qd99tt93WnVIAAACCVrcC1vPPP69169YpOztbgwYNkiRdfvnlWrx4sf7jP/5Df/rTn87Y/pNPPpHb7daIESPa7Lv11lu7UwoAAEDQ6lbAevHFFyVJsbGxgW3x8fGSpNdee03PPvusQkNDO2z/6quvatGiRbrpppt6UisAAMB5octjsMrKyrR7925JUlhYWJv99fX1Kigo6LC90+nUe++9p1tuuUVpaWm6+uqr9dRTT6m8vLwHZQMAAASvLgesHTt2BH6229vv+Nq7d2+H7RcvXqz6+nq53W6Vlpbq008/1UMPPaThw4frvffe60bJAAAAwa3LAauiouJUI1v7zc7UG/W///u/7Qazqqoqffvb39bq1as7raG+vl61tbWBW1NTUxcqBwAA6F1tklJlZaX27dvX5uZ0Os/qid544w15PB6Vl5frww8/1B133BEIXM3NzXr00Uc7fYzp06crLi4ucHviiSfOqiYAAIBzoU3AeuaZZ5Sdnd3m1tjY2OmDJSUldemYa6+9Vn/5y1+0fv16DRw4UJK0bt26TtuuWLFCNTU1gdvDDz/caRsAAIDe1qNThF6vt91jujtZ6IQJE/TOO+9IksLDwzs9Pjo6WrGxsYGbw+Ho1vMBAAD0hjYBa/78+TJNs83tkUceUXZ2tiTJ5XK1eaCoqCjl5uZ2u4DLLrtMo0aN0pQpU3pQPgAAQPDp1lI5c+fOldR6MHtL2Prud78bmAPr5ZdfVkJCgsaPH69Dhw5JkgoLC/Xkk09qz549bR7X4XDo5z//ec9eAQAAQJDpVsC67777lJ+fr+LiYh06dEg+n08bN27U4MGD9dvf/jZw3IIFC1RdXa2tW7fq7bffliQ9+OCDevjhh3XJJZfoySeflMfjkSQtWbJEd999t/Lz8y18WQAAAH2nWwHL4XBo2bJl+uEPf6irrrpK+fn5ysvL0xdffKGUlJTAcT/96U8VHx+vcePGafbs2ZKkp59+WjfeeKPi4+M1f/58TZ06Vc8884wyMzP1gx/8wNpXBQAA0IcM0zTNvi6iM4WFhcrNzdXGjRuVk5PT1+UAAACcUbd6sAAAANA5AhYAAIDFCFgAAAAWI2ABAABYjIAFAABgMQIWAACAxQhYAAAAFiNgAQAAWIyABQAAYDECFgAAgMUIWAAAABYjYAEAAFiMgAUAAGAxAhYAAIDFCFgAAAAWI2ABAABYjIAFAABgMQIWAACAxQhYAAAAFiNgAQAAWIyABQAAYDECFgAAgMUIWAAAABYjYAEAAFiMgAUAAGAxAhYAAIDFCFgAAAAWI2ABAABYjIAFAABgMQIWAACAxQhYAAAAFiNgAQAAWIyABQAAYDECFgAAgMUIWAAAABYjYAEAAFiMgAUAAGAxAhYAAIDFCFgAAAAWI2ABAABYjIAFAABgMQIWAACAxQhYAAAAFiNgAQAAWIyABQAAYDECFgAAgMUIWAAAABYjYAEAAFiMgAUAAGAxAhYAAIDFCFgAAAAWI2ABAABYjIAFAABgMQIWAACAxXocsLZv3665c+fq+uuv71a7ZcuWafLkyZo0aZLy8vL0+uuv97QEAACAoNStgGWappYuXaqZM2dq3LhxevHFF+V0Orvc/u2339Y3vvENjRkzRmvWrNHtt9+u2267TX/4wx+6XTgAAECw6lbA+vjjj9XY2KjIyMhuP5HT6dTdd98tn8+nGTNmSJKmTZsmSfrFL36h4uLiDtu63e5WfwJf1dTUpPnz56upqamvS0GQ4j2CruB9gs509T3SrYB1zTXXaPbs2br33nu7XdD777+vsrIySVJsbKwkKT4+XpI/OL322msdtiVgoTNNTU167LHH+FBEh3iPoCt4n6AzXX2P9GgMlt1u73abFStWBH4OCwtrs3/58uU9KQUAACDo9NpVhDt27Aj83F5A27t3b2+VAgAAcE51vyuqhyoqKgI/22xtc115eXmHbV0ulyRpy5YtrbaHhYW12xuGi099fb0kafPmzYqOju7jahCMeI+gK3ifoDMt75HGxsbAkKf2tAlYlZWVqqysbHNgamqqYmJielyQx+PpcduSkhJJ0n333dfjx8DFYfr06X1dAoIc7xF0Be8TdObgwYNKS0vrcH+bgPXMM8/osccea3Pgyy+/rDlz5vS4kMTExDPuT0pK6nDfddddp1deeUXp6ekKDw8PbKcHCwAA9IWRI0eecX+vnSIcO3as1q5dK0nyer1t9o8ePbrDtsnJybrzzjvPWW0AAABWajMYav78+TJNs83tbHqvJAXmvpJOjak6Hd2xAADgQtGjqwhPH0/VXm/Uyy+/rISEBI0fP16HDh2SJN1www1KSUmRdGpAe0vQCg0N1W233daTUgAAAIJOjwLWhg0bAj9/+eWXgRH1LRYsWKDq6mpt3bpVb7/9tiQpKipKf/rTn2Sz2bRy5UpJUkFBgSTp8ccfV2ZmZqfP29P1D3HhapnwbezYsZo8ebJuuukmpvxAuw4ePKgHHnhAubm5fV0KglBRUZFuu+02paenKzY2Vl//+te1adOmvi4LQaS8vFz33XefMjMzFRcXp2uuuUbbt2/vuIHZDS+++KJ56aWXmjabzZQUuKWnp5vz5s0LHPfSSy+Z8fHx5rhx48zi4uJWj7F06VIzNzfXnDhxojlx4kTzv//7v8/4nD6fz1yyZIl59dVXB57vqquu6k7ZuED5fD7zhhtuMCWZq1atMk3TNHNzc83k5GRz165dfVwdgsXKlSvNWbNmmSEhIaYkMysrq69LQpDZt2+fmZKS0up7TZIZGRlpbtu2ra/LQxA4fvy4OWLEiDbvkeTkZPPYsWPttjFM0zTPYeA7a8uWLVNtba3++te/6v3335ckXXXVVfrkk0/6uDL0tXfeeUezZ89WWFiYXC6XDMPQ/fffr6efflrXXHONPvroo74uEX1s7dq1OnjwoD799FO9+OKLkqSsrCzt27evjytDMJk9e7amTZumadOmqaCgQA8++GDgzMzs2bP1t7/9rY8rRF+bO3eurrzySs2YMUObNm3S97//fZWWlkqSnn/+ef3bv/1bmza9dhVhT11zzTWS/OsWtgQsQFLgCzMmJkaGYUg6tb7lsmXLVFJSovT09D6rD30vPz9f+fn5mjhxYuD9ApyuoaFBd955Z2DoSU5OjpqbmwNr7jLkAC6XS3PnzlVeXp4kKSMjQ7/97W81d+5cSe0v/yf14lI5Z6sn6x/iwuX1erV69WpJHb+5Wd8SLfj8QEeioqLajOs9/ar37Ozs3i4JQSY8PDwQrlokJCRI8veIf/vb32633XkTsIDTHTp0SHV1dZI6/vLkN08APXH6aia33357H1aCYNTc3Kxnn31W0dHRWrJkSYer3BCwcF7qbG1L6czrWwJAR1omxZ46dSpXraOVF154QRMnTtRnn32m+vp6zZw5s8Nf5oOi3/xcrX+IC9fZrG0JAB3x+XxatGiRUlJS9D//8z8d/gKHi9OwYcM0cuRIbdmyRZJ0+PBhzZkzR1988UWbY4PinfPMM88oOzu7ze2dd97p69IQpDpb21I68/qWANCeF154QYcPH9bixYu7ND8jLi5f+9rX9MYbb+jll18OXFy1Zs0a1dbWtjk2KAIW0F1ZWVmKiIiQ1P5qAtKZ17cEgK/at2+ffvnLX+q9997TpEmTAturq6v7sCoEozlz5uhf/uVfAvfbO6sSFAHrXK1/iAuX3W7X1KlTJbW/tqVhGLriiit6uywA5ymXy6U5c+bo9ddfD0wPJEl///vftXjx4j6sDMGqZYm/wYMHt3vGJCjGYHVFZ+sf4uIzd+5cffzxx6qqqpLX61VISEggbM2cOVMZGRl9XCGCBZ8f6Mw999yjbdu2Bea/kiSn06nDhw+rsLCwDytDX/vyyy/15ptv6nvf+54GDx4c2J6cnCxJeuihh9ptFxQ9WF3R2fqHuPjMnj1bs2bNktfr1Zo1ayT517dMTEzUwoUL+7g6BJPTPz+OHz+ukpKSPqwGweb555/XokWLVFtbqz179gRuhw4dkt1uZ7jBRe53v/udfvWrXyknJ0dvvvmmJMk0TT333HO699579aMf/ajddkG/VM6iRYv03HPPacuWLfL5fIHt6enpuummm/Tcc8/1YXXoax6PR/Pnz9dbb72lpKQkJScna8GCBRo+fHhfl4YgsGTJEj322GPasmWL3G53YHtiYqKmT5+ud999tw+rQzBYu3atrrjiig6vTB4/frw2b97cy1UhmOzatUsPPvig1q1bp+rqauXm5mry5MmaOXOmvvGNb3TYLugDFgAAwPnmvDlFCAAAcL4gYAEAAFiMgAUAAGAxAhYAAIDFCFgAAAAWI2ABAABYjIAFAABgMQIWAACAxQhYAAAAFiNgAQAAWIyABQAAYDECFgAAgMUIWAAAABYjYAEAAFiMgAUAAGAxAhYAAIDFCFgAAAAWI2ABAABYjIAFAABgMQIWAACAxQhYAAAAFiNgAQAAWIyABQAAYDECFgAAgMUIWAAAABYjYAEAAFiMgAUAAGAxAhYAAIDFCFgAAAAWI2ABAABYjIAFAABgMQIWAACAxQhYAAAAFiNgAQAAWIyABQAAYDECFgAAgMUIWAAAABYjYAEAAFiMgAUAAGAxAhYAAIDFCFgAAAAWI2ABAABYjIAFAABgMQIWAACAxQhYAAAAFiNgAQAAWIyABQAAYDECFgAAgMUIWAAAABYjYAEAAFiMgAUAAGCx/x8Z2FE+xKMthgAAAABJRU5ErkJggg==" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nO3deXwU9f0/8PfMXrnv+4RAwn0FwiECIgIiIIJaT+hPRC22VVBULB5tLYLV2mpRRAHxW48KFVFBAbnvG0JIgJzkvja72fucmd8fC0sSEgiQzYZ8Xs9HHzb72fkM74SQV2bmc3CSJBEAAACreG8XAAAA4E0IQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJjm8SA8f/58RUXFdXW5cOHCDz/8cPz4cQ+VBAAA4ObBIMzOzp41a1afPn2OHj3ayi5Op/PZZ5+dPHlyZmbmm2++OWrUqOsNUQAAgOsi99B5//KXv2RnZ69bt+66ej322GM7d+48d+5cWFiYJElTp04dP3784cOHAwICPFQnAAAwzlNXhG+++ebatWuHDBnS+i7ff//92rVrX3755bCwMCLiOG7RokU5OTmvv/66h4oEAADw7DPC8PDw1h/8xhtvENH48ePdLcOGDQsKCvrkk0+0Wm3bFwcAAODpIGz9Lc2CgoIzZ874+vr269fP3cjzfHp6utVq/eGHHzxTIAAAsM6zQSiTyVp55NatW4koISGB5xuVlJiYSESHDx9u89oAAACo48wjLC0tJaLY2Ngm7cHBwURUUFDghZoAAIABnho1er1qa2uJyN/fv0m7n58fEel0upY6rl69WqfTuTv6+fk9/vjjHisTAAA6m44ShBaLhYgUCkWTdqvVSkRyeYt1fvLJJ6GhoV26dHG9DA0NlSSJ4zhPFQoAAJ1LRwnCwMBAItLr9U3aTSYTEUVGRrbUMSEhYebMmdOnT/doeQAA0Fl1lGeEKSkpRHTlNAmj0UjNPTsEAABoEx0lCIcNG0ZENTU1TdoLCwuJ6I477mj/kgAAgAUdJQhvu+22mJiYyspKV/K5SJJ09uxZhUJx1113ebE2AADoxDwbhA6Hg4gEQbjyLVEUXSNFXeRy+bx584hox44d7sZTp04ZjcZnnnnmulaoAQAAaD3PBqFGoyGi+vr6K9965JFHoqKi3n//fXfL/PnzBw4cuGrVKlEUXS3vvfdely5dXEuvAQAAeIKnRo0ePHjw0KFDrg2Yli1bJpPJJk6cGBMT4z4gMzOTiE6dOuVuUSqVmzZtmjx58sMPP/zQQw/9+OOPOTk5O3bsuMqQUQAAgJvkqSAMDw8fPXr0nj173C1KpbLhAevWrdu0adPs2bMbNsbFxR07dmzz5s35+fmPP/74uHHjmqy4BgAA0LY8FYRpaWlXP6Bfv34N19d2k8lkkydP9kxRAAAATeF6CwAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGlyz51ar9cvXbp069atkiSNGTPmz3/+c1BQUGs6qtXqRYsWNWwZOHDg3LlzPVMmAAAwzVNBqNFoJkyYkJCQsHfvXplM9uSTT44YMWL37t0RERHX7Pv+++9/+umnDVu+//57D9UJAACM81QQPvHEE7m5uZs2bfL19SWiZcuWJSYmPvXUU9eMNI1G8/XXXy9dutTdolAo7r33Xg/VCQAAjPNIEO7Zs+fHH3+8//77o6OjXS3BwcFTpkz55ptvdu3adccdd1yl7z//+c8nn3zylVde8URhAAAATXhksMznn39ORLfffnvDxoyMDCJauXLlVTpqtdp///vfvXr10uv1nigMAACgibYPQlEUf/nlFyJKTU1t2N6nTx8i2rlz51X6fvDBBzqd7sEHH4yKivrNb36TnZ3d5uUBAAA01PZBWFlZWV1dTUSJiYkN20NCQoiooqJCrVY321EQhOPHj3fv3l0mk9lstnXr1g0cOPDf//53m1cIAADg1vZBWFdX5/ogODi4Ybv7ZUtBKJPJfvrpp7y8vOrq6lWrViUmJjqdzueee+6zzz5r8yIBAABc2j4INRqN6wPXeFE3URRdH1it1qufITw8fPbs2efPn588eTIRLViwwB2uV8rKypoxYwZ3SUJCgiRJN/UJAAAAS9o+CJVKpesDu93esN1kMrk+aM1UQiLy9fX97rvv+vXrp9frf/rpp5YO69ev3/r166VLysrKOI670doBAIA5bR+E7ikTWq22Ybs7CMPDw1t5KpVK9eabbxJRXl5e2xUIAABwWdsHYdeuXQMDA+mKIKypqSGitLS0JrdMr841ByMgIKBNawQAALio7YOQ5/nx48cT0ZkzZxq25+TkENHEiRNv4JwjRoxok9oAAACa8MiE+qeffpqIduzY0bDx9OnTHMfNmjXruk61bdu2AQMGjB49ui3rAwAAuMQjQThx4sTx48fv2LHD/VxQq9Vu3rz5kUceGTJkiPuwt99+++mnn9bpdK6X+fn5b7/9dllZmfuAwsLCN954Y/Xq1TyP7aIAAMAjPBUwn3/+eWho6Isvvuh0OvV6/axZswYNGrRixQr3AQUFBYsWLfrss8+++eYbV8tnn322aNGinj17zp8/f82aNQsWLJg6deqXX36Znp7uoSIBAAA8FYTx8fEHDhxQKpVjx46dNm3a2LFjt23b1nDMS1JS0qRJk3r16jVu3DhXy8KFC+fMmZOcnPzLL798++23qampR48exdNBAADwKO5Wn34+Y8aMmTNnTp8+3duFAADALQnP3gAAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaXJvFwBtwyk4zDa92Wow2fRmq95sN4qiIEqC3WGVJFEQBYdgJ47zkfso5D5KhY9S7qOQKeUyhUKu8lH6+6uCAnxD5DKFtz8PAID2hiC8JTkFh8ZQpdZXVGkv1NSXGsxaiUQZp+B4jiQSJKcgOK9+Bp7jOY7jeTlHHHEkSZIgOnhO5qP091cFB/qFBPtFBPqFhgZEhQZGK+U+7fN5AQC0PwThrcRg0RZWnsktP6411sh5hSiJTsHuflckGwmtPZUoiSSRIDbqIJJotNQbLfXV9cUccXK5guN4p+BQyFUh/hFRwYnhQbFhgbGhAVEKubINPy8AAC9CEN4SpIKK00dyt5os9UScU3QQkV1sdejd2B9JksN5MWVtdnO1vaRaWyqXK3jinYJDpfCJCklKiOgeHZoUERTP8zKPFgMA4DkIwo6uSlu8O+s7k0Vrd9qvfbRnSc5LNVjspuKanDJ1royXOwVnsH94XES3uLCUmNBkf59g71YJAHBdEIQdWrW2eOPhlQ3vf3YknCAKrpurWmON1qTOKzshSKKcl8eGpXSJ7hUf0T3QN9TbRQIAXIMHg9BgMKxfv76mpmbo0KFjxoxpZS9JkrZt25aZmRkbG3vffff5+/t7rsIOzinYfz76eUdNwStIot1pIyJBcFyozi5X50kkKeSqhPDU5Ohe8eHdfFUB3i4RAKAZnppHuG/fvrS0tHPnziUnJ7/22mszZsywWq3X7KXT6caNG/fOO+8kJiaePHmyT58+mZmZHqqw47M7bYJ4jcGfHZZDsDsFh8VmzKs4uTvrf1/uWPLljiV7stYX15x1Cg5vVwcAcJlHrghPnTo1adKkZ599dsmSJUQ0ceLEnj17PvHEE998881Vejmdzrvvvru2tjY7O1ulUj300EP19fUTJ048depUTEyMJ+rs4JRylbdLaBuuQTdGS31O6ZH8ilNOUYgKTugePyA5qhfunQK0J0GUeI7jONKa7HKeC/TF1GEiDwXhvHnzrFbrq6++6noZHBz85JNPLl68+LHHHpsyZUpLvVatWnXo0KEVK1aoVBcDYP78+atWrXrhhRe+/vprT9TZwcllyomDZ245/p/OcwklSa7bp1XaC2p9xaGcn31V/l1j+3aN7hsdmsxzWOcIoO1ZHUJmkVap4L/ZU/TT0VIZz0UEq0pqzRxHw9Iiu0YGBAcoZ45JiQ319XalXsNJktS2Z9y3b9+oUaMyMjKOHDnibvz1118nTJhw5513bt++vdlekiR16dKlpKQkNzc3NTXV3R4VFaXRaIqLi+Pj45vtOGPGjJkzZ06fPr1tP4uOo6T2/O7T39mdVofT5u1aPILjeIVMIUpSfES31LhByVE9FZ3lUhjA64prjY//c1+Fxtyw8cof+n4+8rsHxA1JjXjwtmQZz7VbeR1E218Rbty4kYgGDRrUsHHw4MFEtHPnTo1GExYWdmWv06dPl5SUBAYGNkxBIkpPT9+yZcuGDRt+//vft3mpt4SkyB6P3bnwXOnRY3nbHA6rIDlFUfR2UW1JujTKprj6bEVdoSgKMaHJPRIGJ0f3VinY/RUV4GaIkvTFjoItJyuK1caa+kbjM5q99DFbnesPl6w/XLL7TNWSmekh/mytmNH2Qbhjxw4iSkhIaNgYFhamVCrtdvvx48fHjx9/Za+dO3de2YuIYmNjiejYsWNtXucthOf43knDeicNU+sr8isyc8uO2x1Wnuftne4a0XXVW15XUKsr2521PiI4oWfi4K7RfXyU7A4eBrgBa3YULF53+gY6bjlVse105VPjU1+e3rfNq+qw2j4IKysriSg6OrpJe3BwcG1tbUlJSbO9KioqiOjKQTHBwcFEVFpa2uZ13ooiguIiguKG95xksGgrNUVl6ryKukKLzSjj5YLovHWHmF7JlfHV2gsafeW+Mz+EBcX0ShiSEjvAR+nn7dIAOjS9xbHxaNn/7Sxo6QCOSKWQWR0tLk0liNInW3KjQ3xn3dGNY+MuadsHoVqtJiI/v6Y/sFxDYPR6/VV6+fo2vRXm6qXT6Vr648rLyz/55JPNmze7XoaEhCxdupTr7H97gb6hgfGhafHpRGRzWNT6ijp9ZU19Sa2u3GDRyDgFx3GC6BA8vAxbO3AINiKqrS/TGmr252yMDknqnTy8S3RvbJQBcCWN0Xbv2zsqtZYm7TzHKeX8b8d1G5EWeb5cHxfmGxPiG+yvPFFYt+101dE8db2p6Xzlv3ybuetM1crf38bCI8O2D0KHw0FEMlnTxSfNZjM1F3U308v1VkpKivuRpK+vb6dPwSZUCt/48G7x4d1cLyVJ1Jk19cYanUldp6/UGKoMFo1DsMt4JUd066aja2GBCk2hWl++6/S6pKgevRKHJUR05zDWFOCSDYdLr0zB0ADlI7d3iQjxvXtA3O8+PXymREtEQX7Kr+bd/uBtXR68rYtab/tky/kfjpTUGRrF4e7s6k3Hy+/NaPrEqvNp+yAMDg7WaDT19fVN2l2RFhER0VIvau7Kz2QyEVFkZGRLf1xYWNiECRM68ajR68VxfIh/RIh/o6+zw2nXm+v05jq9WVNvqNEaawxWrcVm5HmZjJNJkuQUHaJ0a4zBcd01Lao8U1abR8Slxg/smZgRGdz5/60CXJ3B4jhZqLn8mqO4UL+xfaPXHSr95Nd8IvrXxnNGy8Wo05vtf/tf1pfP355Voj1VpB3dJ/qRUV2fXn6wqNp4sbtERPTymmO+Stn4AbHt+6m0t7YPwtTU1MOHD2u12oaNdrvdtbJMUlJSs73S0tKIqEkvunQrtaVe0EoKuTI8KDY8qMl3s2Sy6g0Wrd6sNVjqtIYanbnOaK63Ocw8L+d5XpREwemQmh9l5mUSkd1pk4jOlhzJLT/ho/Dv22Vkj4R0DKsBNpWqTQ++u7tW32iA6KyxKScKtU7h4u+47hR0ySmrX709f+n3Wa45dFOGJGx9c/yzKw79eqrSfYzdKb7+1UkE4XW7/fbbDx8+XF5e3rAxLy+PiEJDQ13zKK40cuRIIqqoqJAkqeG9TVfHcePGtXmdQMT5+wT7+wTHhHZp2CpJksmq05s1BotGZ9Zo9VU6U53JVu9w2mUyBUe8IDoFsUPM8eeIREkUnXaH0340d+uR85vjwrv16zoyMSIVt0yBKSu35TVMQYWME4n+u79YFBv+Iss1nD3BEf3zpxz3TPKNx8p+f3fPpbMGa00Hj+XVuQ+r0Vl3ZVXd0a8zL+/V9kH40EMP/eMf/9izZ0/DxuzsbCKaNGnSlU8BXdLT01NTU/Py8s6cOdOvXz9XoyAIubm5gYGBd9xxR5vXCS3hOC7ANyTAN4QopWG7IDr1Zo3BrNGbNVpjtdZYozdrzDYDT7yMl0mS6BAdbb4+Q+u5HiKW1uZWay9wnKx30rBeSRlBfuHeqgegPVU3nizoFCWO50vUpiYjJjj+4iIqHMcZbYIoNHogojXZuscGfvLM8JGvbrY1GFb63Moju/42MSyw06500fZBmJGRMX78+G3btlVVVbmnQ2zfvl0ul7/++uvuwwwGQ2Zm5ogRI1zRyHHcq6++Onv27B07driDcO/eva6l2gICsHGB98l4eWhAVGhAVJN2s83gevqoM9VpDJU6Y53RWu8Q7AqZgiPO2d7zOi6u4pZZtOf0hX1hAdEDu43pGtOH57B1MHRmEUGNU+rSfTWJiONJEjniJI7j4sL8KuvNF9+gy5eIEpGc5975PnvOXal3D4p79/8Nfu6zo0SS6wRGqyPzgnZs570obPsl1oioqKho0KBBzzzzzDvvvENEubm5gwcPfvXVV//0pz+5jxk9evTevXsXLFjw7rvvulokSbrnnnsKCwtPnTrl6+srCMKECROMRuOOHTuushlTp19i7RblFByudHRfPhpMGovdyPNynuMlEh2CvX0ePiplKuK4Pl1G9E0egU2DoVP6cNPZDzaedX2slPNKpcxsu3w9x3MccUREMp4b2DXseGHd5X96kiRJJDZIAZ7j/vvC6PSUsOEv/1yjs7pvpd49KP7j3w1vj0/GGzyy6HbXrl137NjxyCOP1NbWxsbGrlu3bvHixc8991zDYywWi/u/LhzH/e9//5s9e/Ydd9wxZcqULVu2JCQkfPfddyxvSXjrkssUYYExYYGNfoV0PX3UmesMZk29qVZjqNaZ1CarTpJEGa+QSHIKDqmtB6/aBRsRnS7cm1W0NyYsZWDK6ISI7kRszbGBTkySaPX2fPdLu1N8bkrvf/98ziGIRCTY7Q7BKVcq7xqU8PRdaYfyao8X1l1+VshxHEecePmCSJSknWeq0lPC5k7q8Zf/nnKfdsupcq3JHtpJl17z1Ma86enp2dnZJ06csFgsCxcuDAwMbHLApk2bDh48OHHixIaN/v7+3377bWFhYX5+/m9/+1sMFu1kLj99vDTr0cXmMOtMGr1ZXW9SawxV9YZag1UrCA6ZTMlx5HTab35qh+v2bFltbo22WC5TDUgZ3SspQyn3ucnTAnidIIpNlokZ1DV03YLRM5Zst9mdouCQRNFXzv3r/2WYq6prcw5kBAYdNykkUZIk4jjiOAryUWobTKgP9lMQ0Z39Yv7y38vnlCTSmx0Iwus/tVw+dOjQlt6NioqaNm1as2+lpKSkpKQ0+xZ0SiqFX1SIX1RIo7mADqddZ1brTXU6c51aX6E1VhtMWkF0ymUKIslxo9eOdqfN7rQdy91yNHdrWvygASljgv0xoAZuYXIZP7ZvzNZTFa6XEUE+B86r/7Mr3+6UOF4m42W+cvGDp26rzTn/3u0P2EzmAKJ7oqMWHv7eqPRfv/1YgI+yd6+0pz897HCKRBQV7HPfsCQiSgj3jwz2qdVdHoNzPL8uObJz3p/zYBAC3AyFXOlaW7Vho91p1ZnUOpO63lir1lfWm2qMlnqJSMbJRUlwDRxtDYfgIKJzZcdyy05EhyWnd78zvvFFKsAt5MHbkndmVToEiYg0JvvyLeeJSK6UOR0iSVKPxIjxgxK+eGKBzXRxMyZTdc2X7//f4vN2SaZUBQT7BJWmJkZJEuejlE0cGBfkqyAijqM+iSG7dFXuP+VwXu2MEZ3zLh2CEG4lSrlPZHBCk3VkLDaj1lhTb6rVGqrV+nKdSW2xm+WuMavC1W6riqIgklCuLqitL/VR+g9OvTM1Ph3jS+GW88HGs64UJCJREDnXJvTE8TwnCpLFLhCRpb7ROs+flYi+kQm8TK4KDCaJCquMrv45pfXFtca/zxpMRNEhjda2lPOddm4ughBueb6qAF9VQFz45dvpoijozHX1xhqtoaZWV6YxVhst9TzHczwvCFdO55Bc90v3Zf908OzPg7uP65U0zLWod16FrkxtHNQtIsS/086ggk6grK7RvruXR4JxHBFNHpJARH3vGXtqw1ZXs7prX2dCH1/XAZJEXKMR3D8dK/vbo4OUct71sNCt3tTZ9n1zQxBCJ8TzMteUx64NRq0aLfX1ptp6Y02NvkKjq9CZ60RRkMnkoig4BQcROZw2B9Hh81uO5v46IGXMis3c5uMXF0jiOS4qxOexsT3m3tNLKcclI3Qsg7qG7Txz+R7mxeW5OOoRGzh9eNLscalENHLOw+Z6/ZGvNsgUCvXEJ0hHxBFHkkTUZBIdz3GuDSes9kZjcMy2zrPRWxMIQmCFa8BqQkSqu8VqN2kM1fXGmlp9hVpfrjfVOQQbz/OC4PzvngObj3dxHylKUpXW8o/1p/6x/hTHc9HBftNvS372nr7BnXQQHdxa3np00POrj57IV1+aEyGlxQY/MyH13oxEIqrSWpZ8fyanTJcc0X/Bpod7xgfP/HAf6dQccRInkUQcx0kc0aU4nDY0US7jiajJyqVJEZ12YRMEIbDLR+kfF57S8J6qw2nXmWrrTbWV2gtExmZ7SaJUpTUt35SzfFMOx3EBPvKh3aPmTukztEfTNXcA2kdsqO+U9Pjj+RcXCBVFSorwvzcjcdvpyje+yVQbrMQREVeiNu0/X7Pg3j7j+sUczlOT65qQSJQkjqP+yaFdogLSU8IeGtnFdZ7yxndcQwI77a99CEKAyxRyZURwfERw/L3DE1f++ss1176RJMlgcWzPKt+eVU5Ecp6PCvWdMCjxd/f0igvrnAPNoWOqMzYaMl2hNZ+6oH1xzTHXSBmSyHXFJ0j0zoYzXaMC5tzZ7dOt53i5Qrw0yia7VPeXhwf2TQpxvXQ4xQs1jX4XjAlpcV/YW12nHQUEcDMGpoT/cXLf69njWSIipyhW1JnWbDs3/IXvk574MmXON7e/tGHxt8cr1CaPVQpARHR7r6iG365niuvvf2eX0dr8U72iGqNSIZ99ZzcVd3lMtVMQfzpW5n55qkijtzjcvwrKeG7a0M45d4JwRQjQkpceGPiHe/v+a0PWf/fkaU0OusaqvFdkpkROp1BSa/zkl7MrfjlLHMk5ig71H9Mn9rGxaf26hnmscGBRRvfwv88a/NmveTU6S73p0i5pEkmi5Bo7yhFJnEQiRxyRJC37+RwR8TzfZGMmt+2nK6WL5yAiUilkKkWnvXBCEAK0yFcpf/U3g179zSAiUuutf//fqc0nSnUmW7OZKLWwgKl7FwCnROV1pq/35H+9J5+IeJ4L9FX0SQq7/7auU4cl+yjxjxFuyozhSTOGJ730xfH1h0rcjSIRJ0nkyjOBiBrttC2KknvdUYWcn5pxcYauJNE3+4sannx0n2gZ32lX6MW/PYBWiQjy+fvs4X+fPZyILDbnil9yvjtQWKY2i5d2Pr3eHxKiKOlM9gNnq/afrXpx1UGOSC6XxYT63tYz5sHbuw3tEdnmnwKwoFdCoy1WrvltyRN33/BEpZx/aGSXPokXHxDuzKrUmxptvv3IqK5tWWUHgyAEuG6+Kvm8+/rPu6+/6+XBczUrfsk+lldrNDvE699cyvWjSiJyOIXSWuO3tfnf7s0nIo4jH4UsISLgjn6xM27r3ic5pC0/B+ikZo5JOV5Qt/lkBRElRfqXXuv5dP8uoa51ZBp649vMhi/9feQDunTmm/kIQoCbNaJn1IieF+dO2J3ixiPFX+7KyynWWOzOm9nuU5LIYhfyKnR5FbrPtpwl4jiOfJWy+Aj/Ub3i7hvRdWA3LBcOTSnk/EdPD6s32SWJStSm37y3WxCbfhfKZVxsqF9VvWVwSvjixwY1eferPYXlahM1uNv/u4k9ghqvMtPJeGRj3vaEjXmhI7M5xJ+PFH+zNz+7RGO0OCVJbNutEDmOlDJZVJjvkJSoe0ckj+oTq5R32hENcAMO56q/3lvkFMTJQxLyKvTbTlcG+ymfmZA6qnd0s8frLY7BL/7kFC7nglzG71l8d2xop507QQhCgHa2N7vqm925h3NrNQarILTNv74m43TkMi7IT9kzPnTcoISpQ5NiQv3a5E+BTs/mEKYu3pFX2Wh57jescCsAABg5SURBVBen9fnDPT29VVL7wK1RgHY1qk/MqD6Xl0Ct0pr+t6/w52OlhVV6q915xU2sVmlyjekUJI3BduBc1YHzVW/99xhHRDynksuiQ/3Su0VOSk8c0zfGV4V/+9CIKEmv/OdEXoWe6PK3VKi/8pkJaV6sqn3gHwOAN8WE+v9har8/TO3nbjlZULtub8Hes1VVWovdIdz8LRuJiETJancWV+uLqw3fHygkIiJOxkt+PsrEcP+haVH3DEkcnBqpkOG2KruW/C/rB/e8C4mIIxnPffTMcAUDN9sRhAAdy6BukYO6XZ47IUrS/pzqDQcKD52vqdZZ7A6BiHNND7uh01+8jSqRJIhkMNtzzPacUu2a7eeJiCOS8Zy/ryop0m9YWsyE9LiM1KhOPHsM3JZ8d2blr3lNGh+6vesINqbxIAgBOjSe45rcTZUkOpJb/cOh4kNnq8o1JptdaHHr4WZwjf6vMYnIKUo6kzXLZM26oFm5Ncd1JMfz/ipZfIT/kG5Rdw6IH9k72leJvag6CYdTfGH1kY0XF1e7/H0xNDVi0QP9WurVySAIAW4xHEfDekQP69Fo1F9+pe6HwyV7s8oLqvRGq1MQG4VjS6vetIZEJImiwSKeK60/V1r/5a5cVzvPcz5yPjLUr19i6Oh+sWP6xsZinfFbTUGV4dlPDuVW6C41XPxOiQhWffT0cD9mHiRj1ChA52SyOnZlVWw8VpJZVKfWWW3NP268mYhshLv4X04up2A/VXJkYEZa1B39YtNTI1UMPGS65UgSrdmR9876MzaH0OStiCCfbX+dEOzXaTdduhIrgQ/AGn8fxeSM5MkZyQ0bS9TGn4+V7swsz6+srzc6HKLk2qL85uNQoovbnTucpNZb1Xrr8YLaT37Jdr3L85xKwYcG+qTFBo3oGTOmf2yP+BD+enb3gDZ0+oL2pTVHcyv0V76VGO6/8o8jmUpBwhUhAGSXaDYdKTl4vrqwUm+wOpw3MbvxUrK1Jlk5jojneR8lHxGk6h4bMrxX1Og+cWnxQQhIzzlRWPf2uqzjhepmlwLsGR+89uU7An078yIyzcIVIQDr+iSF9UlqtJKkJFFWsfbXk6X7c6oKqw0Gs80p0tV/aeau8qp5kkScIIomq2iyOotrTNszyxfTSdd7roAMCfBJiQpMTwsb1Suuf5cwH4zQuVGiJP14tPRfP+YUN95rt6H7hiW/+8QQOZODhHFFCACtlV+t+/VExf6civPleq3R5nSK4qUfIDf64/Oq/a54k+M4Oc8F+CqiQnx7xgUNTo0c3jM6LS4E15At2ZNd/enW80fy1A5ni4OLfVXypTPT7+28++5eE64IAaC1ukcHd58UPHdSr4aNGqNt75nKnZkVZ0o0lVqLxWYXJGrdJhzXHV+SJDkESWu0aY2286X1Pxy5vPEez3EKGefvo4gK8e0WGziga+SQ7pG9k0JYm+khSZRVrNl4tHTXmarCaoMgXuM29V0D4v722KDokM68lOg1IQgB4KaEBaimDe8ybXiXho2SRNml2p2Z5UfO1+RV6rVGi80pSTe2glxLGv94FyXJ5pRsRpvGaDtXVr/paOnlSZMcyXheJZcF+Suig/26xwb1Tg4e2DW8R0JIgM8t/zzMKYhZxdojuer9OdW5VXq1zuIUG3xtXMsnNJeF3WMD3358cEZqRPvV2lEhCAGg7XEc9U0K7ZsUSlMbtVvtwtG82j1ZlScK1cXVRr3ZZhekFh/Q3Oxo1kvL6EjkFESnIJpsjkqN+VSRmg40rVYu41RKeYCPIjzAJybUp2tMUFpcUFp8SHJUQFiA6maKaFslauOZC/WHc2tzynSltaZ6o80uiE2+gI2+Zs19DVNigxY90O/OfrGervZWgSAEgPbjo5Q1WSjHxWwXTuar95ypOF5QV6o21Jscdqcgie00hEGSyOGUHE6H0eyo0pqzS4lOVzQ+hOOI43iS85xczvspZQE+yiAfeXCgKsL1vxDf8ABlWKBvWKAywEcR6KPwUcqVChnHSTzPK2TcNYfCOgVJFCWrU9CZ7LU6a5XWXFJrulBjvKA2VtaZtUa7xeZwiCSR5D4Rd52/JijksvEDYv8wqWevJGzy3AiCEAC8z08pG9k7euQVm+Q5RelsqfbQuZqjubV5lTq13mqxOR2i2LpnkG1JIkkSyC5Kdqdotjrr9LaWDmuUT9c3jKe5g1sej9vKC2a5jO+dGPKbkV2nD09iZ7GY64IvCgB0XHKe65cc1i857KmJTbfEM1qcJwrUx/JrThdpCmsMGr3NYnMKoiRdGZLXTIyGB1zl4AbtLR3FNTmIpOvJQqnpH3PVeq5+3rBA1ZDukfcNSxw3IA7bNV8dghAAbkkBvvLRfWNG9216l5WIHE4xp6T+SF7N6QuawkpdVb3VaHU6BKfQdDWxS7gWPr6s5Ti6WnC61tu5riedzR3a4hkavsGpFFxCuP+ALmGThyYOS43098GP99bCVwoAOhuFnB+QEjYgJazZd802Z165/nSxOqdEV1RtqNCa9Ua72e50CqJARM0/l2x6wchd+c7Vet2UBnF3+UOVXBYaoOoaHZCeEj6iV9SgruFIvhuGLxwAsMVPJb9KTBKRJJHWZCupMZ4r1xVW6UtrjdX11jqD1WB1WuyC0ymIgiRevAN79WeVnPs/N4IjjojjeKWcC/KTx4T6p8UHpneNuK1XVGJEAPaJbEMIQgCARjiOwgJUYQGqgSnh1zxYksjmEAwWe53BXm+y6S2OerPNbHbaBMFql2w2p10QRZJIJKckiaLomkvJcxzvurLkJZ7n5DKZn0KmUsgC/ZUhforIYN+oEJ+YYF8/XOS1C3yVAQBuHMeRj1Lmo/SNDGZ6cZZbGoYSAQAA0xCEAADANAQhAAAwDUEIAABMQxACAADTEIQAAMA0BCEAADANQQgAAExDEAIAANMQhAAAwDSPB6HD4bDZmt/BEgAAwOs8uNZocXHxvHnzioqKZDJZdHT0smXLUlJSWtOxqKjo6aefbtgybty4hQsXeqZMAABgmqeCMD8//84775w2bdr69es5jnv99ddHjBixb9++1NTUa/ZdsmTJtm3bGra88cYbHqoTAAAYx0nN70J5UyRJuu222woLCwsKCgICAojIZrMlJSWlpKTs37+f5692P7a4uPiuu+5avny5u0Umk40dO7al42fMmDFz5szp06e3Yf0AAMAOj1wRbtiw4dChQ48//rgrBYlIpVJNmTJl9erVGzZsmDFjxlX6Ll26dP78+XfddZcnCgMAAGjCI4Nlvv76ayIaOXJkw8aMjAwi+uKLL67SsaysbM2aNWazOTMz0xOFAQAANNH2Qeh0On/99VciajI0Ji0tjYj2799/lZuxS5cutVqtL7300sCBA/v37//jjz+2eXkAAAANtX0QVlRU6HQ6IoqPj2/YHhwcTER1dXVVVVXNdhRFkYimTJkSExNDRFlZWdOmTfvDH/7gagcAAPCE1j4jrKmpqampueZhCQkJarXa9XFQUFDDtwIDA10faLXa2NjYK/vyPL9s2TIikiTp4MGDr7zyyr59+z766KOwsLC//vWvLf2JTqezurq6sLDQ9dLHxycuLq51nxMAAECrR40uX778008/veZhb731lr+//5133klENTU1kZGR7reys7P79u1LRJmZmf3797/mqSRJeu6555YtW6ZUKvPz8xMTE5s9rFevXlqt1t/f3/UyPDz88OHDHMe15pMCAABo7RXh3Llz586d25ojDx486PrAYrE0bDeZTK4PGqbjVXAc9+GHH545c2bXrl0bN25s6U/v1asXpk8AAMANa/tnhO5LN41G07DdbDYTEcdxYWFhrTwVx3F/+tOfiKikpKRNawQAALio7YMwPj4+IiKCrgjC8vJyIho4cKBKpWr92YYMGUJE4eHhbVojAADARW0fhBzHTZ48mYiOHz/esD07O5uIJk6ceF1n0+v1ROR66AgAANDmPDKh/ve//z0R7dy5s2HjiRMnlErlnDlzrutUGzZsGDduXHp6elvWBwAAcIlHgjAjI+O3v/3t7t27a2trXS3FxcXbt29/7rnnunXr5moRBGHWrFmjRo0qLS11tezZs+fxxx8/cOCA+zy7du1atmzZ6tWrPVEkAAAAeW73iQ8//LCgoGDWrFkrV67UaDRPPPHEQw89tHTpUvcBRUVF//nPf4jop59+evbZZ4lo586dX3311ddffz1hwoT+/fvn5OQYDIZt27YlJSV5qEgAAABPBWFQUNC2bdtWrVr1/PPPBwYG/vWvf73nnnsaHtCtW7f58+cXFRU98MADrpZXX301MDBw//79DofD4XC89NJLo0ePxoxAAADwKI9sw9SesA0TAADcDI88IwQAALhVIAgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgmtyjZzcajcuXLx87duyQIUNa2cVsNq9aterkyZPx8fFPPvlkly5dPFkgAACwzlNXhAaD4YMPPkhNTX355ZfLy8tb2au4uLh///7Z2dnPP/98cnJyenr6zz//7KEKAQAAyHNXhKtXr46MjDQYDK3vYjKZxo4dGxERsXz5co7jBgwYUFhY+MADD5w4caJnz54eqhMAABjnqSvC559//tFHHx08eHDru7z//vtFRUXz5s3jOM7VMnfuXIvF8sc//tEzNQIAAHh4sExgYGArjxQE4YMPPiCiMWPGuBsTExMTExO3bdt27ty5ljparVan03mTdcLNKykpkSTJ21UAFRcXe7sEIEmSSkpKvF0FkN1ur6ysvOZhng1CPz+/Vh55+PDhurq60NDQ+Pj4hu0DBw4kok2bNrXU8fTp0ydPnryZIqFNTJ48OS8vz9tVAPXo0QO/kXhdQUHBpEmTvF0F0JYtW1pzT9GzQei+yXlNe/fuJaLExMQm7ZGRkUR0/PjxljpKkiSK4o0WCG1GEARBELxdBZDdbvd2CYB/Dh1FK/8iOso8wpqaGiKKiIho0h4cHExErbm2BQAAuAGtGjV66tSpefPmXfOwu+++e+HChTdWh1qtpuZupcrlciK6yuhTrVb74YcffvbZZ66XMplswIABN1YD3IySkpI5c+a0/mY4eM6ECRO8XQLrzGZzWVnZ+PHjvV0I62pra1tzWKuCMCUlZfHixdc8LDo6ujVnuy4mk4mIgoKCWjrgnXfe0Wg0vr6+rpcqlapPnz5tXgZcU2lpaUJCQutvhoOHPPzww8nJyd6ugnWSJJWVlV35rAfamd1u9/f3v+ZhrQrCoKCgkSNH3nRJVxMaGkpEWq22SbsrCK+8ZeqGyRUAAHAzOsozwl69elFzQVhfX09E3bp180JNAADAgI4ShGPHjiWi0tLSJpMCz58/T3jmAQAAHtNRgjAtLS0jI8NgMDScKWGz2fLz82NiYjx9YxYAAJjl2SA0m81EZLVar3yrqKho5cqVOp3O3fLnP/+ZiH799Vd3y5YtW5xO55tvvqlUKj1aJwAAMMuzQVhVVUUtzAKcNm3aU0899eKLL7pb7rnnnmeeeebjjz92zSk0GAyvvfba/fffP2fOHI8WCQAALPPU7hNffvnljh07NBpNSkrKmjVrSktLn3zyyd69e7sPSEhIyMrKajK8+OOPP46Ojh41atTQoUNPnDjx4IMPLlq0yDWVEAAAwBM4by1LaLfbCwsLm91fyeFwVFVVxcXFyWSyGz5/Xl7eu++++957711lDiK0CZPJtGLFiiNHjoSFhT311FODBg3ydkXsEkVx7dq1ZWVlCxYs8HYtjDIajatXrz5w4IDdbu/fv//s2bOTkpK8XRSLJElav3791q1b1Wp1jx495s6de7VpnVKnk52dPXPmTNd1pFqt9nY5nVxpaWlaWtrs2bPz8vI2btwYFhb26aefersoFgmCsHbtWtc0pEcffdTb5TDqwoUL3bt3b/gD1t/ff8OGDd6uizlOp3PGjBkcx7nXugoNDc3Kymrp+I4yarStqNXqffv2DRs2DHsztQO73T5+/Hi5XL5ixYru3btPnjz5rbfe+t3vfrd7925vl8acrVu3qlSquLg4bxfCtEcffTQ5OfmXX37Jycn58ssvExMTTSbTww8/XFBQ4O3S2PLWW291795dq9WaTKYDBw507dpVq9W+8MILLXZoz5RuT7gibAf/+te/iGjZsmXuFqPRqFKpevfuLYqiFwtj1kcffUS4IvSS7OzsBx98UBAEd0t5eblr24BXXnnFi4WxxmKxvPfeew1bXJMRgoKCWurS2a4I3QICArxdQufn2kt59OjR7hZ/f//+/fvn5OTs2rXLa2UxDE/EvejUqVPvv/8+z1/+oRoXF+ca9I4rwvbk4+PTcD4CEblmoqemprbUpdMGIbZB8LSzZ88WFRXxPN9kxJNr94+ff/7ZS3UxDd/2XvToo48mJCQ0aXQNlY+JifFGRXCRaw+KRYsWtXRApw1CbIPgaQcOHCCimJgYhULRsN21QvqJEye8UxZAR+JaLRmLRHrX8uXLX3vttenTp7d0QKcNQvC0lvZSdt2dq66u9kJNAB3Mzp07+/XrN2nSJG8XwiibzfbWW28tW7asW7duoii2dFhHn6u+atWqjz/++JqHvf766/fdd1871ANurr2U3TtBurlmf15lL2UARhQUFGzevHnr1q1YFcQrvv/++6VLlx45coSInnjiiV27dq1evbrhQ1y3jv7XM3Xq1IyMjGseduWtefA01/eTdMWCDK4FZl2D5QBYtmDBgueff961tQ60v+nTp0+fPv3o0aPz5s07cODAF198MW3atGZvkHb0IIyKioqKivJ2FdCMsLAwuqG9lAFYsGLFCqPRuHTpUm8XwrqMjIy9e/eOHTt2z549a9eubTYI8YwQblBLeym7WtLS0rxQE0DHsH379pUrV65duxY3RTsCnucXL15MRGVlZc0f0L71QOcxevRouVyu0Whc4+Lczp49S0Tjx4/3Ul0AXnb+/PnXXntt06ZNoaGh3q4FLho6dCjHcdHR0c2+iyCEGxQWFjZlyhRRFBsuqCZJUk5OTkhICIIQ2JSbmztnzpx169Y1eaaDOfXepdVqJUlqaR5Lpw1Co9FIRBaLxduFdGZvvPGGXC7fsmWLu2Xv3r319fWvvvoqljjxCtcDWnzbe0tOTs4jjzyyZs0a9/A9p9NZXl6+cOHCbdu2ebc2plw5iO/zzz/v0aPHrFmzWuzQ+ej1eteE+gMHDni7lk5uyZIl/v7+Z8+elSTJYDBkZGRMnTrVZrN5uy5GLVmyhIgyMjKw1mv7y8nJiY2NbfbHrFKpxLrH7WbPnj2+vr4jR47csGGDw+EwGAwffPBBz549c3NzW+ritf0IPeedd945fvx4YWEhEUVGRg4dOvSll17C0qOe8+mnn77//vs9evQoKiq6//77Fy5cqFKpvF0Uc7Kysr766qv9+/e7LgcHDRo0adKkGTNmeLsuhkycOLGurq7Zt0aOHOlamBfawYULF+67777MzEwiUigUvXv3njFjxvz58wMDA1vq0gmDELxCq9ViaAAAdBAmk8lsNoeEhDRZA7JZCEIAAGBapx0sAwAA0BoIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABgGoIQAACYhiAEAACmIQgBAIBpCEIAAGAaghAAAJiGIAQAAKYhCAEAgGkIQgAAYBqCEAAAmIYgBAAApiEIAQCAaQhCAABg2v8H+v5jTg0CK3QAAAAASUVORK5CYII=", + "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", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\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/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] }, "execution_count": 13, "metadata": {}, @@ -496,7 +1447,129 @@ "outputs": [ { "data": { - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nO3dd3xUVd7H8XNnJo2QnpBAChBI6L0JCIIIiMBKkcUGuxRRXAusiCAqLqjAo+KqqKCCuLYVFLGggBA6iALSEmoSShJSZ9ImZerzx9XZMRCIMMOEnM/7D18zZ+6Z+Y0Qvjn3nnOuYrfbBQAAstJ4ugAAADyJIAQASI0gBABIjSAEAEiNIAQASI0gBABIjSAEAEiNIAQASI0gBABIjSAEAEiNIAQASI0gBABIjSAEAEiNIAQASI0gBABIjSAEAEiNIAQASI0gBABIjSAEAEiNIAQASI0gBABIjSAEAEiNIAQASI0gBABIjSAEAEiNIAQASI0gBABIjSAEAEiNIAQASI0gBABIjSAEAEiNIAQASI0gBABIjSAEAEiNIAQASI0gBABIjSAEAEiNIAQASI0gBABIjSAEAEiNIAQASI0gBABIjSAEAEiNIAQASI0gBABIjSAEAEiNIAQASM3tQXjixImsrKw/1eXMmTNff/31/v373VQSAAAObgzC5OTk8ePHt2nT5pdffqlhF4vF8vDDDw8dOvTQoUNz587t06fPnw1RAAD+FJ2b3vdf//pXcnLy6tWr/1Sv++67b8uWLcePHw8NDbXb7cOHDx84cODevXvr16/vpjoBAJJz14hw7ty5q1at6tq1a827fPXVV6tWrZo5c2ZoaKgQQlGUOXPmpKSkPPvss24qEgAA914jDAsLq/nBzz33nBBi4MCBjpYePXoEBgYuXbrUYDC4vjgAANwdhDU/pZmamnr06FE/P7927do5GjUaTefOnSsqKr7++mv3FAgAkJ17g1Cr1dbwyI0bNwohYmJiNJo/lBQbGyuE2Lt3r8trAwBA1J51hOfPnxdCNGzYsEp7UFCQECI1NdUDNQEAJOCuWaN/Vl5enhDC39+/Snu9evWEEEVFRdV1XLFiRVFRkaNjvXr17r//freVCQCoa2pLEJaXlwshvLy8qrRXVFQIIXS6autcunRpSEhIkyZN1KchISF2u11RFHcVCgCoW2pLEAYEBAghiouLq7QbjUYhRERERHUdY2Jixo0bN3LkSLeWBwCoq2rLNcL4+HghxMXLJEpLS8Wlrh0CAOAStSUIe/ToIYTIzc2t0p6WliaE6Nev3/UvCQAgg9oShL169YqKirpw4YKafCq73X7s2DEvL6/bbrvNg7UBAOow9wah2WwWQlit1otfstls6kxRlU6nmzZtmhAiKSnJ0Xjw4MHS0tIHH3zwT+1QAwBAzbk3CPV6vRCisLDw4pfuueeeBg0aLF682NEyffr0jh07Ll++3GazqS2vvPJKkyZN1K3XAABwB3fNGt2zZ89PP/2k3oBpyZIlWq128ODBUVFRjgMOHTokhDh48KCjxdvbe926dUOHDr377rvHjh37zTffpKSkJCUlXWbKKAAA18hdQRgWFta3b9/t27c7Wry9vZ0PWL169bp16yZOnOjc2KhRo3379q1fv/706dP333//gAEDquy4BgCAa7krCBMTEy9/QLt27Zz313bQarVDhw51T1EAAFTFeAsAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNZ373rq4uHjhwoUbN2602+233HLL888/HxgYWJOO+fn5c+bMcW7p2LHj1KlT3VMmAEBq7gpCvV4/aNCgmJiYHTt2aLXaSZMm9ezZc9u2beHh4Vfsu3jx4nfffde55auvvnJTnQAAybkrCCdMmHDy5Ml169b5+fkJIZYsWRIbG/vAAw9cMdL0ev2nn366cOFCR4uXl9df/vIXN9UJAJCcW4Jw+/bt33zzzejRoyMjI9WWoKCgYcOGffbZZ1u3bu3Xr99l+r722muTJk166qmn3FEYAABVuGWyzAcffCCEuPnmm50bu3XrJoR4//33L9PRYDC8+eabrVq1Ki4udkdhAABU4fogtNlsP/zwgxAiISHBub1NmzZCiC1btlym7+uvv15UVDRmzJgGDRr89a9/TU5Odnl5AAA4c30QXrhwIScnRwgRGxvr3B4cHCyEyMrKys/Pv2RHq9W6f//+5s2ba7XaysrK1atXd+zY8c0333R5hQAAOLg+CAsKCtQHQUFBzu2Op9UFoVar/fbbb0+dOpWTk7N8+fLY2FiLxfLYY4+99957Li8SAACV64NQr9erD9T5og42m019UFFRcfl3CAsLmzhx4okTJ4YOHSqEmDFjhiNcL3bkyJFRo0Ypv4uJibHb7df0BQAAMnF9EHp7e6sPTCaTc7vRaFQf1GQpoRDCz8/vyy+/bNeuXXFx8bffflvdYe3atVuzZo39dxkZGYqiXG3tAADpuD4IHUsmDAaDc7sjCMPCwmr4Vj4+PnPnzhVCnDp1ynUFAgDwP64PwqZNmwYEBIiLgjA3N1cIkZiYWOWU6eWpazDq16/v0hoBAPiN64NQo9EMHDhQCHH06FHn9pSUFCHE4MGDr+I9e/bs6ZLaAACowi0L6qdMmSKESEpKcm48fPiwoijjx4//U2+1adOmDh069O3b15X1AQDwO7cE4eDBgwcOHJiUlOS4LmgwGNavX3/PPfd07drVcdhLL700ZcqUoqIi9enp06dfeumljIwMxwFpaWnPPffcihUrNBpuFwUAcAt3BcwHH3wQEhLyxBNPWCyW4uLi8ePHd+rUadmyZY4DUlNT58yZ895773322Wdqy3vvvTdnzpyWLVtOnz595cqVM2bMGD58+Mcff9y5c2c3FQkAgLuCMDo6evfu3d7e3v3797/zzjv79++/adMm5zkvcXFxQ4YMadWq1YABA9SWWbNmTZ48uXHjxj/88MPnn3+ekJDwyy+/cHUQAOBWyo2+/HzUqFHjxo0bOXKkpwsBANyQuPYGAJAaQQgAkBpBCACQGkEIAJAaQQgAkBpBCACQGkEIAJAaQQgAkBpBCACQGkEIAJAaQQgAkBpBCACQGkEIAJAaQQgAkBpBCACQGkEIAJAaQQgAkBpBCACQGkEIAJAaQQgAkBpBCACQGkEIAJAaQQgAkBpBCACQGkEIAJAaQQgAkBpBCACQGkEIAJAaQQgAkBpBCACQGkEIAJAaQQgAkBpBCACQGkEIAJAaQQgAkBpBCACQGkEIAJAaQQgAkBpBCACQGkEIAJAaQQgAkJrO0wXANSxWc1llcVlFibGyuKyiuMxUarNZbXaryVxht9usNqvZahKK4qvz9dL5env5eut8vbTeOq2Xl87H19vf3yewvl+wTuvl6e8BANcbQXhDsljN+pLs/OKsbMOZ3MLzJWUGu7BpFS9Fowi7sNotVqvl8u+gUTSKomg0OkUoQhF2u91qM2sUra+3v79PUEC94KB64QH1QkLqNwgJiPTW+V6f7wUA1x9BeCMpKTekXTh6MnO/oTRXp/Gy2W0Wq8nxqk1UCmtN38pmtwm7sNr+0MEmbKXlhaXlhTmFZxWh6HReiqKxWM1eOp9g//AGQbFhgQ1DAxqG1G/gpfN24fcCAA8iCG8I9tSswz+f3GgsLxRCsdjMQgiTrcahd3UfKexmy28pW2kqyzGdyzGc1+m8NEJjsZp9vHwbBMfFhDePDIkLD4zWaLRuLQYA3IcgrO2yDWe3HfnSWG4wWUxXPtq97Jbfayg3Gc/mpmTkn9RqdBarJcg/rFF4s0ah8VEhjf19gzxbJQD8KQRhrZZjOPvd3vedz3/WJorVZlVPrhpKcw3G/FMZB6x2m06jaxga3ySyVXR48wC/EE8XCQBX4MYgLCkpWbNmTW5ubvfu3W+55ZYa9rLb7Zs2bTp06FDDhg1HjBjh7+/vvgprOYvV9P0vH9TWFLyI3WayVAohrFbzmZzkzPxTdmH30vnEhCU0jmwVHdbMz6e+p0sEgEtw1zrCnTt3JiYmHj9+vHHjxs8888yoUaMqKiqu2KuoqGjAgAGLFi2KjY399ddf27Rpc+jQITdVWPuZLJVW2xUmf9ZaZqvJYjWXV5aeyvp125EvPk5a8HHSgu1H1pzNPWaxmj1dHQD8j1tGhAcPHhwyZMjDDz+8YMECIcTgwYNbtmw5YcKEzz777DK9LBbL7bffnpeXl5yc7OPjM3bs2MLCwsGDBx88eDAqKsodddZy3jofT5fgGuqkm9LywpTzP5/OOmixWRsExTSP7tC4QSvOnQLwOLeMCKdNm1ZRUTF79mz1aVBQ0KRJk/773/9+9913l+m1fPnyn376aebMmT4+vwXA9OnTc3Jy/vnPf7qjyNpPp/Ue3GVcnVrkbrebLJU2myXbcOanYz98vvXVT5IW7D727QV9us1u83RxACTl+iDcuXPntm3bOnXqFBwc7GhUrxG+9tpr1fWy2+0vvfSSEKJ///6OxjZt2kRERKxatSozM9Pldd4QYiNaDOoyzt83yKuujA4dLFaTxWYuKS88kr77h18+WLFh7g/7Vp7OOmS2VHq6NABycX0QqsO+Tp06OTd26dJFCLFlyxa9Xn/JXocPHz537lxAQEBCQoJze+fOna1W69q1a11e540iLqLFfbfO6tlqaD3fQC+tt0ZT17aHtdttJkulxWo6m3Ns25EvV/4479uf3j2Zsb/SXO7p0gBIwfXXCJOSkoQQMTExzo2hoaHe3t4mk2n//v0DBw68uNeWLVsu7iWEaNiwoRBi3759Lq/zBqJRNK3jerSO65FfnHU669DJjP0mc4VGozHVucGTOhzMLEjNK8rYdmRNeFBMy9guTSPb+HrLO3kYgLu5PggvXLgghIiMjKzSHhQUlJeXd+7cuUv2ysrKEkJcPCkmKChICHH+/HmX13kjCg9sFB7Y6KaWQ0rKDRf06Rn5p7IK0sorS7UandVmuXGnmF5Mzfgcwxl98YWdR78ODYxqFdM1vmEHX+96ni4NQF3j+iDMz88XQtSrV/UfLHUKTHFx8WV6+fn5XbJXUVFRdR+XmZm5dOnS9evXq0+Dg4MXLlyoKMpVVn+DCPALCYgOSYzuLISoNJfnF2cVFF/ILTyXV5RZUq7XKl6KolhtZqubt2G7DszWSiFEXmGGoSR3V8p3kcFxrRvf1CSydZ2aQwTAo1wfhGazWQih1VbdfLKsrExcKuqupZf6Unx8vOOSpJ+fX51PwSp8vPyiw5pFhzVTn9rttqIyfWFpbpExv6D4gr4ku6Rcb7aatBpvRYgbNx3VjQWy9Gn5xZlbD6+Oa9CiVWyPmPDmilLXLpoCuM5cH4RBQUF6vb6wsLBKuxpp4eHh1fUSlxr5GY1GIURERER1HxcaGjpo0KCRI0deS811iaJogv3Dg/3/8P/ZbDEVlxUUlxUUl+kLS3INpbklFYbyylKNRqtVtHa73WIz3ygLGNSzpukXjmbknRJCSYju2DK2W0RQ1avLAFBDrg/ChISEvXv3GgwG50aTyaTuLBMXF3fJXomJiUKIKr3E76dSq+uFGvLSeYcFNgwLbPjHZruxorik3FBcZigpLzCU5BaVFZSWFVaayzQanUajsdltVovZLuyeKfqy7EKYLJV2IY6d+/lk5gFfL/+2TXq3iOks4bSa878mr5r2r+xjp2M6thn7xvNRLZt5uiLgBuP6ILz55pv37t1bZeXfqVOnhBAhISHqOoqL9e7dWwiRlZVlt9udz22qHQcMGODyOiGE4u8b5O8bFBXSxLnVbrcbK4qKy/Ql5fqiMr2hOLvIWGCsLDRbTFqtlyI0VpvFaqsV26QpQtjsNpvFZLaYfjm58ecT6xuFNWvXtHdseIIkp0ytZstbwycVZmYLIY79uGPpyCnPH9usvlScnZd7+kxki2YBEaEerRGo7VwfhGPHjn311Ve3b9/u3JicnCyEGDJkyMVXAVWdO3dOSEg4derU0aNH27VrpzZardaTJ08GBAT069fP5XWiOoqi1PcLru8XLES8c7vVZiku05eU6YvL9IbSHENpbnGZvqyyRCM0Wo3WbreZbWa73WPDR/Ui4vm8kzmGM4qibR3Xo1Vct8B6YZ6q5/rIOZGqpqAq+3hqYWZ2cHTU9qWfrHr8eYvJ7OXne9/SF28aP9qDRQK1nOuDsFu3bgMHDty0aVN2drZjOcTmzZt1Ot2zzz7rOKykpOTQoUM9e/ZUo1FRlNmzZ0+cODEpKckRhDt27FC3aqtfnxsXeJ5Wowup3yCkfoMq7WWVJerVxyJjgb7kQlFpQWlFodlq8tJ6KUKxXO91HXb1IuKh9O2Hz+wMrR/ZsdktTaPaaJS6eevggMgIRVEcv39ovXT+ocEVJcbPH5trNVuEEObyik+nPtP17r/ovL3MFZW7ln+ecyItrnPbHuNGaqr5rRSQjeKOX+HT09M7der04IMPLlq0SAhx8uTJLl26zJ49++mnn3Yc07dv3x07dsyYMePll19WW+x2+x133JGWlnbw4EE/Pz+r1Tpo0KDS0tKkpKTL3Ixp1KhR48aNY7JMbWOxmtV0dAwfS4z6clOpRqPTKBq7sJmtputz8dFb6yMUpU2Tnm0b96yTNw3+4okXNi1+XwihKMpf5j8xZM4jWUdPzGs32PmYF9J2hDWJefP28Skbd6gtPf9+198+eMUD5QK1j1vuPtG0adOkpKR77rknLy+vYcOGq1evfvHFFx977DHnY8rLyx3/VSmK8sUXX0ycOLFfv37Dhg3bsGFDTEzMl19+KfMtCW9cOq1XaEBUaMAfdkhQrz4WlRWUlOkLjXn6kpwiY76xoshut2k1XnZht1jNdldPXjVZK4UQh9N2HEnfERUa3zG+b0x4cyHqzhqbu159pvNdd2Qln4zr1CauSzshRETzJn5BAeVFJeoBAQ3CQuMa5aeedaSgEOKn/6y5+81/+dT3P7lt7xdPvFCQfj6+Z+d73n4hNK6RZ74G4DluGRGqLBbLgQMHysvLO3fuHBAQUOXV3NzcPXv2DB482NfXt8pLaWlpp0+fbtmyZU0mizIirAMqzWVFRn1xWX6hMV9fkl1YkldSYbBazVqtt6IIi8XkwqUd3jofndanQ3zfVnHdvHVV/+7VGUd/2PrRpJlFF3JD4xr9/cPFif1uyko+Oa/tIMcBiqK8WnDQbrc/26xvWeFv21w079N9xvZV6uNz+48UZefF39TJP4xbZaGOc2MQXh8EYV1ltpiKyvKLjQVFZQX5xVmG0pwSo8Fqs+i0XkLYzdc2dvTSetmFkhjdqUP8LUH+dXNCjd1uL803OKaM2qzWFzsPzTx8XH3aenDfx9b/5/jmXf++7T5HF41W+3ppis7He/k9j+77/DshhF9QwMPfLE/o2/361w9cN245NQpcOy+dt7q3qnOjyVJRZMwvMuYXlublF18oNOaWlhfahdAqOpvdqk4crQmz1SyEOJ6x72TGgcjQxp2b3+rYmueGY6k06Xy8L25XFMV54YRGq31s/X/WL3j7Qsqpxl3bD541VQgRGPWHrSrqhQR5+fqcSNqtpqAQoryoZM3Ml576Sd7bv0AGBCFuJN4634igmCr7yJRXlhpKcwuNeYaSnPzizCJjfrmpTKfOWbVe7rSqzWa1CWtmfmpe4Xlfb/8uCbcmRHe+geaXbn3rP98880pFibHFrb0mfPRaYOSlt21yCGrYYOwbzzu3NGqT2PNvo/d8+KUQQqPVjlz4lBCi4OwfFgEXnMlwcd1ALUMQ4obn51Pfz6d+o7D/rXq02axFZQWFpbmGkty8ogx9aU5peaFG0SgajdV68XIOu8lSabJU7kz+ds+x77s0H9Aqrkft39T77L7Dnz86V720cezHHaunz5v06RtCCLvNlrprX0VpWbNeXfyCql6bv9jfVr7ae9LYvNRzTW/qpO5K06R7B41Wa7P+tidtfK9Lb4IB1BkEIeogjUarLnls6jRrtbS8sNCYV1iam1ucpS/KKiorsNmsWq3OZrNarGYhhNlSaRZi74kNv5z8sWOzW9o26VWbZ9Ok7z3ofIE/dfd+IYSl0vTv2+47vfMXIURAg7Dpmz9t1LbFFd+qeZ/uzfv87ypgozaJ9y17ae3sRUZ9UYv+Pe9eMs8N5QO1CEEIWajb5cSEJzhaKkxGfUlOYWluXnFWfnFmsbHAbK3UaDRWq+XnExsOnN7SuXn/DvF9tZra+GMS1uQP54fDm8YKIX7+9Gs1BYUQJbkF38597cEvlwohzh04unvFKpvV2mPcqGY1GOH1njS296SxFpNZ513bR8bAtauNP+HA9eHr7d8oLN75nKrZYioy5hUa8wwlufqS7PSc5MjguOjw5h4ssjpth/TrNOr2X9esF0L4h4WMWjRbCKE/94fLe/pzWUKIc/uP/F+vURaTWQix493Ppm36pEX/njX5CFIQkiAIgf/x0nmHB0WHB0V7upArUzSaB79cem7/kZI8fdObOtULDhRCNOvd1fmY5jd3FUL89NFXagoKIew2256VX7To39NSafr8sef3r17nXc9v4IwpA6ZNvP5fAaglpNihH6ir4rq0a3P7LWoKCiFa3XbzqEWz/EODdT7eXccOGz7vCSGE3faHebM2i0UI8cNLb+1499MyQ1FhZvbq6fNSNvy2S35pvj55/TbHckNABowIgTpl0MyHBs18yGa1OvbU7nr38G1vf6TOAlUUpfv9I4UQp7b95NzrxJY9rQf3Pb5519JRD1YUlwohek0YM37Fy9e9fMADGBECN4zD3/z4QschMxt2+/DvT5QZii5zpPOdJZr16jJt86fd7xvR9e7hj3y/su2QfkKIoEaRzscHR0cKIb6c8aKagkKI3R+sTt21z+VfAaiFGBECN4bcU+nvjnlYvdq358Mv7Xbx9w9fFUKYyyvSfvrV28+3SfcOiubSv9om3tIj8ZYezi1D5jySsnGHscAghIhu37Ln38eIi9bOF5zJqHLREaiTCELANYou5Oann49q2cw/NNgd73965z7HnBchxLFNO4UQBWcyXu03Vn82U6gjv02fePnVaO1jozaJ804kHU/a7V3Pr/WgvlovnRCi6U2dktdvUw/Q6HSNu3Vw/dcAah9OjQIukPT6iqcb93q59+inG/f+9csf3PERAQ3+sDm4uqHauvlv6H/fES119/5dyz8XQpTkFnzxxAtvDZv47XOLK0qM1b2hf1hIlzFD2w29VU1BIcR9S19q3qe7otEENAgbv3xRZGJTd3wRoLZhRAhcq5I8/RczXlJnY1aWGj+eMrvjyMFVzlJazRZH3lydNoP7Jt7S4+S2vUIInbfX8OeniYtOZualnbNZrW/cPv78r8lCiCPrks7uP/LIug+EEIWZ2RmHj0cmNo1o1ri6jwhtHD1j+6rqdvEG6iqCELhWBenn1RRUGfWFpfkGxwAuL/XsyvH/TPvp18CoiL/++7kuY4Ze3adodLppmz89+v2WktyCxH43qXnWtEfHE0m7HcfE39Qp+3iqmoKq5B+2lhUWH/7mx4+nzLZUmhSNJqpVc5OxrGHrhNEvP92wdcLFH0QKQjYEIXCtIlvE+/jXqzSWqU9D4xo5n8b8z8Qn1Y1Ai7JyPhg3Pf6mziGxDa/ugzRabfvhtzm3DJnzSO6pMwfXbtR66fo/+vfOY4bmnT7zhz6KotEo/310rqXSJISw22wXkk8KIQrOZGQln5x3civbxwBcIwSulV9QwISPXqsfHiqECGsSM+mzNx0v2e329L0HHU8tlaaz+4849929YtW8toOebX7L2qf/z3lYWUM+/vWmrH77DeOx10uSRy2apShKRPMmzjuodb/3TnOl2bEowpn+bGb2sdN/9hOBuocRIeACHUcO7nDnQOczoipFUULjGuWeOuNocd4s+/jmXR9Nfkq9icT6BW/XCw4cNPOhq/h051Gdoij/+G7FjmWfXjh2unHXdr0m/FXrpYto1jgv9ezFHf3D3DLBFbixMCIEXEOdbHlx+5jFz/r411Mf9/vH+NiOrR0vHftxp/OtlJJ/3+dMVWks++KJF+Z3uP2N28erJ1dryLue34Dpk+5/d0GfKfeqM3Qe+HxJdLuWQgi/3zdjE0LcPPnukJirPEkL1CWMCAH3ajdswPzU7Wf3HQ5rHF3l7oD1w0OcnwZEhDo/XT19/s73PhNCZB4+nrZ7/9yUTVedW3Fd2j17eL25otLL1+fU9p/PHTjasHVC60F9ru7dgDqGESHgYikbtr/QcciMiM7LRj9UnJ0nhAiMDG839NaL75Hba8IY9T6CQgif+v5Vzose+W6z43FFifHklj3OrxZm5az82xPz2g1+76//uORpz4t5+foIIRL6dh8wbSIpCDgwIgRcqTArZ9noh9QZpL+uWW8xmf/x7fLqDvYPC3n28PqDX20wlVe0GzYg+I/7f/oFBxZdyHU8rffHDWuWjpxy5udDQoisoyfOH0x+PmWTRsePM3A1GBECrnRm70HHOgohxImk3c5XAVN37Xuh45BH/Vq8fPNdWcknhRA+9f17jBvVZ8q9VVJQCDHoyQcVRVEfx3Vu2+q2mx0vleTp1RRU5Z46c4H5n8DV4ldIwJUCoyKqPHWEmbm84p0RU0rz9UKI1F37lo1+6F/Hk6p0rzSWefn6qPeO6DVhTKM2icc27Qxq2KDbPX9xXufuW7+eRqdzXm7hpg1OARkwIgRcqelNnTqOHKw+1nrpRrz4pOOlC8dOqymoyjmRpl5BVBkyLrzSZ8zj9VtPD2q3afH7amOT7h2GPP2PXhPGqJf3HLz8fPs/Mt7xtPt9I4Kjo9zxdQAZMCIEXElRlAe/XHpyyx79uazmN3eNaN7E8aX6X0MAABGbSURBVFJwdJSiKI4zpV5+vv5h/5s1umravNM7fxFCVBrLvpzxYvM+3Zr88eYPhVk5pXn6yBbxaiiOee25VgP7nN1/pFGbxI4jBl2HrwbUVQQh4GKKorS4tdfF7YGR4YNnTV2/4G0hhEarHf1/s5234T6777Djsd1uP/vLYecgXDNzwY+vvme32YKjox7+5v24zm2FEG3v6N/2jv5u/CaAHAhC4PoZ8dLMrmOHZx87Hdu5bZWbHEXExzluqCSEcL5HRPregxtfXqY+LszM/vzRuU/u+tK5b1lhcfIPWxWNpu0d/X0D/N35DYA6iCAErquYDq1iOrS6uH30y08vGTqhOCdfCNHj/pGtnNb55ZxIdT4y+/gfnhacyVh00wi1Y3B01Kyfv754AiqAyyAIgVohrku7+ae3nTuQHBARGtWqufNLMR1aO19cjO3UxvnVzf9eoaagEKIwM3vrmytHLHjq+tQM1A3MGgVqC5/6/gl9u1dJQSFETIdWIxc+pS6faNg64Z635ju/WpyT5/y0KPsPTwFcESNC4AYwaOZD/R/9e2mB4eLtRlve2mvff791PHVedw+gJghC4Mbg5ed7yU23e0++25CRvWflakWjufmBe7rfN+L61wbc0AhC4MamKMrwf00f/q/pni4EuFFxjRAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1ghAAIDWCEAAgNYIQACA1tweh2WyurKx096cAAHB13Hj3ibNnz06bNi09PV2r1UZGRi5ZsiQ+Pr4mHdPT06dMmeLcMmDAgFmzZrmnTACA1NwVhKdPn7711lvvvPPONWvWKIry7LPP9uzZc+fOnQkJCVfsu2DBgk2bNjm3PPfcc26qEwAgOcVut7v8Te12e69evdLS0lJTU+vXry+EqKysjIuLi4+P37Vrl0ZzufOxZ8+eve2229555x1Hi1ar7d+/f3XHjxo1aty4cSNHjnRh/QAAebhlRLh27dqffvrp/vvvV1NQCOHj4zNs2LAVK1asXbt21KhRl+m7cOHC6dOn33bbbe4oDACAKtwyWebTTz8VQvTu3du5sVu3bkKIDz/88DIdMzIyVq5cWVZWdujQIXcUBgBAFa4PQovF8uOPPwohqkyNSUxMFELs2rXrMidjFy5cWFFR8eSTT3bs2LF9+/bffPONy8sDAMCZ64MwKyurqKhICBEdHe3cHhQUJIQoKCjIzs6+ZEebzSaEGDZsWFRUlBDiyJEjd9555yOPPKK2AwDgDjW9Rpibm5ubm3vFw2JiYvLz89XHgYGBzi8FBASoDwwGQ8OGDS/uq9FolixZIoSw2+179ux56qmndu7c+dZbb4WGhs6bN6+6T7RYLDk5OWlpaepTX1/fRo0a1ew7AQBQ41mj77zzzrvvvnvFw+bPn+/v73/rrbcKIXJzcyMiIhwvJScnt23bVghx6NCh9u3bX/Gt7Hb7Y489tmTJEm9v79OnT8fGxl7ysFatWhkMBn9/f/VpWFjY3r17FUWpyZcCAKCmI8KpU6dOnTq1Jkfu2bNHfVBeXu7cbjQa1QfO6XgZiqK88cYbR48e3bp163fffVfdp7dq1YrlEwCAq+b6a4SOoZter3duLysrE0IoihIaGlrDt1IU5emnnxZCnDt3zqU1AgDwG9cHYXR0dHh4uLgoCDMzM4UQHTt29PHxqfm7de3aVQgRFhbm0hoBAPiN64NQUZShQ4cKIfbv3+/cnpycLIQYPHjwn3q34uJiIYR60REAAJdzy4L6f/zjH0KILVu2ODceOHDA29t78uTJf+qt1q5dO2DAgM6dO7uyPgAAfueWIOzWrdvf/va3bdu25eXlqS1nz57dvHnzY4891qxZM7XFarWOHz++T58+58+fV1u2b99+//3379692/E+W7duXbJkyYoVK9xRJAAAwn13n3jjjTdSU1PHjx///vvv6/X6CRMmjB07duHChY4D0tPTP/roIyHEt99++/DDDwshtmzZ8sknn3z66aeDBg1q3759SkpKSUnJpk2b4uLi3FQkAADuCsLAwMBNmzYtX7788ccfDwgImDdv3h133OF8QLNmzaZPn56enn7XXXepLbNnzw4ICNi1a5fZbDabzU8++WTfvn1ZEQgAcCu33IbpeuI2TACAa+GWa4QAANwoCEIAgNQIQgCA1AhCAIDUCEIAgNQIQgCA1AhCAIDUCEIAgNQIQgCA1AhCAIDUCEIAgNQIQgCA1AhCAIDUCEIAgNQIQgCA1AhCAIDUCEIAgNQIQgCA1AhCAIDUCEIAgNQIQgCA1AhCAIDUCEIAgNQIQgCA1AhCAIDUCEIAgNQIQgCA1AhCAIDUCEIAgNQIQgCA1AhCAIDUCEIAgNQIQgCA1AhCAIDUCEIAgNQIQgCA1AhCAIDUCEIAgNQIQgCA1AhCAIDUCEIAgNQIQgCA1AhCAIDUCEIAgNQIQgCA1AhCAIDUCEIAgNR0bn330tLSd955p3///l27dq1hl7KysuXLl//666/R0dGTJk1q0qSJOwsEAMjOXSPCkpKS119/PSEhYebMmZmZmTXsdfbs2fbt2ycnJz/++OONGzfu3Lnz999/76YKAQAQ7hsRrlixIiIioqSkpOZdjEZj//79w8PD33nnHUVROnTokJaWdtdddx04cKBly5ZuqhMAIDl3jQgff/zxe++9t0uXLjXvsnjx4vT09GnTpimKorZMnTq1vLz80UcfdU+NAAC4ebJMQEBADY+0Wq2vv/66EOKWW25xNMbGxsbGxm7atOn48ePVdayoqLBYLNdYJ67duXPn7Ha7p6uAOHv2rKdLgLDb7efOnfN0FRAmk+nChQtXPMy9QVivXr0aHrl3796CgoKQkJDo6Gjn9o4dOwoh1q1bV13Hw4cP//rrr9dSJFxi6NChp06d8nQVEC1atOA3Eo9LTU0dMmSIp6uA2LBhQ03OKbo3CB0nOa9ox44dQojY2Ngq7REREUKI/fv3V9fRbrfbbLarLRAuY7VarVarp6uAMJlMni4B/DjUFjX8g6gt6whzc3OFEOHh4VXag4KChBA1GdsCAHAVajRr9ODBg9OmTbviYbfffvusWbOuro78/HxxqVOpOp1OCHGZ2acGg+GNN95477331KdarbZDhw5XVwOuxblz5yZPnlzzk+Fwn0GDBnm6BNmVlZVlZGQMHDjQ04XILi8vryaH1SgI4+PjX3zxxSseFhkZWZN3+1OMRqMQIjAwsLoDFi1apNfr/fz81Kc+Pj5t2rRxeRm4ovPnz8fExNT8ZDjc5O67727cuLGnq5Cd3W7PyMi4+FoPrjOTyeTv73/Fw2oUhIGBgb17977mki4nJCRECGEwGKq0q0F48SlTBxZXAACuRW25RtiqVStxqSAsLCwUQjRr1swDNQEAJFBbgrB///5CiPPnz1dZFHjixAnBNQ8AgNvUliBMTEzs1q1bSUmJ80qJysrK06dPR0VFufvELABAWu4NwrKyMiFERUXFxS+lp6e///77RUVFjpbnn39eCPHjjz86WjZs2GCxWObOnevt7e3WOgEA0nJvEGZnZ4tqVgHeeeedDzzwwBNPPOFoueOOOx588MG3335bXVNYUlLyzDPPjB49evLkyW4tEgAgM3fdfeLjjz9OSkrS6/Xx8fErV648f/78pEmTWrdu7TggJibmyJEjVaYXv/3225GRkX369OnevfuBAwfGjBkzZ84cdSkhAADuoHhqW0KTyZSWlnbJ+yuZzebs7OxGjRpptdqrfv9Tp069/PLLr7zyymXWIMIljEbjsmXLfv7559DQ0AceeKBTp06erkheNptt1apVGRkZM2bM8HQtkiotLV2xYsXu3btNJlP79u0nTpwYFxfn6aJkZLfb16xZs3Hjxvz8/BYtWkydOvVyyzrtdU5ycvK4cePUcWR+fr6ny6njzp8/n5iYOHHixFOnTn333XehoaHvvvuup4uSkdVqXbVqlboM6d577/V0OZI6c+ZM8+bNnf+B9ff3X7t2rafrko7FYhk1apSiKI69rkJCQo4cOVLd8bVl1qir5Ofn79y5s0ePHtyb6TowmUwDBw7U6XTLli1r3rz50KFD58+f/9BDD23bts3TpUln48aNPj4+jRo18nQhUrv33nsbN278ww8/pKSkfPzxx7GxsUaj8e67705NTfV0aXKZP39+8+bNDQaD0WjcvXt306ZNDQbDP//5z2o7XM+Uvp4YEV4H//73v4UQS5YscbSUlpb6+Pi0bt3aZrN5sDBpvfXWW4IRoYckJyePGTPGarU6WjIzM9XbBjz11FMeLEw25eXlr7zyinOLuhghMDCwui51bUToUL9+fU+XUPep91Lu27evo8Xf3799+/YpKSlbt271WFkS44q4Bx08eHDx4sUazf/+UW3UqJE66Z0R4fXk6+vrvB5BCKGuRE9ISKiuS50NQm6D4G7Hjh1LT0/XaDRVZjypd//4/vvvPVSX1Phr70H33ntvTExMlUZ1qnxUVJQnKsJv1HtQzJkzp7oD6mwQchsEd9u9e7cQIioqysvLy7ld3SH9wIEDnikLqE3U3ZLZJNKz3nnnnWeeeWbkyJHVHVBngxDuVt29lNWzczk5OR6oCahltmzZ0q5duyFDhni6EElVVlbOnz9/yZIlzZo1s9ls1R1W29eqL1++/O23377iYc8+++yIESOuQz1wUO+l7LgTpIO6+vMy91IGJJGamrp+/fqNGzeyK4hHfPXVVwsXLvz555+FEBMmTNi6deuKFSucL+I61PY/nuHDh3fr1u2Kh118ah7upv59sl+0IYO6waw6WQ6Q2YwZMx5//HH11jq4/kaOHDly5Mhffvll2rRpu3fv/vDDD++8885LniCt7UHYoEGDBg0aeLoKXEJoaKi4qnspAzJYtmxZaWnpwoULPV2I7Lp167Zjx47+/ftv37591apVlwxCrhHiKlV3L2W1JTEx0QM1AbXD5s2b33///VWrVnFStDbQaDQvvviiECIjI+PSB1zfelB39O3bV6fT6fV6dV6cw7Fjx4QQAwcO9FBdgIedOHHimWeeWbduXUhIiKdrwW+6d++uKEpkZOQlXyUIcZVCQ0OHDRtms9mcN1Sz2+0pKSnBwcEEIeR08uTJyZMnr169uso1HdbUe5bBYLDb7dWtY6mzQVhaWiqEKC8v93Qhddlzzz2n0+k2bNjgaNmxY0dhYeHs2bPZ4sQj1Au0/LX3lJSUlHvuuWflypWO6XsWiyUzM3PWrFmbNm3ybG1SuXgS3wcffNCiRYvx48dX26HuKS4uVhfU796929O11HELFizw9/c/duyY3W4vKSnp1q3b8OHDKysrPV2XpBYsWCCE6NatG3u9Xn8pKSkNGza85D+z3t7e7Ht83Wzfvt3Pz693795r1641m80lJSWvv/56y5YtT548WV0Xj92P0H0WLVq0f//+tLQ0IURERET37t2ffPJJth51n3fffXfx4sUtWrRIT08fPXr0rFmzfHx8PF2UdI4cOfLJJ5/s2rVLHQ526tRpyJAho0aN8nRdEhk8eHBBQcElX+rdu7e6MS+ugzNnzowYMeLQoUNCCC8vr9atW48aNWr69OkBAQHVdamDQQiPMBgMTA0AUEsYjcaysrLg4OAqe0BeEkEIAJBanZ0sAwBATRCEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKkRhAAAqRGEAACpEYQAAKn9P7tE4qpGadKmAAAAAElFTkSuQmCC", + "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" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] }, "execution_count": 14, "metadata": {}, @@ -522,7 +1595,89 @@ "outputs": [ { "data": { - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nO3de3RU1f2w8b0nmdwTEkLCJSQkBAIBREO4eUNBQZGqKCCtULC+FVHkpkWRUmq1/hRURItatUtbK1YWoC0tCkUEpIEi2gCRFAiJIQEyAXKdTCZMMrPfP9LGFEIAOTMnk/18/nCZkzPnfEtdPHMuc0YqpQQAALqymD0AAABmIoQAAK0RQgCA1gghAEBrRobQZrPdf//9qamp/fr1mzt3blVVlYEbBwDAG6RRd406HI7MzMyUlJTevXtv27YtJyfniiuu2L17d2hoqCHbBwDAGwwL4auvvpqQkDBhwgQhRENDwz333PPxxx+/8cYbM2fONGT7AAB4g2GnRhMTExsrKIQIDAx8+umnhRC5ublGbR8AAG8wLIR33XVX8x+TkpKa/gkAQJvlrbtGDx06FBwcPGnSJC9tHwAAQxh2jfAs999/f3x8/PPPP3++Faqqqq699tp+/fo1LbnjjjumTp3qjWEAADifQG9sdP/+/Tk5Odu3b29lHafTeeLEiV/+8pdNSzIzM70xDAAArTA+hFVVVfPmzVu7dm1YWFjra3LuFABgOoOvEbrd7lmzZr344os9evQwdssAAHiDkSF0u92zZ89+5JFHBg0a1LjE4/GUl5cbuAsAAIxlWAgbGhqmTZuWmZkZHx9fUFCQm5u7c+fO6dOnnzp1yqhdAABgOGOuEdbX1//oRz9at27dBx980Hz50KFD+/TpY8guAADwBmM+PlFbW7tz585zlyclJaWlpbX4EpvNlpGRUVJScvl7BwDgezPmiDAsLOzmm282ZFMAAPgS30cIANAaIQQAaI0QAgC05pVHrAEAzLV69epFixaZPYVhpJRLly5t+rI/YxFCAGiH8vLyxo4d++ijj5o9iDGWLVt25MgRL22cEAJA+xQTE9OzZ0+zpzBGdHS09zbONUIAgNYIIQBAa4QQAKA1QggA0BohBABojRACALRGCAEAvvPFF19MnDhxwIABI0aMWLhw4YkTJ8yeiBACAHxl1apVP/jBD6677roPPvhg2bJlVqv1hRdeMHsoPlAPAPAJh8Mxe/bsV1999b777mtcMnz48Lq6utzc3M2bN8+dO7dx4d69e3fu3Pnwww/7bDCOCAEAvrBr166ampqpU6c2XxgSEpKUlPTUU0/l5+c3Lnn++eftdrsvB+OIEAC0sPm4mvkPt892F2kV/7or0CK/W1JSUtK1a9fAwLO7ExERMWXKlHfeeefZZ589ffr0J5988sorr/hsTkEIAUATo7rJzbcF+Gx3UVbZvIJCiA4dOpSVlSmlpJRnrTxr1qxRo0Y99dRT77777tixYzt37uyzOQUhBABNBEjRM/LsAvnSsGHDXC7Xjh07RowYcdav0tPT09LS1q9f/7vf/e6NN97w8WBcIwQA+ELnzp1nz549Y8aM7OxsIYTb7d6yZcvLL7/c+NuZM2fOmzdPKTVy5EgfD8YRIQDAR1544YWOHTveeuutbre7vr4+PT192bJljb+aMGHCnDlz5syZc+6JU28jhAAAH7FYLD//+c8XLVpUVlYWFRUVFBTU9CubzVZfX9/0yQqfTuX7XQIAdCal7NSpU/MKvvXWWxMmTPjpT38aFxfn+3k4IgQAmCwmJmbRokW33367KXsnhAAAk02aNMnEvXNqFADgO5s2bRo3blxqaurgwYNnz55dWFho9kSEEADgK++8884Pf/jDO++8c/Pmze+88063bt1Wrlxp9lCcGgUA+ERNTc2jjz76+uuv33vvvY1LBg4cWF9f73Q6Fy5cOGvWrLS0NCHEihUrkpOTx48f77PBOCIEAPjCzp07nU7n5MmTmy+0Wq2hoaF9+/adOHGi0+lcu3btihUrzn30jFdxRAgAWqg7+HX5e8/5bHeWiOguT74tmn06vrS0tEuXLgEBLTzv9KGHHtq6dev06dO3bdu2YcOGjh07+mxOQQgBQBMhfQZ1Wfx7n+1OBgSI/31GTHR09OnTp1t86LYQYvny5cnJyQ899NCQIUN8NeN/EEIA0IOUlrAIE/c/fPhwt9v9+eef33TTTef+9vHHHx89evTq1avnz5/fs2dPXw7GNUIAgC/ExcU99thjM2bMyMrK8ng8Lpfrr3/969KlS4UQb7/99v79+9etW/fkk09OnjzZ5XL5cjBCCADwkV//+tePPPLIlClToqKiOnXq9Morr9xwww3FxcWvvfbamjVrwsLC5s2b16dPn9dff92XU3FqFADgI1LK+fPnz58/3+l0hoSENF0s3Lt3b9MK77//vo+nIoQAAF8LDQ01e4TvcGoUAKA1QggA0BohBABojRACALRGCAEAWiOEAACt8fEJAGiHIiMjn3322ddee83sQYzhdDpfeuklL21cKqW8tOnW2Wy2jIyMkpISU/YOAO1eRUWF2SMYRkoZHR3tpY1zRAgA7VNMTIzZI/gHrhECALRGCAEAWiOEAACtEUIAgNYIIQBAa4QQAKA1QggA0BohBABojRACALRGCAEAWiOEAACtEUIAgNYIIQBAa4QQAKA1Qgj8hznfzAnAbHwfIfRy0ilO1KpjDnG8Vp1wqGMOUeJUxTWipFad8YjCH1pjg80eEYBvEUK0N0oIW6045lDHa1VRjTjuUMccotihjjvE8VoVZRVdw2RiuEgIl93C5DWdRdcwS2K46BomO4WYPToAMxBC+KuyM+KYQxXVqKIaccyhjjnE0Rp1zCGOO1THYJEQLhPCZY8IkRAmr+gokiIs3cJE93AZEmD23ADaGEKINs3laaydKKpRhTWiuEYV1ahihzhao4IDRGK4TIoQieGye7gc0130iLB0DxcJYTKY2gG4aIQQbUKdWxTaVWGNOFqjjtrV0RpxtEYV1ojTdapbmEwMFz0iZI9IMSROTkixJEWIpHAZYTV7aADtAiGET7k84qhdFdaIb+2qsNm/VLhEjwiZHCF6RMoeEXJsokiOsPSIFN3CZIA0e2gA7RohhLeU1IoCu/rWrgrsoqBafWtX39rFyTqVECZTIkVKpEyOlOMSRUqkJTlSdA2T9A6AKQghLpfLI761q4JqkW9X+dWqwC7yq1WBXUVZRUqk7Bkpe0aJEV3l9DRLz0jRPZwjPABtCyHEJahzi/xqlVetjlSLI1XqSLXKtwtbreoeLlOjRM9I2StK3tBV9Iy0pEbJcP7jAuAP+LsKLav3iAK7OlylDleJvCp1pFrlVYuTTpUcKXtFid5RcmBHeXeKJTVS9IiQgTyhCIDfIoQQQojjDnWoShyuUoer1MEqlVcljjlU93DZu4NI6/Cf5vWOEkkRnNgE0N4QQu3UucWhKnWoUh2qEgcr1aEqdbhKhQWKvtEyrYNM6yBv7Cr7RMuUSBnEcR4ADRDCdq7SJf5dqXIr1MFKlVupDlaKEqdKjZR9o2WfDuLWRDl3gKVPB9khyOxBAcAkXgzhmTNngoN5gLFPVZwRBypUbqVq/GduhaipV32jZf8Y2Tdazuwq06NlSiSnNwHgO14J4dGjR5cvX/7NN99s2bLFG9tHI3u9+HelyilXByrUNxXqQIWoqVf9YuSAGNkvRo5LsqRHi8RwogcArTE+hFu3bv3b3/72m9/85uqrrzZ84zpzecTBSvVNhcop/0/2TjpVerTsHyP7x8gx3S39okVSBNkDgEsjlfLK15EmJycnJCRkZWWdbwWbzZaRkVFSUuKNvbcPNqfYV6b2lat9ZWp/ucq3q5QIOaCjHNhR9o8RV8TIlEhpIXwAcHm8dY0wKirKS1turzxK5FWr7NNqb7nKPq32lSu3Eld2lFfGyjHd5c8GWvpF86UKAGA8b4XQauWrAS7A5RE55WpvmcouU9llan+5ig+RGZ1kRqyc3d+SESsSuLwHAN7Hxyd8p6ZeNGbvX2Uq+7Q6XK16RcmMWJkRKyelWK6K5TMMAGAC00LocrnKysoGDx7ctOTHP/7x3LlzzZrHG5wNYm+52nNKfXVKfX1aFdaoATFyUCd5Tbyc1c8yIIZvSwcA85kWwqCgoA4dOrz55ptNS3r16mXWMEbxKHGoSu0+qb48pXafUgcrVb9oOSRO3tBVPnqFpX+MtPKsFgBoY8w8NRoYGJiZmWniAIYodYrdJz2N5dtzSsWFyGHxcmicnNbbkhHL7S0A0NZxjfCSORvEv8r+c9j3z5PKXq+Gxslh8XL+gIBh8TKWZ+kAgF8hhBflmENllaqdpWrXSXWgQg2IkcPi5Q+S5NOZlrQO3NsJAH7MWyG02+0ej8dLG/eNw1Vqh01tL1E7SpWjXl3T2XJtZ/nycEtmJ25yAYD2w/gQnjhxYvv27cXFxYGBgR9++OHIkSM7d+5s+F68waPENxXqC5v6h019YfNYLfKGLnJEV7noKkvfaA77AKB9Mj6EYWFhw4YNO3DgQOOPoaGhhu/CQI4G8eUp9Q+b2nXSs7NUdQmV13eRtyXK54cEJkcSPwBo/4wPYXR0dHR0tOGbNVBtg9hhU1tLPNtLVE65ujJWXttZPtjX8ocbLHEhZg8HAPAtXW6WUULsK1N/P642HfN8eUoNipWjulmWDrUMjeOCHwBorZ2HsNihPj+hPjuuPjvuiQqSt3SXj14RcEMXGcGTUAEAQoh2GcICu/qiRG23qR02Za9XN3a13NRNPpPJNT8AQAvaSQir68Xfj3k2HlObj6sGj7ixq7y+i1ww0JIeLakfAKAV/h3CUqdYf9TzUaFnZ6m6tou8LdGyYKClD59wBwBcNP8LYXW9+PKk+sLm+ftxdbhK3drdcn8fy5qbLFz2AwB8D/4Rwjq3+KTYs6FI7TypjjlURqy8vov8v8EB13WRQXyfAwDgMrT1EBba1cpczx/yPFd2lOOTLfMGWPrFyADOfQIADNJGQ6iE+PyEei3Xs8PmuT/NsudO7vkEAHhFmwuhW4n3j3iW7fMEWMSsfpY/3mgNb3MzAgDaj7YVmWKHmvCZOyxQrLw2YGRXDgEBAF7XhkJYXS9u/sT9//pYFgy00EAAgG+0oRA+8y/3dZ3l4wO5DRQA4DttJYT2evHOYc/+u9vKPAAATbSVw69Piz3D42VCOOdEAQA+1VZC+EmxGpfYVoYBAOijrbQnq1SN7MbhIADA19pECKtc4qRT8bBsAIDvtYkQ/qtMXRkr+cwEAMD32kQID1aq9GgyCAAwQZsIYV6V6s15UQCAGdpECA9Xqd5RZg8BANBSmwhhgV30iuKIEABggjYRwqIalRRBCAEAJjA/hKfrRHCAiLSaPQcAQEvmh5DDQQCAicwPYbGDEAIATGN+CItqRFK42UMAAHRlfgiPOVR3vnQCAGAS80NY7BCJEWYPAQDQlfkh5IgQAGCithBCkRBm9hAAAF2ZHEJHgyh1qh7cNQoAMInJIfymXKVHy0Dzj0sBAJoyOUH7y9XAjhwOAgBMY3IID1WpvnwTIQDAPCaH8Ei16MUXMAEAzGN6CBVfwAQAMJHJIfzWrnpGEkIAgGlMDaEl0OUREXwBEwDAPGaGUAVYg/jgBADAVCaH0EoIAQCmMjVEHBECAMxm6hGhJTAogDtlAABmMvmIkFOjAABzcbMMAEBrpoYoMIgjQgCAucy+RkgIAQCmMvcaYVBQgJn7BwDA5CNCTo0CAMxl8jVCTo0CAMzFk2UAAFoz9xphYJCFD9QDAMxk7jVCKzfLAADMxZNlAABa48kyAACtcUQIANAaR4QAAK3xZBkAgNbMPSIMtPLpCQCAqTgiBABojWeNAgC0ZvKTZaw8WQYAYCpzjwgDgjk1CgAwlZkhDNv17vTenBsFAJjJzA4F2EvjQkzcPwAA5l4jBADAbIQQAKA1QggA0BohBABojRACALQWaPYA33EdPXjmyH6Po9pTV2sJCRPyu0grV51yN1iCQ4UlQFqDpDVIBgTKoPPecipDwqTl7I8oypAwablA+GVwqDjnhWevY7HIkLCWfxUYJK3BrbzWEhouJM8QAIA2pG2E0OMp//BlV/43oQOvsUTGBHbq5qmrFcrT9HsZ3UkGBHrOOIXHrVxnPLU1yt2gXHXn256qq1Ued0sLPS2u/906Z5zinBeevY7Ho+pqW/5Vg0vVn2nltR6nQyh17nIZHCoDWg6wJTRCiBbaKYNDZEAL//fJ0IgWFgYEyuAW3jdYgkJEoPXslQOt5+ZcBrb8zsPS4u4u+o1Ii+88ZFCwbGGqFt5knO8PAQAunvF/iVRUVJSWlqalpVkudPjVxP75Gnd5aeeFb0prkOHz+AV1xqncLQfY46wRooV2qjN1yt3QwnJnTQsL3Q3qTAvvGzyuOtFQf/bKDfXn5lw1NHhqW9hyQ5mthd3VOc59z9HiG5EW33l4XGdamqqFNxkt/iG0+K5CWoNl4Dn/dQVaLUHN4hoQ0GnGM5awyHP+BwFoz4wMoVLqiSeeOHjwYGZm5qZNm1auXDlo0KALvsrjrLFvXRf/2G+0raBo/Lv7PL+yhLVwyIVWtPiuQtWfUQ2ucxb+T/KlxdLiAS6A9s3IEC5cuHDLli179uyxWCxDhgwZM2ZMTk5O165dW3+VY9fGkH5DAzt2NnAS6Ow87yooHICWGXbXaF5e3ssvv/zQQw81nhEdO3ZsSEjI4sWLW3+Vaqh3ZG2IuPYHRo0BAMAlMSyEq1atqq+vHz58eOOPUsphw4Z9+OGHtbUt31fSqHrj+9buvYKS+xo1BgAAl8SwEG7evFkI0fxEaEpKSm1tbXZ29vleEmiRNds/jpk0y6gZAAC4VIaFsLi42GKxxMTENC2JjIwUQhQVFZ3vJVFBATI4zBIRbdQMAABcKsNCWFlZGRMT0/wjEwEBAUKI850adblcHoc9/4St438988wzRg0DAMBFMuyu0Y4dO1ZWVjZf4nA4Gpe3uH5QUFCPzp1S+1+Z/9LHjUuaH00CAOAbhoUwISGhqKjI7XYH/PezzHa7XfzvVcOzRAcHBneIoX8AABMZdmp00KBBSqni4uKmJfn5+ZGRkZmZmed7SYfgAEt4lFEDAADwPRgWwunTpwshtm/f3vijUionJ2fixIlW69kPjWzSISiQx1kBAMxlWAgHDx48derUdevWNf742Wef1dbW/upXv2rlJZFWjggBACaTqqUvQ/h+HA7HlClTEhMTe/XqtWbNmhUrVgwePPh8K9tstjHXDN2b8w0tBACYyMgQNsrLy7Pb7QMHDgwMbO1OHJvNlpGRUVJSYuzeAQC4JMZ/DVPv3r0N3yYAAF5i2DVCAAD8ESEEAGiNEAIAtEYIAQBaI4QAAK0RQgCA1gghAEBrhBAAoDVCCADQGiEEAGiNEAIAtEYIAQBaI4QAAK0RQgCA1gghAEBrhBAAoDVCCADQGiEEAGiNEAIAtEYIAQBaI4QAAK0RQgCA1gghAEBrhBAAoDVCCADQGiEEAGiNEAIAtEYIAQBaI4QAAK0RQgCA1gghAEBrhBAAoDVCCADQGiEEAGiNEAIAtEYIAQBaI4QAAK0RQgCA1gghAEBrhBAAoDVCCADQGiEEAGiNEAIAtEYIAQBaI4QAAK0RQgCA1gghAEBrhBAAoDVCCADQGiEEAGiNEAIAtEYIAQBaI4QAAK0RQgCA1gghAEBrhBAAoDVCCADQGiEEAGiNEAIAtEYIAQBaI4QAAK0RQgCA1gghAEBrhBAAoDVCCADQGiEEAGiNEAIAtEYIAQBaI4QAAK0RQgCA1gghAEBrhBAAoDVCCADQmrdC6PF4vvrqKy9tHAAAoxgfQo/Hs2bNmv79+8+dO9fwjQMAYCzjQ5iVlRUUFFRYWGj4lgEAMFyg4Vu8/vrrhRDdunUzfMsAABjOW9cIIyMjvbRlAAAM5K0QBgQEeGnLAAAYyPhToxdPKVVRUdH0Y0REhNVqNXEeAICGLiGETz755Oeff36+344bN27JkiUXvzWXy3X69OnU1NSmJU888cQTTzxx8VsAAODyXUIIn3vuOQN3HBQUFBcXV1JSYuA2AQC4VDxZBgCgNUIIANCaFx+xppTy0sYBADCKt+4araysbGho8NLGAQAwivFHhNnZ2QsWLLDb7SUlJY8//viBAwcM3wUAAEaRZp3AtNlsGRkZ3DUKADAXN8sAALRGCAEAWiOEAACtEUIAgNYIIQBAa4QQAKA1QggA0BohBABojRACALRGCAEAWiOEAACtEUIAgNYIIQBAa4QQAKA1QggA0BohBABojRACALRGCAEAWiOEAACtEUIAgNYIIQBAa4QQAKA1QggA0BohBABojRACALRGCAEAWiOEAACtEUIAgNYIIQBAa4QQAKA1QggA0BohBABojRACALRGCAEAWiOEAACtEUIAgNYIIQBAa4QQAKA1QggA0BohBABojRACALRGCAEAWiOEAACtEUIAgNYIIQBAa4QQAKA1QggA0BohBABojRACALRGCAEAWiOEAACtEUIAgNYIIQBAa4QQAKA1QggA0BohBABojRACALRGCAEAWiOEAACtEUIAgNYIIQBAa4QQAKA1QggA0BohBABojRACALRGCAEAWiOEAACtEUIAgNYIIQBAa4QQAKA1QggA0BohBABojRACALRGCAEAWgs0dnOHDx/esWNHSEjIdddd16NHD2M3DgCA4YwM4dKlSxcvXtzQ0CCECAkJeemllx5++GEDtw8AgOEMOzWalZX16aef7t69u6qq6qOPPgoPD58zZ87u3bvPt77dbi8vLzdq7zq7//77s7OzzZ7C733yySeLFy82ewq/53a7Bw8ebPYU7cH8+fO3b99u9hR+Lysr65FHHrngaoYdEW7fvn3Dhg3h4eFCiLvuuqu2tnbq1Knr168fNmxYi+s7nc7GY0dcpuLi4rKyMrOn8HulpaUnTpwwewq/53a7c3JyzJ6iPTh+/PjJkyfNnsLvnTp16vjx4xdczbAjwgcffLCxgo1uueUWIYTL5TJq+wAAeINhIYyNjW3+45kzZ4QQN9xwg1HbBwDAGy7q1GhdXV1JSUkrKyQnJ0spmy/ZuHHjoEGDbrvttta3/P777zf9e5cuXWJiYi5mHjRXXV2dl5fHH91lKiwsLCsr+/rrr80exL/V19crpfhjvHwVFRUFBQX8SV6m/Pz8xqOy1kml1AVXys3Nffrpp1tZ4fe//31ISEjTj3V1dVdcccV777139dVXn+8lBQUFvXv3bv6q2NjY+Pj4Cw6Ds5w4caJjx47N/yTxPdTU1NTW1vJf4OUrKCjo2bOn2VP4PZvNFhUVFRYWZvYg/q22tjYxMXHTpk2tr3ZRIbxUS5YsiY+Pv5h7dQAAMJfxT5ZZs2ZNVVUVFQQA+AWDnyyza9eubdu2rVy50tjNAgDgJUaGMCsr6913333zzTebbpzJzs72eDyZmZkG7gUAAAMZdo1w27Ztd9xxx0033WS1WoUQbre7rKzs4MGDR48eDQ4ONmQXAAAYzpgQVlRU3HnnnbW1tWctv+2221q/3RQAAHN55a5RAAD8hTnfR7hv376JEydOnTp18uTJ+fn5pszQPpSVlf3iF7+YMWOG2YP4MZvN9pOf/CQ1NbV///7z5s2rqqoyeyJ/tWXLlhEjRiQkJNx4440bN240exy/V1dXN2TIkGXLlpk9iB+bP3/+Pf+1YMGC866nfO7rr7+OjY3Nzs5WSm3ZsqVr167FxcW+H6MdWL9+/d133y2EuPvuu82exV/Z7fa0tLSxY8fOnj17wIABQogrr7zS6XSaPZf/2bJly+jRo1977bUnn3wyLCwsKCgoNzfX7KH825w5c4QQTz31lNmD+KutW7dGRETE/NfKlSvPt6bBH5+4IKXUzJkzb7755quuukoIMWrUqKSkpHnz5q1du9bHk7QDt99++7hx40JDQ80exI+9/fbbS5cuHT9+vBCivr5+4sSJ69ev/+Mf//jAAw+YPZqfyc7O3rhxo8ViEUKkp6dPmzZt/fr16enpZs/lrzZv3vztt9+aPYV/W7Zs2aFDh7p163bBNX19ajQrK2vPnj3NH8Y9YsSIjz/+uKioyMeTtA8WiyUyMtLsKfxYcnJyYwWFEFartfHergMHDpg6lF967LHHGisohBg1apQQIiUlxdSJ/FhlZeWzzz67YsUKswfxYzt27PB4PI2fYrggX4fw008/FUIkJyc3LUlPT/d4PNu2bfPxJO0GTxm9HHfddVfzH5OSkpr+ie8tLy/vmmuuaTxvj+9h1qxZzz33HO9xL8fTTz+9adOmLl26jBkz5ssvv2x9ZV+H8PDhw+J/v7MpOjpaCHHo0CEfTwKc69ChQ8HBwZMmTTJ7ED928uTJJUuWfPDBB4GBvr7y0j689957aWlprXxjAS6orq7u9ttvnz9/fnp6+ubNm6+99tp33323lfV9HcLTp0+L/w1h4wENt+qhLXjjjTcee+yxxMREswfxSx6P58UXX+zXr9+OHTuGDx/OV9V/D8XFxatWrVq0aJHZg/i3kJCQOXPmLF++PCcnZ/Xq1aGhoTNmzNi/f//51vd1CBvv7Gh+3rbxY/gRERE+ngQ4y969e//9738vXrzY7EH8lcVi+dnPfpadnX3vvffabLZp06aZPZGf8Xg8Dz/88MqVKy/yyhYuSEp5zz33/OUvf3G73b/97W/Pt5qvz10kJCQIISoqKpouwzgcDiFEXFycjycBmqusrHz00UfXrVvHXbiXKTExcdWqVWVlZZs2bSotLe3cubPZE/mN119/vbq6+qOPPmr8sfHvxqysrKVLl06ZMqV79+6mTufHRo4cecsttxw5cuR8K/g6hH379hVCnDx5smlJcXGxEGL48OE+ngRo0tDQ8MADD7z00kucFDXKfffdt2nTJi4TXpLy8vJjx4699dZbjT+63W4hxFdffZWfn3/TTTcRwstx1VVXtfLZBF+fGh0/fnxAQMCuXbualuTm5nbp0mXYsGE+ngRo5Ha7Z8+evWDBgoyMjKYl5eXl5k7l76xWa2pqavO7AXBBS5YsyW9mz549Qoi5c+fm5+cPHjzY7On8W35+foD/dQcAAAGsSURBVCu3Mfs6hKmpqdOnT2/8EIUQ4syZM5s3b16yZAnvHL83h8PhdDrNnsJf1dfXT506dejQoZ06dSooKMjNzd25c+e0adPKysrMHs3PFBYW1tfXN/34hz/84bnnnjNxHuisqKho7dq1jYfUQoitW7fW1dW1EkIT8rN8+fIxY8a8+OKL48ePX7JkyeTJk2fOnOn7MdqB6urqr776qrq6+sCBA/v27UtPTw8KCjJ7KH/icrkmT5785z//+cMPP2y+/Oqrr+7du7dZU/mj48ePp6SkJCUlPfjgg4mJiRs2bBg9ejSfQoFZ/vSnPy1cuHDAgAHjx48/evRoXFzc6tWrm74o91zmfPuEy+Vau3ZtUVHRyJEjOSn6vR0+fLj5We+BAwfGx8ebOI/fcTgczc/SN+nRowchvFRbtmz55z//qZTq1avX6NGjOSl6+Vwu1xdffNGzZ8+ePXuaPYufaWhoWLt2bV5eXmxs7K233nrBP0C+hgkAoDVzvoYJAIA2ghACALRGCAEAWiOEAACtEUIAgNYIIQBAa4QQAKA1QggA0BohBABojRACALT2/wGJ+cMhDcKUmQAAAABJRU5ErkJggg==", + "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" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] }, "execution_count": 15, "metadata": {}, @@ -554,8 +1709,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Mean lift coefficient = 1.0383119099930695\n", - "Mean drag coefficient = 0.08669043665803298\n" + "Mean lift coefficient = 1.0383119099930727\n", + "Mean drag coefficient = 0.08669043665803317\n" ] } ], @@ -575,27 +1730,36 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Set up a polar grid on which to plot" + "Set up a Cartesian grid on which to plot" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 42, "metadata": {}, "outputs": [], "source": [ - "rmax = 5.0 # largest radial coordinate (smallest is 1)\n", - "ϵ = 0.00001 # small offset from the surface of the unit circle\n", - "\n", - "nth = 400 # number of circumferential points\n", - "dth = 2π/nth\n", - "θ = range(0,2π,length=nth+1)\n", - "dr = dth\n", - "r = [1+ϵ]\n", - "while maximum(r) < rmax\n", - " push!(r,r[end]+dr)\n", - " dr = r[end]*dth\n", - "end" + "xg = range(-1,1,length=101)\n", + "yg = range(-1,1,length=101)\n", + "zg = [x + im*y for y in yg, x in xg]\n", + "ζg = inverse_conftransform(zg,b);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Enforce no-flow-through in the circle plane" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "Bodies.clear_images!(b)\n", + "Bodies.enforce_no_flow_through!(b, motion, (fs_circle,ambient_ω_ζ), t)" ] }, { @@ -607,21 +1771,141 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 44, "metadata": {}, "outputs": [ { "data": { - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdd3Bb6Xk/+oNOdIDonU0sYCfVmyV5d7WWVju53vg61fF6PPZNm9yUa0/u5Jdsss44mZvE9nXsjGcSj8drZ25m15nJ7motebsqJUpibxILSPR+Dno9uH884QksabXSiiIOiOfzx5kDECRfgBK+eN/zvu/DqVQqBEIIIdSouLVuAEIIIVRLGIQIIYQaGgYhQgihhoZBiBBCqKFhECKEEGpoGIQIIYQaGr/WDdhpMpnM2NjYzZs38/n8X/zFX9z3Mclk8jvf+c7S0tLw8PAf/MEfCIXCbW4kQgghBgfXEW6t119//aWXXtLr9ZOTk4FA4L6POXnyZFNT02/91m9973vfa2tr++EPf7jNjUQIIcTAIHwiPvzww89//vP3DcKpqanDhw+HQiGxWOz3+1tbW9fW1kwm0/Y3EiGEEIHXCLff1atX9+3bJxaLCYIwmUytra03btyodaMQQqhx4TXC7RYIBDQaDXNTp9P5fL77PjKXy+3evdvpdBIEIRQKf/jDH+LVRIQQ2nIYhNutqampWCwyN/P5vEQiue8jc7mcy+X6q7/6K4Ig5HI5piBCCD0JGITbzWq1vvbaa3BeqVTcbrfVav2oBwsEgs997nPb1TSEEGpEeI1wm5w/f35lZYUgiM985jMLCwuzs7MEQbz77rs0TR86dKjWrUMIocaFQbjFVlZW2tvbf+M3fiMSibS3t58+fRru/9rXvvbOO+8QBKHRaL7xjW+cOHHizJkzv/7rv/6tb30LxzwRQqiGcPnEFisWi263m7kpFAph5NPr9SoUCrlcDve7XK7l5eXe3t4HLJwgSbK1tTUejz/pNiOEUCPDIGQvDEKEENoGOFkGsUK5XE4kEnfd+VEfAhKJRLlc3qpfLZVK7x2d5vF4CoWi+h6VSsXhcLbqlyKE2AODsOFAitA0TVEUQRC5XC6bzRIEkUwmS6USQRAURdE0TRAESZKVSqVSqZAkSRAEc0JURVEmk8nn88QvJxlzJ0EQqVSKWS5SHWBMAwCXy1UqlXc19aOyR6FQ8Hi8LXgtCIIgiHQ6XSgU7rrz3mCuTuXq7GQa2dTUBPskMCfMw9RqNUEQEolEJBLx+XwYIYc7lUoll8uFZwRHpVLJ4/FUKpVAIJDJZFv1NBFCHwWDkNXK5fKrr75KbIYThBYTIfAOzrxlQ+QwX2XSCN7BmcCTy+V8Pp8JHuZdG+4nNt+aiaq3eHjLrj6x2+3wYLFY3NTURPxykjF3EgQhk8kEAgGcVwcYh8NRqVRP8sV7gqrTHT4uEASRzWZzuRxR9VLDw5gPEPAXKRaL8BdZXV0lNv+y8BEBjiRJ0jRNkmShUEin0xCfSqVSKBTK5XKpVCoSiVQqFfzh1Gp1U1OTRCJRqVRSqVQqlcpkMqVSCecKhYL5ayKEPgpeI2QvkiQtFgvMO4UIEYlEEomEiRB4i2QG8SBymECCrxKb6cUEHqov8HEHcjGVSqXT6Xw+T5Ik5G48Hs9ms5lMhqKoVCqVyWRSqRRJkul0Op1OJ5NJkiTFYrFMJpPL5SqVCmZsMUe1Wq1QKCAvq9XvZxSEPgEMQvbCyTJoS6TT6VQqlUwmKYqiKCqZTCYSCTiSJElRVCKRoO6hVqtVKpVKpYJchJvqKiqVqrm5Wa1WNzc3M51+hOoRBiF7YRCiWoHh3Hg8TpIkhGU8Hoeb8XvEYrGmpiYmFJubmzUajUajYc6rjxiZiIXwGiFC6G4cDge6fQ/5+GQyGYvFYrFYPB6PRqPRaDQWiwUCgbm5ObifuVMikWg0Gp1Op9mk1WrhHq1WC+darRbzEm0n7BGyF/YI0c5DUVQ4HI5uikQicAyHw8x5JBKRy+V6vV67SafTMTd1Op3BYNBqtR+1Wz1CjwqDkL0wCFHDYhIRBINBOAmHw6FQKBQKRSIRHo8HoajT6SAp9Xo9nBuNRjjB/QvRw8AgZC8MQoQeIJVKBYNBCMVwOBwIBKBbGQqFAoEA3CmVSpmkNJlMzAlEptFovHf1KmpAGITshUGI0GOKRqOQlMFgEFIzHA77/f5wOAwnhUIBEhE6kUxGms1m6GXqdLpaPwn0xGEQshcGIUJPWjabhd4kk5Fw4vP5YBg2Ho/DoCtkpMFggJ6l0Wg0GAyQlLj3Xr3DIGQvDEKEaq5UKsFVScjIQCAAY7CBQAC6mLFYDPqOZrMZktJoNEJwMklZ6yeBPgYGIXthECLEfnclZTAYhKFXn88HSUlRVHVXkslL6GIajcaHX6aCnhAMQvbCIERoBygWi0xXEvISApLpYmYyGaYHyeQl06E0m81MHVP0hGAQshcGIUKNIJ/Ph0Ihn8/HdCghICEvfT5fqVS6NyCrT7BKyWPCIGQvDEKEEEEQ2Wz2vgHJDMnSNF2dlF//+tdbWlpq3ep6glusIYQQq4nF4paWlgdkWyaTYWbx+P1+KJGGHh72CNkLe4QIIbQNsGInQgihhoZBiBBCqKFhECKEEGpoeE0VbYFEIlEul3O5XDabhZquBEFkMpl8Ps/czOfzmUyGuZ8giFQqVSwWCYJIJpOlUqn6SzRNUxQFP7xcLicSCeZ3URRF0zRzM51OFwqFu9qTzWZzudxjPimVSnXX1llisbipqeneB3A4HJVKBXcqFAoej0cQhFKp5HK5fD4fFoHJZDKBQCAUCqVSKdzJ4/HgwQqFQiAQyGQykUgkkUjgkY/ZeITQw8MgbAiQK5Ao1cdSqQQhxBzhfiaHYKoOZA88BrKqUCik02km5ORyOZ/Pb2pqEovFBEHAThkQG0xIQAYQBCGRSEQiEUEQMpkM1j/ZbDZ462e+VB0tEBXMc2GSBjDfUo1pyeMgSfKuqWR35SvzgOrYhteW+Sq8qgRBpFKpVCoFr1v1Sw3ncD98koDPB2q1Gl4xuVze1NQkl8uZE6VSKZFIpFKpUqmUy+VSqVQmkymVSrgpl8uxUB9CjwRnjbIXSZIOh+O9996DHIrH4/CGWywWmbdUeOuEcII3UHgjhm8hSRKOXC4XOihKpbK6IwJH6KBUd1PgkcRmpMH3wmMg3uA9ujqu0NaKx+PQh04kErlcLpVKJZNJiEmKotLpdCaToSgqkUik0+lUKpVIJEiSTCaTyWSyWCzK5XK1Wq1UKhUKhXKTSqWCI1BXqfXTRaiWMAjZiyRJs9nsdDohsVQqFY/HUyqVkFgQRTCYBuEEQ2oQV8y3cDgcfJtrNMViMZlMkiRJkmQikaAoiqIokiThWC0ej8fjcZIkm5ubIRGbf5lGo4Ejc4KVFtDOg0HIXriOEG2PSqUSi8Xi8XgsFqs+iUajzAmIx+NarVazSavVarVanU6n3QQVi3DHL1RfMAjZC4MQsU25XGZCMRKJMGVvGcFgMBKJlMtlCEWDwQBJCdtJa7VaqFKk0+nuvbKLUK1gELIXBiGqU1DtNhgMQiH4SCTCFIVnSuCKxWKmwi1THZ6pt6DX6zEp0bbBIGQvDEK0g8ViMUjE6k0yq7eThqTU6/UWiwViEpISYlKv1+PVSrRVMAjZC4MQNbJ4PA7dR6/XCzEJSQkxGYvFoAIRw2g0ms1mg8FgtVr1ej2uxUQPD4OQvTAIEfooUO3W5/MFAgF/lUAg4PV6Q6GQRqMxGAwWi8VoNMLRarXCucFgwPoMqBoGIXthECL0yVQqlWAwCKF47xFi0mQyWSwWk8lk3gQ3DQYDDro2GgxC9sIgROhJoGka6tz6fpnX6/X7/fF4XK/X22w2g8Fgs9kgLyEjrVZr9SZHaMfAIGQvDEKEtl+hUAgGgx6PJxAIeDweCEhISo/HUy6XbTab0Wiszkiz2QzjrkKhsNbNR58EBiF7YRAixDbpdNrtdldnJPQj3W53MBhUq9XQcazuR0Jw6vX6WrcdfSQMQvbCIESojsCFSb/fX92DhIwMBAKJROLeHiR0K61W6+PvEY8eBwYhe2EQIrRj5PP5u3qQgUDA7XZDcDY1Nd2bjhCcBoOhutwKehIwCNkLgxChBhGLxaAHCekIQ6+QkZFIRKvVMrN1IClhNYjJZNJoNLVu+06AQcheGIQIoXK5zEzeuSsjfT5fJpNhln8wC0JOnz6NNWceCa4qRQgh9uLxeJBz9/1qLperXvvh9Xqnp6dHRkYwCB8J9gjZC3uECCG0DbBHiHasYrGYSqWYm+VyOZFIPP6PbWpqqp7jB7WRH//HIoRqBYMQbZ98Pp/JZNLpdKFQSCaTpVIpkUhAPpXLZbgnlUoVi8VsNpvL5ZgkoyiKpmn4doIg4JEEQZAkCUMa8BMIgigUCul0Gn6dQCCorhDL4/G2ZFsQaNtdTwrOZTIZ7PUslUphbbVSqeRyuUKhUCqVEgQBA1YqlYrD4ahUKh6Pp1Qq4avwLSqVqqmpSSKRKBQKiUQikUjgwY/fbITQR8EgRB+DpmmKojKZTC6XI0kyl8tls1mSJPP5fDqdTqVS+Xyeoii4P5FIFAqFRCIBN5PJZLFYJEmyVColk0noPEkkEpFIBJmhUCh4PJ5cLufz+XCEPBCLxWq1Gu4kNuOE6XvBI5n7CYKAn0MQBBM5NcEkNIQ9sRnVEJaVSoUkSeZOeFni8TiEN3wCgFc4k8nAa57NZuPxuEQikUqlcrlcpVLJq6jVaoVCoVAolJtUKpVarVapVLgTGEIPD4Nwh8tms5Bb8K5KUVQqlcrlcolEIpVKQVbd9wQek06ni8WiSqUSi8VNTU1qtRoGBpVKJYSZVCoViUTM/QqFQiAQKJVKuAmJpVart6o3xnIQ28Rmz2+rZDKZVCqVSqXi8XgqlUokEslkMplMkiRJUZTP56MoiqIouBmPx+HPra7SXEWj0cBRo9HodDqVSrWFTUWoHuFkGfYiSbKlpeX27dvw3pfL5apPKIrKZrPQdYATkiQh9uLxOAzfxeNxCCS1Wi0WiyUSiVKplEqlkFgPPmlqalIqldB7q/UrgR4Z9DUZsSrRaDQajcZisUgkEg6HM5mMRqPRarVwNBgMWq1Wp9PBuV6vh3Nc0412MAxC9iJJ0mQyMeNgTU1NcCIWi2UymUKhEIvFUqkUul9wAmkHHTixWIyXl9DHKhaL0Wg0EolALgI4DwQCcBKNRiEdoRauTqczGo2wfyZTLx6TEtUvDEL2wuUTiCXK5TIEZDAYDAaDkJFQPh7qxUciEaYQrl6vh43Bqovi4rgCYjMMQvbCIET1Air8hUIhKHvr8XjgGAwGoRyuXC5nQvGuMkZGoxFmPCFUKxiE7IVBiHaMSCQCe4NV7xMG+6FEo1GdTmez2WDXaavVajab7XY73MSuJNoGGITshUGIGkGpVAoEAhsbG36/3+PxQEC63W44USqVFovFarXa7XbmBPISMxJtFQxC9sIgRCgQCEBZho2NDa/X6/F41tfXoZiRSqWCRHQ4HDabzWq12mw2h8NhMplw5g56JBiE7IVBiNADwPgqZOTGxgZ0ItfX18PhsMFgsNvtdrvdZrNBOkJY4lbU6L4wCNkLgxChT6BYLMLg6vr6utvtdrvdGxsb6+vrGxsb5XLZ4XBAQEJSwk2LxQJ746HGhEHIXhiECG2tRCLhdrtdLhcTkC6Xa2NjIxgMarXalpYWexW42Qg7IiEMQvbCIERoe5TLZZ/Pt76+Dp1IGGuFjORyudBxhL4jk5G46mMnwSBkLwxChGouHo9DLkJMMuexWMxisVT3HZmx1qamplq3Gj0aDEL2wiBEiLXy+TzTd6zOyI2NDZVKxVyDrM5InU5X61aj+8MgZC8MQoTqESyLvDcjM5lMS0vLXfN0YFkkVK9EtYJByF4YhAjtJOl0urrjyMxl9fv9Go2Gmc5qs9kgL202m1arrXWrGwIGIXthECLUCGia9vv9MJcVFkQyCz8ymQysgIR+pMPhgH0D7Ha7WCyudcN3DgxC9sIgRKjBZTIZZrFHdUC63W65XM5sF1C9sY7RaOTzseL6o8EgZC8MwgdLJBLFYpGiqFKplEwmi8ViKpUql8uJRIIgCHjdMplMPp9nblYqFZIk4dtTqVSxWIRzmqYpivpkzZBKpcwFHoFAIJPJCILgcDhQ+V0oFEqlUoIgoDakTCYTCARyuZzP56tUKjiXSCRNTU1YKR49kmAwCJvp3LuxzgcffHDgwIFaN7CeYBCy184Owkwmk0wmU6kUSZKpVCqVSqXTaZIk0+k0fCmRSGSz2XQ6TVFUPp9PpVLJZDKfz8P9uVxOoVBAnPB4PIVCASEE58Rm8EgkEtiaGfbWYvKJ+OUA43K5SqXykz2R6kCFMCaqEjefz2cyGWIzieHBiUSiXC6TJFkoFOCJ53I5iqKgrrJSqZTL5TKZDMovq1QquVyuVCoVCoVSqVRVUavVGJ/oLqVSiSAI7BQ+Enyx0ONKp9OJRCKRSFAUlUgk4vF4YhPkGUmSFEUlk0lIPoqiKIpqamqC93q1Wi2VSmUymVQqVavVEolEIpGo1Wq4CgJhAA+Wy+VCoVCpVIrF4h25VCuTyWQyGXjp4MNBMpmMx+PJZJKiKJfLRVEUWQVearVa3bxJ88v0er12E85LbBAYgZ8A9gjZqyY9QggqSDUA77lwztwPJyRJJhIJoVCoUCigvwJdFsUmuVyuUCjUajWcA+jcYH2ALUHTdDwej8VisVgsGo3CEUQikVAoBCfhcFgmkxkMBp1Op9PpjEajTqeDUvJ6vd5gMJhMJolEUutng1BtYBCy1+MH4V2pBt21j4o0SDuRSARJptykVquZc+Z+GLKDc/wEWhei0Wg4HA6Hw6FQKBAIwLnP54ObgUCAy+VCLkLVeLPZzFSQt9lscO0ToR0Jg5C9qoMQLiwxnTBm1LF6KBJSjXkYXHOqTi/ort0baUzawZW2Wj9vVBvJZNLn8wWDQa/XC8fqmvJcLhdqx1ssFqgmD1MWLRYLbpiC6h0GIXuRJGkymeRyeTKZLJVKTCesetSxeiiS+RIEGw4/oi2USCSgZLzX63W73VDnyO12e73eVCpVPX2fWejmcDiwH4nqAgYhe5Ek2dLScvv2bblcjotnEWtls9mNjQ2okVu90M3lcjU1NTFbbsLOKVDGQa/X17rVCP0PDEL22tnLJ1AjiEajTEmj9Sqw6yZwOBxw0traiqOsqCYwCNkLgxDtVKlUan19fW1tDQLS5XLBeT6fh0RsbW1ta2traWlpa2trbW3FIVb0RGEQshcGIWo0iUQCQhGsrq7CiVQqbWtrg1Bs22S1WvEqONoSGITshUGIEAgEApCLAM5DoZDdbodQbG9vZ47YfUSPCoOQvTAIEXqAfD7vcrlWV1dXVlaqjwqFgslFhsFgqHV7EXthELIXBiFCn4DP54NEZKJxZWUlk8m038Nut+N2EIjAIGQzDEKEtkoikVi5RzAYtNls9wbkjtzJFj0ABiF7YRAi9EQVi0W32736yxYXF4VCYVsVp9PZ19eHhT52MAzCrRcMBv/u7/7O5XLt27fvj//4j6EMULXvfe97brcbzi0Wyx/+4R/e9+dgECK0/Wiadrvd93YfBQLBvX1Hs9lc6/aiLYBBuMUqlcrIyMjo6OgLL7zw93//9z09Pf/yL/9y12P27du3f//+3t5egiC0Wu1nP/vZ+/4oDEKE2CMUCt2bjolEojoXYYZOS0sL7tlbXzAIt9i7777727/92x6Ph8vlrq6u9vb2er3e5ubm6sfs27fvr//6r5999tkH/ygMQoRYLpVKVU/JAV6v12w2Vy/qgJNPXPwZPWk4Y2qLjY+PHzx4kMvlEgTR1tam0Wimp6ePHTt218P+7d/+7c033+zt7X3xxRfxyjxCdUomkw0ODg4ODlbfWSwWNzY2mIC8fv06BKRIJIJErIbbArABBuEWCwaDGo2GuanVagOBwF2POXnypF6v5/P5P/7xj3/0ox9dunTpvgMp5XI5nU4//fTTBEE0NTX97Gc/wyLjDwNqu2cymXg8nslkstksRVHZbDaXy5EkWSqVEolEPp/PZDKlUimZTBIEQZJkpVIpFArpdBp+yF0d8Uwmk8/n7/vrxGJx9UeZpqYm2CFdIBDAym6pVCoUCuF+kUgkkUjgHpVKJRaLxWKxSqWSSqUymUwmk2HZkB2AuZp41/2hUIhZ73jp0qUf//jHq6ur4XAYtgVob2+v3jdHoVDUpPGNCYNwi0kkkur30Gw2K5VK73rM3/zN38DJF77whba2tl/84henT5++90fxeDyRSPT1r3+dIIimpqbGTMFyuRyvAgWEmRMou5jYlEwm4/E4hIpUKlWr1UzSQA4plUqBQKBWqyGQ+Hy+XC4nCEKpVHK5XKFQyPyxVCoVh8NhmiGRSO6d9AQgYu+9WSwWU6kUQRDpdLpQKORyOfhSNptNpVLpdHp1dRXuicfj6XQa8huekUQigapbjObmZrVa3dzc3NzcrNmk1+txtK2O6PV6vV6/f//+6jvz+Xz1pjmXLl2CmyKRCHKR2Xm1tbXVbrc35vvAk4ZBuMVsNtvly5fhvFAo+Hw+m832UQ+WSCQOh+PeLiODz+c/9dRTW99KFkgmk5FIJBwOR6PRaDQai8WYk+rzRCIBGQAgFeC8paWluhwjuCvAtoFard7ynwlVl5mwZz4HuFyumzdvwusTiURCoVA+n9dqtVqt1mg06vV6rVZrNpsNBgMUmod33m1+QdAjEYlE3d3d3d3dd90fCoWYDVdv3Ljx6quvrq2teb1evV7fWgW2JjebzXA5Bn0yOFlmi/n9/vb29omJia6urp/+9Kcvv/zywsICh8MZGxvL5XLHjh3LZDK5XA6mz1y7du3YsWPXrl0bGBi490fV6WSZXC4XiUTgbRpO4F07HA5D7ME9QqFQo9HodDpNFejuMEeIwFo/IVbL5/Pw2gYCAXiFA4FAMBgMhUJerzcUCsViMb1ebzabTSaTxWIxmUxQX95qtVqtVhx/qy+lUsnj8UBAVu9OHo1GbTZba2srFLT60pe+ZDQaa93YeoI9wi1mMplefvnlw4cP9/X1zc3N/fSnP4XP4//+7/8eDoePHTvm9/sHBwc7Ozt5PN7t27e/+c1v3jcF2QlijBEMBpmcY5KvWCxqN+n1eo1Go9VqnU6nRqMxGAxwU6PRfNRII3okIpHIYrFYLJaPekCxWIRQDAQCHo/H7/d/8MEHUGh+Y2ODw+HYqjgcDuaIQ3AsxOfzIeqOHz9efT9su8qAMXn08LBH+ET4fL6NjQ2n08l84k6n0zRNwxWpVCp1+/ZtgiB27doF99zXdvYIU6lUNBqFJGM6bUy2MVEnl8th/A3odDqdTgfn0L3T6/UPeEaIbSiK8ng8UF/e7Xavr69vbGysr6/7fD6NRsNUzXU4HDAQZ7fb8RMM2nkwCNnr8YOwUqlUX2+LVmEuzgE+nw99NQg2pt9WHXsajQaXCTcImqb9fn914VwYiPN4PDqdrnr2P0yPxMryqK5hELLXRwVhqVSKxWLxeJw5wgkz06SaWq1mrrpVX4qDzGPuwbWM6GGUy2WPx8NUBGQqPBQKhY6ODgjFjk1Wq7XW7UXooWAQshdJklar9fOf/3z8l2UyGWYiJTOjhJlY3/zLcC4Z2gYkSa6srCwvL8NxeXn5zp07FEXt2rWro6Nj16auri6sC4hYCIOQvUiStNls3/72t9W/DGf6obqQSqXu3LkDoXjnzp2lpaU7d+4UCoXOzk4Ixc7OTjhiTXlUWxiE7FWnyycQeoBYLAaheLuKRqOBUIQVdV1dXXa7HZc/om2DQcheGISoEVQqlY2NjaWlpcXFxcXFRYjJaDTa1dXV1dXV09PDpCNOWEVPCAYhe2EQooaVSqUgGhcWFpaWlhYWFlZXV81mc3d3N0QjHO+q64LQJ4NByF4YhAgxSqXS2trawsICdBzn5+eXlpZEIpHT6YRcBA/YWwChj4JByF4YhAg9mM/ng2icn5+HYyaT6e7u7u3t7e7udjqdPT09ra2tOHcaPRgGIXthECL0qEiSXFhYgFycm5tbXFwMBAIwDQfSsaenZ9euXbiBHKqGQcheGIQIPb5CoXDnzp35+fnV1dW5uTkYU9Xr9W1tbU6ns7e31+l0Dg0N4RKORoZByF4YhAg9CYVCYXl5ubrXePv2bYPBAKOpzBVHnInTODAI2QuDEKHtQdM0zMSpvuIoEolgbiqkY3d39wNqi6K6hkHIXhiET0gulyNJkil+m0wmM5lMKpVKJBKFQiGRSOTz+UwmUyqVkskkQRDJZLJUKsH3kiT5gP8ycrmcz//v0mZQIripqUksFguFQqlUCucKhUIsFkulUpVKJZfL5XK5QqFQKpW4YRDb+Hw+mKE6NzcHSziSySTTX+zq6nI6nW1tbbgT/Q6AQcheGISPKpFIMPVpoYZUddV72JockgxCSKlUKpVKuVwukUggkIRCIRylUimfz4eSUvfG20c14N7IzOVy2WwWkjWbzeZyOYqistlsJpOJx+PJZBLymKKoVCqlUqmYTdJh51imEojRaISiV3q9fhteSXRfFEUx/UVY4+jxeBwOB+QiLP/v6upSqVS1bil6NBiE7IVBeJdyuRwMBqHGrM/nCwQCcBIKhfx+fygU4vF4BoNBr9dDMSlIjuqNyNVqtUqlEovFtX4q90HTNEmS1ZVDmEqQ4XA4GAxCupMkqdPpTCaT0Wg0Go0Wi8VoNFqtVovFYjabsS75NoOZOIuLi8zOOEtLS2KxGLbC6ezshGhsaWnh8Xi1biz6SBiE7NWYQZjNZjc2Nnw+n8fj8Xg8Pp/P7Xb7/X6PxxOJRLRardlsNm0yGo1ms1mn05nNZr1ez86E21pQcT4QCPj9/kAgAB8LvF4vvFbxeNxisdhsNrvdDrXm7XY7FNeVSCS1bnuj8Hg8sJkq5OLS0lIwGGxvb2c2Ge/u7u7s7MTJOOyBQcheOzgI8/m82+32er0bGxtutxvKo29sbHi93nQ6bbPZ4N0cejk2m81kMlmtVqPRiB+rHyyfz8MHiI2NDag1D0eXy6VUKltaWqDQPIcRFeMAACAASURBVFNT12az4WLzbZDL5WBuKqQjnAgEAiYawa5du3A/1ZrAIGSveg/CUqkE/bnqqIMTkiQtFovVaoWOi9VqtdlscKLVamvd8J3J7/dDlfnVTSsrK+FwuLW1FTorTOFAu92O6bgNAoFAdRWOpaWl9fV1o9EIfwUmGltaWphL1OgJwSBkr7oIwlKp5Pf7IeqghwfDdBsbG+FwWK/XOxwOq9UKUWe32+EEL2WxRC6Xg1K61YUDw+Ew80bMlEZSKpW1buzOVyqV1tfX79y5A9EIfw6/32+z2eAvwhQ6ttvtODqyhTAI2Ys9QZjJZJgLdT6fz+v1ut1u6O1FIhGdTudwOCwWi8VisdvtTFfPZDLh/9V6lMlkmD4KXOW6ffu2XC6HRIQNPJ1OJ36a2R6FQmF1dZXJRfi8EgqFHA4HhGJHR0d7e3tHR4fD4cC1HJ8MBiF7bWcQZrNZ/yafz+f3+71eL5x4PJ5SqQTdOJvNZjabLZvgTky7RuB2u2Et3fz8/MLCwtzcHE3TsD8ZHPv7+3Fpx7bJ5/MrKyuQi9CnX15e9vl8Vqu1o6PjO9/5TldXV63bWE8wCNlrC4OwXC6HQqFwOAyLDYLBIKw38Hq9wWDQ5/MVCgVmKibMwoeJKhB7OCyG7hWJRGZnZxcWFmZmZubn52dnZzkczsDAQG9vb39/f39/f29vLyzERNujUCi4XK6VlZXdu3frdLpaN6eeYBCy18MHYTKZDIVCEHXhcJhZVB4IBODOaDSq1Wr1ej0sMzAYDCaTSa/XWywWOMclwOjx+f3+ubm5mZmZ2dnZ6enphYUFg8EAoTgwMDAwMNDR0YHjB4iFMAjZC4Jwbm4OtkeBbIMV1nAMBoORSCQSifB4PIg3WEVuNBphUblerzeZTLCuHOcBom1G0/TKysr09PTMzMz09PT09HQgEIBSDwMDA4ODgwMDAzjYgNgAg5C9SJI0Go2w1RbQ6/XMnlvQw4MtVBphITnaAZLJJITi5OQkBKRerx8cHBwaGoKjw+GodRtRI8IgZC/2zBpF6EmgaXp5eXlqampiYmJqampycjKbzQ4NDQ0PDw8NDQ0NDfX09OASOrQNMAjZC4MQNZpQKDQ5OTkxMQFHt9vtdDpHRkYgHQcGBnCjOPQkYBCyFwYhanCpVArGUScmJiYmJubn51tbW4eHh4eHh0dGRoaHh3GSF9oSGITshUGIULVisTg3NzexaWpqSqfTDW8aGRnBNf7ok8EgZC8MQoQegKbpO3fuQCjeunVrYmJCKBRW9xdbW1tr3UZUHzAI2QuDcPtBzXqKoqB8LkmS6XS6UChQFEXTdCKRKJfLBEFAud17v10qlQqFQoIgRCKRRCIRCAQymQzK/CqVSrFYLJPJlEqlSqVSKpW4om7Lra+vM/3FW7duZTIZSETQ2dmJrzm6LwxC9sIg3Fo0TcM2OrBdKpS6hR12opskEgmklFKphHOJRCISiRQKBY/HY0rVNzU13XfJSiqVKhaLBEFASfpisZhKpQqFQjqdpigqk8mkUqlEIhGPxymKkkgkUCu4ubkZ1nrCMlBm0wOz2YxzQx5HKBRiOou3bt0KBoP9/f1MLvb19WHNIwQwCNkLg/CTqVQqHo9ndXV1bRMU5/N6vc3NzbBpHGwjB6XeYWkm2M49iyER4/F4LBYLhUKRTcw2eF6vVygUWiwWKMcIG5pDuV2HwyGTybatqTtDIpFg5t1MTEzcuXNn165dzFKNoaEhnHrTsDAI2QuD8GEEAgGm0insQby6uqrRaNra2lo3ORwOqHcI45Z1hKIo7ybIcgh1l8slFourC+22t7e3t7fb7XZcePeQ8vn87Owss1Rjenpap9MNVbHb7bVuI9omGITshUF4r/X19YWFhdnZ2cXFxfn5+cXFRT6fX13mG0rSNMKIYjgchkK7a2trK5sCgYDD4WBqukI1QZPJVOvG1gFY3Q+hCKv78/k8bHkDnE5n3X2QQg8Jg5C9MAh9Ph9s4jw/Pz8zM7OwsKBUKqHuT88mjUZT62ayCFTngc4xU1Awn89DBUE4Op3OlpYWDodT68ayXTAYhEScmpqanp5eWVnZtWsX7JIKG6UaDIZatxFtDQxC9mq0IIzH47Ozs7OzszMzM3Nzc7Ozs3w+H6r59Pb29vX19fb24h7Nn0A8Hl9cXJybm4Pj/Px8LBbr6enp7+/v6+uD0hBYSvBj5fP5ubk5CEVY5i8QCKCqBlN2Cmff1CkMQvba2UGYTqdhkBP6fHNzc4lEAkrZQeYNDAxotdpaN3NnSiQS8FEDSiZNTU3BezrUhRgaGuru7sZrjR/L6/XOzMxMTU3BTuLLy8stLS3wwQL+Abe2tmLPuy5gELLXTgrCVCrFdEdAIBDo7u6u7u21tLTUupmNy+PxQEcHJo94PB7Y5BPW4Q0MDDQ1NdW6jWxXLBYXFxdnNs3NzUUikZ6eHshF+EduNptr3Ux0HxiE7FW/Qejz+ZaWluACFYhEIl1dXc5Nvb29ra2tuLqZtWCTT2YR3tLSUmdn5+imwcFBHAN8GNDzhm43dMGLxWJfX5/T6WSOOCjNBhiE7FUXQUhR1J1NS0tLMEGjqanJ6XR2dXV1dXX19PR0d3fj7Iy6VigUpqenb968efPmzRs3biwtLfX09OzZs2fPnj179+7t6enBzzQPKRKJwLSv2dnZ+fn52dlZgiBg8ldvby9MaMJe4/bDIGQvtgVhMBhcXV1dWVlZXV1d3pTNZndtYpYxqNXqWjcWPUG5XG5ycnJ8fHx8fPz69es+n29kZGTfJovFUusG1pNQKDQ3N8csCpqbmysUCjC/t7u7G44tLS1cLrfWLd3JMAjZq1ZBGI1G19fXXZuY/VmkUmlbWxuzdrujo6OjowP3+0cURV2/fv3atWvXrl27fv26UCjcv3//gQMH9u3bNzo6ihcXH1U0Gl1YWFhYWGAWywaDwc7Ozu5N8HFTKpXWuqU7BwYhez3RIMzlcm632+PxuN3ujY0Nt9vtdrvX19fX19eFQqHD4WhpaXE4HK1VcE8v9DBWV1evXr167dq1sbGxubm5/v5+yMVDhw5ZrdZat64uZTIZuOgO6Qjner0exmCYaLTb7XgB4pPBIGSvxw9C2LLS7Xb7/X7Ypsvn87ndbp/Pl0wmrVarxWKx2+12u91qtdpstpaWFrvdLpfLt/BZoEaWzWZv3LgxNjZ2+fLlq1evikSigwcPHjx48NChQ4ODg7hC4xOjaXp9fR3mozHX5mOxGGwq9M1vfrO9vb3WbawnGITs9bFBmMlkQqEQ1E8IbIItmz0eTygUUqlUBoPBZrMZjUar1Qr7TcMJzlVD2295efnKlStXrly5fPny+vr67t27Dx8+fOjQoQMHDigUilq3ru4lk0nYdPfYsWO4r94jwSBkL5IkHQ7Ha6+9xpQmCAQCoVAoHA5D8tE0rdfrzWYzVFEwGo1Qu8dgMFgsFoPBgFsjItYiSRJC8dKlSzdv3mxvbz9y5MjBgwePHDmCI6hom2EQshdJkmaz+cCBAwaDASrVQZk6ODEajTiG+YSUSqVoNEpuSiQS6XQ6n8+TJEkQBNQXvPe7oGYhn8+HsoVyuVypVEqlUrlcrlar1Wo1XmT9KMVi8ebNm1euXLl48eKVK1fEYvGRI0cOHz585MiRnp4evO6FnjQMQvZi2/KJHaZYLLpcrpWVlbW1Na/XC9OFoFpvLBbTaDSqTVCkVyQSwbIQqDh/7w+E+vWlUimZTEJJXoqiUqlUMpmEuoP5fF6j0Wi1Wq1WCx9ljEYjVEa02WxWqxV3UgWLi4uXL1++cOHCpUuXEokEdBMPHz48Ojq6nQUjUePAIGQvDMItVCwWmUIWsNObx+OxWCzt7e1tbW1M2Vuo1qvT6Z5EL6RYLEajURjlDm7yer2BQACm79I0bbfboYCiw+GAtrW3tzfy9TOfz3fx4sVLly5dvHhxdXV19+7dR48ePXz48P79+7GHjbYKBiF7YRA+pqWlpbGxsbGxsZs3b87NzbW0tAwODvb19cEuHq2trWzrXiSTyeoVnLB9wcrKilQq7dwEO9W1tbU14JRLiqIuX74MoTgxMdHb23vo0CHoLOp0ulq3DtUxDEL2wiB8VJVKZW5u7r333nv//fcvX74skUgOHToEy7qHhobqdwGy3+9fWlpiSgwuLCx4vd729nan09nf3+90OgcGBtra2hpq85FcLjc+Pn7x4sXLly9fuXLFZDIxodjW1lbr1qE6g0HIXhiEDykUCp0/f/7cuXPvvPOOQqE4ceLE8ePHjxw5soP3+srn8wsLC7BZJQz5hsPh3t7ewcHBoaEhqBchkUhq3cxtQtP0zMzMhQsXLl++fPHiRYIgDh8+DHNt+vv7cR9U9LEwCNkLg/ABKpXKzZs333jjjbNnz66urn76058+efLkyZMnbTZbrZtWGxRFQW28ycnJiYmJhYWF1tZWpl7E8PBw4+Ti6urqpU1er3f//v2HDh2CsQG8rIjuC4OQvTAI75XNZt95553XX3/97NmzSqXyzJkzzz333MGDBxvwgtmDFYvF+fn5m5tmZ2c7OjqgWMT+/fudTmeD9JOi0SgsVbx8+fLk5GRXV9fhw4cPHDhw+PBhXK2IGBiE7IVByIhEImfPnn399dffeeed3bt3P//888899xxuIvXwisXi1NTU+Pg4bI3t8/lGR0cPbNJoNLVu4HbI5/OwWhEuK4pEItjU5sCBA0NDQ2ybOYW2EwYhe2EQzs/Pv/XWW2+88cb09PRTTz31/PPPnz59urm5udbtqnskSV67du3q1atXr14dGxszm80HDx6E3c46Oztr3bptcufOHXgFrly5srq6Ojw8DJuD79+/H/cnazQYhOzVmEGYTqc/+OCDc+fOnT17lqbpU6dOPf/888ePH8eS6E9IuVyem5uDwcNLly4VCoXDhw8fPXr06NGj/f39DTITNZlMXr9+HT4WjI2NSaXS/fv3Q3nFkZERsVhc6waiJwuDkL0aJwhpmp6cnHz33XfPnTs3Pj6+Z8+eZ5555vTp0319fbVuWsNxu90XLly4ePHihQsXAoHAkSNHjh07dvTo0aGhoQa5rEgQxJ07d6C24rVr12ZnZ7u7u/ft27d37949e/Z0d3c3zuvQODAI2WtnByGs+fvwww8/+OCD999/X6/Xw8zP48eP1++Cvx0mGAxeuHAB/kY+n+/o0aPHjx8/ceJEX19f4+z/mc/nJyYmrl+/Pj4+Pj4+7vP5RkZGdm/q6OiodQPRFsAgZK+dF4SZTAZmK8CEBY1GAx2OEydOmM3mWrcOPUgwGHx/E0VRJ06cOHHixFNPPdXa2lrrpm0riqJu3LgxPj5+48aNGzduJBKJ6jUq7e3tjfMRYSfBIGSvHRCE5XJ5cXERPkpfv359fn5+YGBg//79sI2y0WisdQPRJ7GxsfHee++9++6777zzjlQqfeqpp55++ulPf/rTKpWq1k3bbuFwGBao3Lhx49atWxRFDQ8Pj4yMDA8PDw8P4zhqvcAgZK96DMJcLjc3Nzc1NTUxMXHr1q3p6Wmz2QzL1/bs2TM8PNzU1FTrNqItU6lUZmdn33nnnbfffvvy5cu9vb3PPPPMM888s2/fvsYMgEgkAv/yb926NTEx4fP5+vr6YK+foaGhvr4+HPZnJwxC9mJ/EJbL5dXVVSjpMDMzMzs7u7a21tnZOTAwMDQ0BJ+Ld0ZpoXwxSxAEQVTyxRxBEJUKzeFweFw+nycU8ptwNIwgiHw+f/ny5bfffvv8+fPr6+snTpw4efLks88+28jr1pPJJOz1AxYWFmw2G2yD19/fPzAwYLfba91GRBAYhGzGtiCkKAo2fQaLi4vLy8tms7m3t7e3t7evrw8KO7B/YXKhUFhdXe3u7iYIokyXEplYJp9M5xLZfDKZiSWysXQ2kSmkiqVciS4RlQpBEHwuH/6f8Li8ClEhCA5BVCoVolKh6UqJIDg8Lp/PFfB4Aj6PL+CJBHyhtEmplGhlYpWkSSEXq6RNCpHgfzY5u3XrVjqd7u7u3pFlE4LB4C9+8Ytz5869/fbbBoPh2Wef/cxnPnP48GGhUFjrptVSqVRaXFycmpqanp6GYy6XGxgY6O/vh1zs7e3Fats1gUHIXjUMwnA4DDWAVldXl5eX79y5s7y8nMlkmEpAPT09XV1d3d3ddTfU+cLn/rc7rrndB/o//4VfiSS96VyCz+UTHA5RqZToIk3T8DDIusfEITg8noDH4VYIokyXKkRFJJBIRXK5WL28tH5jbHJmYinojg0NjL7xxhuP/dvYiKbpGzdunDt37uc///nCwsLx48dPnTp16tSpHbwf+iOJRCJTU1MzMzMzMzPT09MLCwt6vb5vU29vb09PT4N/etgeGITstQ1BGA6HNzY21tfXNzY2XC7X2tra2tqay+USCARQFbatra2jo6Ojo2PXrl31u90GXaF90ZVl39RGaCFXyPB4QpoulelSbVvF5wl4XH6xVOQQnGa5Tquy6pRWtUzfLDdU9x13jGg0ev78+bNnz54/f95ms506der06dMNezXxvmiahmsNUFFkbm5udXXV4XBAKPb29jqdzs7OTvYPutQdDEL22qogjEajPp/P7XZ7vV6ohA7H9fV1iURit9uhHnpLS0tLS0tra2tLS8vOuLBXpkvu8O1l39R6aJ7D4RVL+UqFrnWjHoTH5XG5gnK5yOfxlVKtVmnVK606lbVZbuRyds4OL+Vy+dq1a2fPnj179qzX63322Wefe+65kydPNuCk049VLBaXlpbm5uZmZ2cXFhZmZ2c3NjZaW1udTmd3d3dvb293d3c9DsywDQYhez18EIbD4VAo5PP5AoFAIBDw+Xx+v9/r9cJRIpGYzWabzWaxWKxWq81mg6PD4diRpXlWV1e/8Y1vfPH3f3U1Nk7T5UKpQBD1+o9cwBdyCE6ZLqvleoumw9TcalDZxSJZsVh866239uzZU+/rL91u91tvvfXmm29euHBhdHT09OnTZ86caZz9Tj+BQqEAxZnn5+cXFhYWFhbgUn13d7fT6YTLFiMjIxiNjwSDkL0gCIPBYDgcjkQigUAgHA5D5gWDQTj6/f5wOKxQKAwGg8lkMplMRqPRbDYbjUaLxWIymSwWS0PtlOjz+V74zVOf/z8+LVdJi6V8rZuzlTgcDp8rKFdoIV/ULDVdfGdcwmv+q//7b7mcnTC0mM1m33vvPSgwKZFIoMDW4cOHscDWx4LJ2xCKS0tL8/Pz3/3ud/fs2VPrdtUTDEL2IknSaDTSNK3VanU6nV6vNxgMWq1Wr9ebTCa4aTQa9Xo9Xk4HkUjk97/+hWO/MsDh7vx/1TANp1QuqWQ6i6bdqus0N7cK+HW/NXmlUpmYmHjjjTfeeOMNl8t18uTJ559/HgdO0ROFQcheJEm2tLSQJFnrhtQHiqJ+80svnP7iKMHdggmfdYbDEXKFpUpJJdG2GJwW3S6j2sHj1n1fyuv1vvnmm2+88cbFixf37Nlz5syZM2fOtLW11bpdaKfBIGQvtq0jZLNSqXTkyJHf+toRnrDhQvAuXA6XzxOW6JJWYWrRO626jv/nb/9fl2v9u9/9bv3uaZfJZN5+++033njjzTff1Gq1Z86cef755/ft29cgVaLQk4ZByF4YhA/vZz/72be//e0v/a9Pb24BgwiCILgcLo8noOkyp9g0uOtAu7WvWV6vWQhomh4fH4eB02AweOrUqeeee+6ZZ56RyWS1bhqqYxiE7IVB+PA+/elPf/WrX801387kk7VuC0vxuQIOh8Pj8e0GZ7uxz6Lp4PPqezmay+WCRBwbGzt06NCZM2dOnz7tcDhq3S5UfzAI2QuD8CEtLi6eOHHC5XJtROY+mP7PUrlQ6xaxnZAvKtElncLSaR2263vkYnWtW/RYEonEL37xC1iYaDQaT58+ferUqQMHDuCMU/SQMAjZC4PwYUSj0V/91V/91Kc+9dJLLxEEMbHywc0772IWPiQ+T0hUKmKRtNXU12roM6gddb1yn6bp69evnz179q233oIZp6dOnTp58uSO3NAVbSEMQvbCIPxYr7322p/92Z/92q/92t/+7d8yO3Xd9t68On+2VC4WMQ4fGofg8HmCClExa9o6zMMOfVe9b/Pm8/neeuutn//85++9915XV9dnPvOZkydP7tmzB3d0Q/fCIGQvDMIHuHnz5h//8R+nUqlvfetbn/rUp+76apkuzbmujt95m6hUMA4flYAvoumyTmnptI62GvvEwvouoVcsFi9dunTu3Lnz5897PB4oI/z0009jCSTEwCDcepcuXfr2t7+dTqdfeOGFL3/5y/c+IBgMvvTSS8vLy4ODg3/5l3+pUCju+3MwCO9VqVQuXLjwz//8z1euXHn55Ze/+MUvPmACfbFUWAvMLLpvBMkNPo8PpQTRw+PzhJUK3SwzdNl3txr6pE33/4daR3w+3/nz599+++133nmnubn56aefPnHixLFjx9Tq+r5Kih4TBuEWW11dHR4e/od/+IeWlpavfOUrL7300u/8zu/c9Zh9+/b19/e/+OKL//iP/0gQxH/+53/e90dhEFZzuVz/8R//8cMf/lAoFH71q1/94he/+PAz5gulnCs4v+S+EYiv87i8Ml2ueemJ+gKJqJRqu6yjbab+ep9cQxBEpVKZnJx8991333333StXrnR1dZ04ceL48eOHDx/GIvINCINwi/35n/+52+3+yU9+QhDET37yk3/6p3+6detW9QPGxsZOnToVDAYFAkEsFjOZTLdv377vnG8MQoIgVlZWfvazn7322msul+uzn/3siy++uG/fvk/80+hKOUJ5AzHXengpFHcTRIXgEMUSjp0+LD5PUCEIuVjVaRntMA8oJJpat2gLFAqFsbGx999///3337958+bg4ODRo0ePHj166NAhLJPbIDAItxhsjfj7v//7BEGsrq52dnbmcrnqadzf//73/+u//uv8+fNws7+//+WXX/6VX/mVe39UwwZhOp3+8MMPz507d+7cuXQ6febMmc997nPHjh3b8mkOZCociLuCpDtMusl0mCAILpdfKhXoSnlrf9HOw+MJOAQhbVI67ft2WYYloh0SGNlsdmxs7MMPP7xw4cKNGzc6OzsPHTp0+PDhQ4cO1XuhD/QAuM5miwWDQeZ6Q3Nzc7lcDofD1SVtqx8AjwkEAvf9UeVyOZVK7d69myAIhUJx7ty5Hby5NkVRV69evXDhwocffjg9Pb1nz56TJ0+++uqrAwMDHM6T2jVNJdOpZLpu23/v05/KktFkIJrwB+OuaDKQziV4PD6Xwy3T5XK5+ITaUKfgBaHSkfGlX1xfOq9RmHsd+1uNvUJ+fVf/EYvFx48fP378OEEQhULhxo0bly5deuWVV373d39XoVAcPHjwwIEDhw4d6uvrw0WKOwn+LbeYTCbLZv97l69MJkMQxF2jKzKZLJf7n1kbmUzmo4ZfeDyeWCz+wQ9+QBCESCTaYSlYLpcXFxfHx8fHxsauXLnicrlGR0c/9alPfeMb39i/f39NSkfJxCqZWOXQd8PNSoVOZUkyHaHSkWjSH0sGEulorpjl8wRcglOmSyW80EgQJbpIEESI3IgnAxdm/tOi7XDa99l1XVxu3a9SEAqFBw8ePHjw4Ne+9rVKpbK0tHT16tXLly9///vfd7vdIyMjBw4c2Ldv3969e7GzWO8wCLeY3W5fW1uD89XV1ebm5rvmdNjt9ldeeQXOaZp2uVwP2BSKx+ONjo4+udZup2KxODs7Ozk5OTk5OTExMTk5aTabd+/evXfv3i9/+ctDQ0Ns+4jN4XDlkma5pNmm+586sWW6lMjEEplYMhOl0pF4KkSlo+l8ksvh8Hn8CkEUSwWaLhMEUSEaqwgGLFPZCC36o6sVgmgz9vXY95qaWwiCUywWuVxuXS/g43A4UAv+xRdfJAiCoqhr166NjY3967/+61e+8hWRSLR37949e/bs2bNndHQUK0bVHbxGuMVef/31P/mTP7l165ZCofjCF74gl8u/973vEQTx05/+dGBgoL+/P5lMWiyWc+fOHTx48LXXXvvTP/3T1dXV+75H1PU1Qpqm19bW5ubm5ubmZmZmZmdnl5eX29rahoaGhoaGRkZGRkdHlUplrZu5ZbKFVCITS2ZiiUyMTIXJdCSZjecLaS6Xz+PyOUSl0GiXHjlcAU/A4/K7rKPX3lv4+2/842/+5m9++ctf7u7urnXLtt7a2tr169fHx8dv3LgxMTGh1+tHN42MjGAush8G4RajafpLX/rS+fPnNRoNn88/d+4c1L4ZHBz8vd/7va9+9asEQfzkJz/5oz/6o7a2tvX19VdeeeXkyZP3/VF1FISJROLOnTu3b99eXFxcWlpaWlq6ffu2wWDo6enp2+R0OkWiui8b+0gqlUo6RyWz8WQ2nkhH4+lQIhVN5shCMcvjCjhcTqVCF8sFYkf/F+RxeBwOt0kgd89TG4vRf/n+D2rdoieLpunFxcWbmyYnJ/V6/cjIyMjIyPDw8NDQUP0Ww9rBMAifCJ/Pl0wmOzs7mYkehUKBx+MxPb9kMrm+vt7W1iaRfORGVuwMwlAotLa2trq6urLp9u3bqVRq165du3bt6urq6t6E67E+Cl2hU1kymYklsrFEOhZNBpLpaCpPlcpFAU/IIYgSXdp5Kx0FfFGlUmk19Pa1HjSoGmVXF5qmb9++fevWLbgccOvWLZFINDQ0NDg4CMddu3bV9aDxzoBByF61DcJAIOB2uzc2NtbX112b1tbWRCJRa2tre3t7W1tbe3t7e3v7rl27LBZLTRq5w5TKxf8eX83GqFQ4ngpTmWgmR/G4fB6PX6HpQilfIei6vvjIITg8nkAkEPe3HOyy7RYLG66O4MbGxuTk5NTU1NTU1OTkZCAQcDqdg4ODcOlkYGCgubm51m1sOBiE7PWkg7BSqQSDQa/X6/V63W63z+dzu91u8eMB7AAAIABJREFUt9vj8bjdbqVSabfbbTabw+Fo2dTa2vpRG8KhJyedSyQy0UQmRmWi8USAzERSWbJULgr4AoIgSuUyXYfdRz5PUKlUTM1t/a2H/q8/+F8UlXjllVf0en2t27Xdksnk7Ozs1NTU9PT0zMzMzMyMTCbr6+sbGBhgrik0NdX3ohT2wyBkr8cPwlKpFAqF/H5/IBCAzAsGgx6PB46hUKi5udlsNlssFpvNZjabbTabzWazWCx2ux3/77FcqVyA+auJdDSeDMZToUQ2niukuFw+l8OlK3SpXCTq4PIjR8gXEhyuIKd+9vD/rms2ffx37HQulwummMEsszt37lit1oGBAafTCbnY2dm5wxZT1RwGIXt9bBAmk8lQKBQKhcLhcCQS8fv94XA4HA5D7IXD4VgsptfrjUajyWTS6/VWqxWOBoPBZrMZDAaBoL5rlKO7wPScRCaWyESpdDSa9Ccy0XSOKtNlPldQIYhyuUBX6Fo38z54XD6HQxib24bajlq1HXU9/Lu1SqXSnTt3Zmdn5za5XK6Wlpbe3l6n0+l0Ont6erq6uhptJtrWwiBkL5IkHQ7HD37wg+imSCQSiURCoVAkEgmHw3w+X6fTGQwGnU4HJ3BuNBqNRqNOp2vAgSZ0X4VSLpGOUploIhOLp4JkMpTMxvPFLI8n5HF5NF0qlAos6T4KeEIBXzTYdrTbtkckqMG+CuxXKBSWlpYWFhbm5ubm5+cXFhZWV1etViuEYk9Pz/PPP49rNh4JBiF7kSRpNpvPnDmj1Wo1Go1Go9FqtVqtFmJPq9XWZPsVtGPQdDmRjcPVRzIZiqUCVDqWySf4XD6Hw60QdA23I+fzBARBtBh6B9uO6pQ4FetjFIvFlZWV+fn5xcXF+fn5r3/96/39/bVuVD3BIGQvdi6fQDtdJZWlqEw0kY5S6Ug0GUikI6k8ySG4fK6gUqEL5fz2vWlwOHyuQCZWDrd/qsM8zOOya+8htGNgELIXBiFij0w+mUhHqUyETEeiCT+ZDqezFIcguFxBhSgXS092Yo6AJyQ4nD7Hwf7WQzum0gViDwxC9sIgRCyXySfJVJjKRMhUKJLwU+lIOpfgcfk8DrdcKZe2umQHj8snCI5D3z3ScVyrtPzoRz8aGRkZGBjY2t+CGhAGIXthEKK6U6lUUjmSSkeodJRMBcOUn8qEc4WMgCfgcDjFcoGmH3fOKofD4XH5Sqm2GJEqhabTp5/bkpajRoZByF4YhGhnKNMlKh0h0+F4MhRJ+uKJUCoXrxAVPodPP8aUHAFfxOMJhts+1WPfW+91EFFtYRCyFwYh2sGyhRSZCpOpcCwZCFMeKh3Jl7J8nrBSqZRKxQrxsB1HPk9IEJVe+/6h9mNikWxxcZHL5XZ2dn78dyK0CYOQvTAIUUMplYtkOkymwrFUMEJ64ulQOpfgcvlcglOiP2ZMFS4fdlqH/YvZ//MP/2zv3r0vvfTSyMjItjUe1TUMQvbCIEQNrlKhk9l4PBmKpYIRyhtJ+FLZOJR4LJUL907G4XF5HA7Hpu1evhX95t/8w549e1588cWTJ0/irivowTAI2QuDEKF7VJJZkkyFYslgmPJEE/5EJkZwODwuj6bpUrlAEASHw+VyuJbmDvds5v/7yWvT09PPP//8Cy+8cPz4cSwNhu4Lg5C9MAgRehiwioNMh+PJYCThpdKRbD5dISocDnek/bhF3vfqq6++/vrr4+Pje/fuPXny5NNPPz0wMMDlcmvdcMQWGITshUGI0CdDV8qpLJnMxPl8IVMEOJ1Ov/fee+fPn3/vvfcCgcDhw4ePHj165MiR0dFRPh/3rGloGITshUGI0BMSCoUuXrx44cKFCxcurK6u7t2798iRI0ePHt27d69EIql169B2wyBkLwxChLYBRVGXLl26ePHixYsXp6en+/v79+/fv3///gMHDthstlq3Dm0HDEL2wiBEaJtls9nx8fGrV6+OjY2NjY1xudy9e/fu3qTRaGrdQPREYBCyFwbhw8vn85lMJpPJ5PN5giCSyWSpVLr3YXw+Xy6XMydCoRCnEaIHWF9fv3bt2vj4+K1bt27duqVSqXbv3j06Orpnz57R0VGs+bdjYBCyVyMHYalUivyyWCwWi8VIkiRJMh6PUxSVSCRSqVQ6nU4kEiKRSCKRiMXipqYmgiDkcvl9pz+USqVkMkkQRLFYTKVShUIhnU6LxWKxWKxSqSQSiUwmk8vlKpVKoVCoqjQ3Nzc3N6vVaigMyeFg/fSGU6lUlpeXb968eePGjRs3bkxMTBgMBugpjo6OjoyMwGcsVI8wCNlrBwdhLpcLhUI+ny8UCgWDwUAgEA6H/X5/MBiMRCKhUIgkSW0ViJ/m5mYmmdRqtVwul8lkUqlUqVQ+TmOy2Ww2myVJMp1Op1KpZDJJURRFUWQViOF4PB6NRmOxWHNzc3XbDAYDUy3ZZDLp9XqdTocTEXc2mqaXlpYgFG/evDk1NWUymYaHh4eHh4eGhoaGhoxGY63biB4WBiF71W8QlsvlUCjERJ3f7w8EAtU3c7mcTqezWCw6nc5oNBqNRp1OZzAYmETR6XS1fhIfiabpaDQajUahqxoOh0OhUDgchgiHUA+HwxqNhnl2er3ebDbDE4QTNj9B9AmUy+WlpaWJiYnJyUk48ni8gYGB/v7+vr6+gYGB3t5esVhc62ai+8MgZC/WBmG5XIb3er/fXx14cBIOh6PRqFarhXd/vV5vMpmYMNDr9UajUa1W1/pJPHHwgkB/F14ZOIeOL0VRer3earUaDAaLxWI0Gm02m8FgsNlsRqNRq9XWuvnocXm93tnZ2enp6ZmZmdnZ2cXFRbvdPjAwMDg4CEe73V7rNqL/hkHIXrUKwng8HgqFmL4ODFdC7EH+RaNR6LTBMCBEnV6vh+6OTqfT6/W4bceDFQqFYDDo8XhCoZDH4wkEAszR7/en02mTyWSxWKxWq8lkstvtZrPZYrHYbDaTySQQCGrdfPTISqXS4uLi9PT09PT01NTU1NRULpcbHBzs7+/v7++HLqNMJqt1MxsUBiF7bXkQZjIZZkwP8oyZigLJB8RiMXRKtFotDO5B7FUPXWLOPVG5XM7n83m9Xo/H4/P5PB6P1+v1er1utzsYDGo0GpvNBrnInNjtdszI+hIOh6empmY2LSws6PX63k09PT1dXV04AWd7YBCy10MGYTabjcfjMJUjViW6iTmvVCow6wTGLeGEuQlzPbRarVAo3J4niD4BmqYDgYDb7YZcZE42NjaCwaBOp3M4HFarFaLRbrdDWOr1+lo3HH0MmqbX1tZmZmbm5+fn5uYWFxeXlpaam5u7u7udTmdPT09PT09vby+uZXwSMAjZiyRJh8Px4x//mFkzAMe7VCoVtVqtVqub76Gp0tzcjGvmdrZyuez3+9fX191ut8fjcbvdLpcLwjKVSjkcDvumlpYWJiaxE8lalUplY2NjcXERcnFubm5hYUEgEPT29jqdzr6+PqfTidG4JTAI2YskSbPZ/PTTTzMLBuB4F9waEX2sbDbrcrk2Njag7+hyudbX1zc2Nvx+P3QiW1pa7jpiDT928vl80GWcn5+fnZ2dn58XCoW9vb3d3d09PT3d3d3/f3t3HxvJWd8BfHa99r7vzr7N7Ku9Pttn+y7QpNfkLtcEiJpASCBqqjYgclQphaK2qgqq+qJSqUIpVQvpC62IKCINKjoohEKgUI7wktxFoDTJkTaN784+e23v+/vOzL6/94+fPNr45XJ38e3Oer+fP0bPzD67eXbO8dfPzDPPMz8/j2E41wpBqFyKHTUKB0a73Y7H45ubm+vr65SOm5ub1I90OBzT09PBYDAYDFJhenoaPUgFSiQSFy5cuHTp0oULF5aXl5eXl9/5znc+8cQTg27XMEEQKheCEAal0+nE4/GNjQ0KSHmbSCTcbvf09PShQ4emp6flAh4eh6GGIFQuBCEoTavVCofD61tCoRBty+XyzMzMoUOHDh06RIWZmZlgMIiBVzAUEITKhSCEYVEsFkOhUCgUWltbo+3a2losFnO73TM9ZmdnZ2Zm8LQcKA2CULkQhDDUqPu4tra2urpK0UgFq9U6Nzc3OztLWyogHWGAEITKhSCEg6fb7cZisdXV1dXV1cuXL8sFlmUPHz48Nzc3Nzd3+PDhw4cPz8zMYOQq9AeCULkQhDAiut1uNBq9vGV5eXllZSUcDns8nsOHD8/38Pv9g24sHEAIQuVCEMIoa7Va6+vrKysrly5dWllZWVlZuXjxYrlcXlhYoGfm5ufnFxcX5+bm8EQHvEkIQuVCEAJsIwgCJSLNQHbhwoVwODw5OXnkyBF5KrKFhQVMogTXBEGoXAhCgDfUbDYvX75M0ShP0cnzPE0/RlORLS4uYgImuAIEoXIhCAGuQ7vdXl9fp5k5aRKy5eVlt9t90003HT16lLaLi4t4xhFkCELlQhAC7It2ux0KhWhhh//7v/9bWloKhULBYPCmm26S03F2dnZsbGzQLYXBQBAqF4IQ4AZpNpt0KVVOx3g8vrCwIHcZjx49GgwGVSrVoFsK/YAgVC4EIUDfVCoVWs9BTkdBEBYXF9/ylrfIax7h4Y2DCkGoXAhCgAESRXGpx2uvvVar1WgMDg3DOXr0qNfrHXQzYR8gCJULQQigKPl8nkbf0HKAS0tL9XqdEpGWj19YWMBagMMIQahcCEIAhcvlcjQ8lbYXLlwolUp0r5Ge+j9y5EgwGMQwHIVDECoXghBg6AiCQIlIK+VevHgxmUzOzc31TogzPz+P5xoVBUGoXCMYhK1Wq1gsNpvNUqnUbrclSWIYRhCEbrdLBxmGkY/L9a/+8zUajdlspvL4+DiteDAxMUETkdhsNoZhrFarWq1mWVaj0Vgsln39fjCKqtUqPeYvT4izsrLC8/z8/DylIxU8Hs+gWzq6EITKNXRBWCwWS6VSuVwWRbFYLJbL5UqlUigUKpVKpVKRJKlUKtVqNSrU63VRFKvVKh1pNpuiKFJQUUSNjY1RDrEsq1Kp5AyTj28rX43e4Gw0GuVymWGYer1eqVS63a4gCMxW7gqC0Gw2i8WiTqfT6/VWq1Wv1xsMBpZljUaj0Wg0m80sy5rNZrPZbLVaLRaL1Wple+BqGOyl0+lsbGxQNC4vL1OhVqvRDOMLCwuHt6Dj2B8IQuUaVBCWSiWKNEmSBEEo9igUCqVSiSrQq6UtgiCYTCaTyWQ0GikhDAYDlQ0Gg8FgsFqtRqNRr9dbLBaj0ajValmW1ev1Op3OYrFoNBqWZfv8Ta8GRbUgCNVqtVqtFgqFcrlcLpdLpVKhUKDTIoqiJEmiKIqiWCgUBEEQBMFoNNq22O122trtdqfT6XA47Ha7YwumOAGGYQqFwvLystxlXFlZWV1d5ThODsX5+fm5ubmpqSmNRjPoxh40CELlepNBWK/XS6US/Y6Wk6x3l9JL3pUkibLNYDCYzWaTyWS1Wq1Wq3mLxWJhWZbSjrpBVqvVtIWuK4JMkqTClnw+n8/nC4VCbks+n89ms1TW6/Ucx7lcLqfT6XQ6XS4Xz/NU4DiOynq9ftBfCPqt3W6Hw+GVlRXqNdIaVclkMhgMyms3Er/fj2f/3wwEoXJREIZCIbrMWC6X5R5Yb5nSThRFOl4sFuklhmFMJpN8+Y707lJ6ySEnZ5tarR70Vx8toiim0+nslnQ6TbuZTCaZTGYymUwmMz4+7vF4OI7jOM7r9VJY0hGPx+N2u3U63aC/B/RDvV6//HorKyuCIMzOzs7NzdH2wQcfdDgcg27pMEEQKpcgCG6322Aw0PVGutS2s0xpZ7FYevtqJpMJq3sfJKIoyqEYj8czmUwqlUokEul0Oh6Pp1IprVbr9Xo5jvP5fDzP09br9brdbq/Xq8zLzrBfSqXS6urq5cuXafvHf/zHi4uLg27UMEEQKtfQDZaBARIEgXIxFoulUil5m0wm4/F4o9Hw+Xwej8fv97vd7kAg4Ha7/X6/1+v1+XzoTcKIQxAqF4IQ9kulUqFQjEQiyWQyGo0mEoloNBqPx+PxuNFo9Hq9k5OTPp/P6/UGAgGfz+f3+wOBAB4ggVGAIFQuBCH0B11ujUQisVgsHo+Hw+F4PB6NRsPhsEqlCgQCgUCAcnFyctLv9/v9/qmpKYzshwMDQahcCEIYOFEUo9FoJBKJRqPRaHRzc5N2w+GwwWCgaJyampqcnJycnAwEAlNTUx6PByMYYbggCJULQQhKlslkIpFIJBLZ3Nzc3NykdAyHw/l8ngJycnIyGAxObQkEAuPj44NuNcAuEITKhSCEYVSv18Ph8ObmJm03NjYoKROJBMdxU1NT09PTwS3T09N+vx8BCYOFIFQuBCEcJK1WKxaLUTSur69vbGxQIZlMut3u6R2w1B/0DYJQuRCEMAqazWY0Gl1/vVAoJIri9PT0oR0wSAf2HYJQuRCEMMoqlUooFKJQJGtra+vr6zab7dChQzMzMzMzM3KB47hBtxeGGIJQuRCEANt0u91YLEah2Lut1WozMzOzs7MzW2ZnZwOBAOYLhKuBIFQuBCHAVRJFcW3L6uoqFdLpdDAYnH29qakpjM2BbRCEyoUgBHgzarWanIurWxKJhN/vl3ORJqoOBoNYDGuUIQiVC0EIsO8ajcb6+rqcizRRdSwW83q9vdE4Ozt76NAhpOOIQBAqF4IQoD+azebGxoaciyQSibjdbjkdZ2ZmaIt1XQ4eBKFyIQgBBqjVam1ubvZ2HFdXVzc3NzmO601HKmPl5KGGIFQuBCGA0tCq8as9Ll++HAqFnE4njVnt3Vqt1kG3F64KglC5EIQAQ6HT6USjUXlUjrzV6/Xysxzyox145FGBEITKhSAEGGqpVIp6jb3PdTQajZkeNCdAIBDQaDSDbu/oQhAqF4IQ4OARBIFykaYCoEIymQwEAhSKvfPJYWHk/kAQKheCEGBE0EMd8kxy8qxyer1+21Sr09PTgUBgbGxs0E0+UBCEyjUKQVipVOr1OpVbrVaxWOx9tVqt1mq16/tks9nce63JYDDIo95NJhPmFoGhkEqlQj0oLNPptN/vpzU6KBqJy+UadHuHFYJQuQYShJIktdtt2haLxVarVSqVms0mJVa9Xq9UKnJiUduoQrPZLJVK8m6n0xFFkWEYegvDMLVarVqtMgwj12QYRq/X63Q6Kms0GrPZ3NuY3levFTVe3u1NXPklOR0tFsvY2Nj4+LjJZFKpVCzLMgzDsqxarWZZdmxszGKxTExMGI1Go9Go1WpZltXpdHq93maz6fV6g8FgtVqRr9AfjUaDVrDapl6v01qPf//3fz87OzvoZg4T3J4dVhRXFCoUNvS7nnKIkqxQKFAgUXRRNepmlcvlRqNBlSkYaEsdKdrSb3aj0TgxMUGZRGFAwcAwjM1mYxiGVh6XY4zepVaraey4VquldXMoOZjdAm9Q6CQwW/FPJ1OO8EKh0O12BUGQz16hUIhEIo1GQxCEarVarVYFQaAzL0lSsVhUq9Umk4llWXMPlmWtVqvFYqEt7VqtVpvNxrIshS7A1ZuYmDh8+PDhw4e3HZckiRZ6NJlMA2nY8EKPULkEQfD5fCdPnqS+FP3WlhOOkoZChcKGsopyi7o4cp+GqlGMUTXqDFFo0XbbtUS4DvSHiCiKlItEFEVBECRJkiSJyqIoiqJYKBSobHs9u91ut9vlgt1udzgctMWcJgA3AoJQuQRBmJyc/OY3v0l9KYouiiuWZVUq1aAbCPug2+0WXi//eoVCIbdFq9U6HA6Xy+VwOJxOJ22dTifHcc4eGEkBcE0QhMo1CoNl4JoUi8VsNpvJZCgXs9lsLpfLZDLpdDqbzdJuNpulsHQ6nTzP8zzvdDpdLpfH43G5XC6Xy+fz4dIZQC8E4f5bW1v7xCc+EQqFbr/99kcffXTnk0B//ud/vrq6SuVDhw79zd/8za6fgyCE69DpdDKZDOVlMpnMZDKUlMlkkg7G4/F2u81xnMfj4TiO53nKSK/Xy/O82+32eDx0WxdgRCAI91m73Z6fn3/ooYceeuihT37ykwaD4fTp09vqHD9+/O6777755psZhrHZbHffffeuH4UghBukWq2m0+lEIkEBmUwm0+l0PB6n3UQioVarfT4fx3E+n4/nea/X6+lht9sH/Q0A9hOCcJ9997vf/YM/+IP19XWGYeLx+PT0dDgc5nm+t87x48c/+clP3nvvvVf+KAQhDEqpVIrFYqlUKh6PJ5NJ2ia2VCoVj8fj3eLz+TweD20DgYDRaBx08wGuDUYJ7rNXX331tttuo7LX63W73UtLS9uCkGGYxx577PHHH7/55ps/9rGP4e9rUBqTyTQ/Pz8/P7/rq7VaLb4lkUjEYrFXX301Go0mk8lIJKJWq/1+v8/n83q9fr/f6/UGAgHKS7fbjUFeoEAIwmvW6XReeOGFncfn5uZcLlc6naan64jNZkulUttqfuADHwgEAmq1+l//9V9Pnjz585//fNdbMvRI+8zMDMMwZrP5xRdfxHrZoAQ6nY6m+9r1VUmSotFoLBaLx+PRaPTChQvPPPNMLBaLxWL5fN7tdgcCAUrKyclJucDzPAa7wqAgCK9ZvV7/sz/7s53HP/GJT7zrXe8ym835fF4+WC6Xd65J9od/+IdUuP/++2dmZp555plf/dVf3fmBY2NjRqPxhz/8IcMwExMTSEEYChaL5ciRI0eOHNn5UqPRoHSMRCLxeHx9ff3cuXOxWCwSiWSzWZ7nKRr9fn8gEKByIBBwu939/xYwUhCE10yv1587d26vV4PB4I9+9CMqV6vVWCw2NTW1V+Xx8XGe569wF1CtVu/1dzfA0JmYmAgGg8FgcOdLzWYzkUiEw+FIJBKNRkOh0HPPPUdlQRCoEzk5OTk5ORkIBAKBwNTU1OTkJJ4DgX2BwTL7LJ/PT05OPvvss7feeuvnPve5L37xi6+88grDMD/4wQ8qlcqDDz4oSVI6naaZAP/zP//zoYce+t///d+dsyUxGCwDwDAMw9RqtciWzc1NubyxsaHT6ajvSLlI5WAw6Ha71Wr1oBsOQwM9wn1mt9sff/zxe++91+l01mq1b3zjG3T8zJkz2Wz2wQcfLBQKJ06coOuc3W73iSee2DUFAYDodLq5ubm5ubmdL+VyOepEbmxsRCKRl19+ORwOb25u5vN5uvVIuUgFCsvrnsYdDjD0CG+Ier2eTCb9fv+u9/87nU4qlVKpVFe++YEeIcD1qdfrkUgkHA5TLm5uboa32Gw2SkSKxmAwODU1NTU1tfNePowOBKFyIQgB9le3200mk3I0UmFjY2Nzc1OtVlMiytFISbnz2Sc4eBCEyoUgBOibQqGwuYWikZKyVCpti0ba9Xq9uA15YCAIlQtBCDBwlUplY2NjY2ND7kFSUuZyOboN2duJnJqaCgQCeNJp6CAIlQtBCKBYjUaj9x6k3ImMxWIOh4NG6PR2IicnJxWyHjXshCBULgQhwNDpdDrxeFzuO1JYUkxqtVp5IKuckTSrzqBbPeoQhMqFIAQ4SHK5nHzrka61EkmSJntQ95HmDdBqtYNu9UhAECoXghBgFFSrVZooQO4+UiEWi9ntdnk+HepBUkByHDfoVh8oCELlQhACjLJOp0MPe1BGyvMGRCKRcrks9xopKWle1qmpKSyqfB0QhMqFIASAXVWrVQrFaDRK3Ucqb25uGgyG73//+7feeuug2zhMEITKhSAEgGuVzWZNJhNmkrsmmGt05AiCQH/9iKLY6XQYhikWi61Wi2GYWq1WrVapmhzAzWazVCpRudFolMtl+aN6Q7rVahWLxd7/0LbKsk6nI4ridbd/YmJi1zXQWZbtXfR126qQVDAajfSMl8FgoGEIZrNZo9GMjY1ZLBZ5l17V6XR6vf662wkwEE6nc9BNGD4IQkVrtVpf+MIX5IypVCr1ep3ZyjD5uBxg5XK50WgwDCNJUrvdZnpiTw4tOTCsVitNjWEymcbHxxmG0Wq18g0Gudr4+Li82M22EOrNHo1Gs2328L0SS6VSsSx73edkr3yVvymRv2+325XL0WiUzo98JumPAPlM0nmj01itVmu1Gp0TvV6v0+koR61W6/j4uMVioaS0WCxardZsNtOf4RaLxWQy6fV6s9lstVqNRqPRaKSUBQBlQhAqWrfbPX/+vEajoUdx9Xo9dW6CwaBarZaPywEm93gsFgvN9y2nXW8PCa4e/ZFBwVkqlZrNpiAIrVZLkiRKSkmSarVaoVAIh8O1Wq1YLBaLxWq1WiqVBEGoVCqlUqlYLFJAmkwms9lss9nMZrPZbLZYLJSXLMtaLBar1Upb+cigvz3ASMA9QuXCPcKDRBTFUqlEoSgIgiRJFJmSJEmSVCgUJEkSRZG2oigKglAul1mWZVnWZrOxW2w72O122vZeGQaAq4ceIUA/UD/vmt7SbreFLYVCQS4UCoVIJEKFfD4vb+12u91udzgccqGXy+WiAobXA2yDIARQqLGxMYquq6nc7Xbz+Xw+n8/lcr3bCxcu5HK5TCaT28IwjNPpdDgcPM87HA7nFp7nqeByuZxOJ/qXMDpwaVS5cGkUboRyuUzRmMlkstlsLpfLZrPpdDqdTmez2Ww2m8lkBEGQE9HtdrtcLpfLxXEcz/NU9ng8mEIaDgwEoXIhCGFQWq0WJWI6nU6lUhSZyWQynU7LB1utFsdxHo+H4zi5wPO82+2mXaz5DsMCQahcCEJQsmq1mslkEokE9SapkEqlEokEHa/X6xzHeb1eykW3283zPO36fD6e5zGjNCgEglC5EIQw1Gq1WjqdjsVimUwmHo+nUqlkMkl5GYvFUqmU0Wh0u91ut9vr9fI87/P55Iz0+Xx4egT6BkGoXAhCONjy+XwymUwmk/F4nLbpdDoajaZSqVgs1m63fT6f2+3u3Xq9Xo/Hg5iE/YUgVC4EIYyySqUih2IymezdRqPRdrsdCAR4ng8EAm632+/3U1hSTGJuPLijGm0cAAAUkElEQVQmCELlQhAC7KVcLkcikVQqFY1GE4lELBbr3er1eq/XS7kYCAQ8Ho/f76eMdLvdNNcSgAxBqFwIQoDrk8/n4/E45WIkEqFOJB3J5XIul4tyMRAIUF5SZE5OTu46Oy4ceAhC5UIQAuy7VquVSqUikQhlZDwej8fj1K2MRCJjY2N+v9/r9Xq9XirIYcnzPLqSBxWCULkQhAB9JopiLBaLxWKUjrSl3Vwux3Hc5OQkXWj1+XwUk7SLu5JDDUGoXAhCAOVoNpvJZJI6kbFYTO5TJhKJaDRqMBjkXJQ7kXQBluO4Qbcd3gCCULkQhADDIpfLJRKJcDhMuUidSIpJSZJ6c5H6lHRj0uv1YlYBJUAQKheCEOAAqNVqdCey98YkXYBNJBJWq5UurvYO26FnQtCV7BsEoXIhCAEOPJqUju5HysN2aCtJktx3lJ8AoScmA4EAltPaRwhC5UIQAoyyer1OfUc5I+kmJT0NotFo5IcjaZgrPSVJ9yk1Giyxdw0QhMqFIASAvdAAV8pIuspKSRmNRr/2ta/dfvvtg27gMEEQKheCEACgD/B8KAAAjDQEIQAAjDTcUFW0brcbCoWoIAiCfFwQBPmadrVardVqVG6325IkydWazWapVJJ36/V6pVLp/XxJktrtdu+R3k/rVSqVms3mlVu713v3otfrdTrdFSqMjY3tXG3HZDKNj4/vujsxMSHPFWkwGOgJLY1GYzabez9NrkbvlY9v+2QAGBG4R6hcgiB4PB6v18swjEqlYllWfollWZVKReXeOFGr1VarVa42Pj5uMpnkXa1Wu23ItcViGRsb6z2yVzhdTUi8YbBt84bBuS3XybZI7t1tNBrlcpnK5XK50WgwDNNqtYrFYu+nydWKxWKr1ZIr0K5Op9Pr9XTqKCPprNKWjlMdOicsy46Pj5vNZopelmW1Wq3RaLRYLDqdrvf8A4AyIQiVC4NlBoLimcKSMpISlLbUyaY6lMGFQoEOViqVer1eKBSo5y2KYr1eL5VKZrOZUtNqter1eoPBYLPZjEaj0Wg0mUwsy5q2sCxr7tH7pw8A3Di4NArwOnq9fn8nUC4Wi5VKpVwui6JYqVQqlYogCOVyuVQqlcvlQqEQi8WKxWKpVBJFUZKk4hZRFC2vZ7VabTYbFWQsy9KW7GPLAUYEghDgxqLu3fW9l6JRJoqiIAiiKIqimEqlqEBHBEGggs1mo0Skgu317HZ7b0G+wA4wyhCEAMpFfb6rr0+DqgqFQu+WRCKRfD5PZblg7+FwOLaVHQ6Hw+FwOp3X1AaAoYN7hMqFe4RwQ3W73fyWXC63s5zL5TKZTD6fr1QqjtdzuVxOp9PpdFJSOhwOjuOQlzCkEITKhSAEhWg2m7ke2Ww2k8lks9ne3UwmU6vVnFs4jpPD0ul08jxPBZfLtW2gMsDAIQiVC0EIw6Ver8u5mE6ns1vS6TQlJe1SJ5JC0e12U17yPC9np8vlws1L6CcEoXIhCOHg6XQ6cocynU6nUinaTSaT8kFBEFwul8vl4nme53mXy8VxHEUmx3Eej8flcl3TE6sAV4bBMgDQP2q1muO4Ky8522w2qQeZTCapN5lKpZaXl6mQSqUymczExITX66WwpGjkeZ7CkgryHEMAbwg9QuVCjxBgL4IgUCLSwrZUoG4lHVGpVB6PhzqUHo+H0tfr9XIcR9mJhW1BhiBULgQhwHUrl8uJRILCMpFIpNPpdDodj8fpeiwlpdfrpXuT1Ln0eDzUp/T5fLj6OlIQhMqFIAS4cUqlEiUl5WI6nU4mk3QxlvJSr9dTV5L6kW63u3eX4zgMfz0wEITKhSAEGCBBECggKReTyWTvLg1/pcE7NKiHYpJ23W63w+EY9DeAq4UgVC4EIYBidTqdnZdbaZd6mcVikXLR7XbLMUkXY2kXw3mUA0GoXAhCgOHVaDR6c3FbTCYSCYZh5ME7vTcp5auvtKAm9AGCULkQhAAHWLlcplyUu5XyPct4PJ7JZAwGQ28uyg+K0NVXjuOwjvR+QRAqF4IQYJTl8/nemOwd1EPHrVarHJBUoOC84447LBbLoJs/TPBAPQCAEtFKIIuLi3tVoKnsqCtJSXnp0qVMJuP3+9/61rf2s6nDDj1C5UKPEACgD9SDbgAAAMAgIQgBAGCkIQgBAGCkYbDMQVAqlZrN5s7j7XZbkqTrfvubND4+bjKZ9npVpVKxLLvzuMViwcxVANBPCEJFq9Vqdrtd3t0r2Ewm065PFI2NjV3NKOq93v4mNZvNUqm016vdblcQhJ3HJUlqt9vy7sTERO8EHL1N1Wq18gICBoOBnj7uzVc5U81ms0ajYRjGarWq1Wr5tNC71Gq11WqVP5w+lursldYAcJAgCBVNq9Wura3Ju1cZbAdJo9Eol8vybm/ntV6vVyoVKlcqlXq9zrw+X+VMLRaLrVaLYRhRFDudTqvVunz5svyuTqcjiqJcrVarVavVVqtVLBbll2w2G8MwLMtSNKpUKpvNRv8cFNV6vV6n01GU2mw26g2bTKaJiQmWZXU6nV6vt1qtOp0OE2sBKA0en1AuPD6hHPSvsG1LHXTKY8rUYrHYbDYFQaD8LpVK9XpdFMVqtVqr1QRBqNVqlUrFYrHo9Xqj0Wi1WvV6vcFgsNlsVLBarWaz2Wg0Go1GlmVNJpPRaDSZTFQ2mUxYRQ9g36FHCPDGqEdI2zePorFSqQiCUK1Wq9VqoVCgNJUkqVgsZrPZcrksCEKxWKRAFUWxWCyWSqVGo2GxWCgXzWaz2Wy2WCw2m81isVCZsCxrtVqtVqvFYqG43ZeWAxxICEKAfqOIur730jVbykgiSZIgCJIkSZK0sbFBBVEUBUEQRZHKnU7HusVms1FMsnu7wigngIMHQQgwTDQajc1mu9a+KV2hJYIgFAoFKgiCcOnSJeH1CoVCs9mkvJS3NpvNbrfvWsBdTxh2uEeoXLhHCIPSaDQKhQKFIhXy+XxhC5XlbafToVDclcPhcDgcVDabzYP+ZgC7QI8QALabmJig9WOvpnKtVsvn83IuyqLRaC6Xy+VytJvL5ZrNZm80UsHpdDp2wLOk0E/oESoXeoRwwNTrdcpFeZvJZHJb6AixWq0UkHJMOp1Ol8vVu4u8hP2CIFQuBCGMrFwul81m5VzMZrPZbFZOTXopm83a7XY5LwnHcdt2R+3RW7gOCELlQhACXEG325UTkbbpdJoik3Zpub5Go0Gh6HK5OI6Tg1PeJTT3EIwm/NsDwFBSqVQul8vlcl25Wr1ep3RMp9OZTIbKS0tLlJryEZvNRpded2ak2+2mgk6n689Xgz5Dj1C50CME6A/qXMrkyMxkMtStpF2tVstxnJyRcl5SgvI873K5MPXPMEIQKheCEEBRRFFMpVK9eSlfjJXLKpVKDkXKS7lM/Vee5zFfgdIgCJULQQgwdMrlciaTobykfmQqlZIvwFK53W5TLvI8L3cu5TKN8dmv+fzgaiAIlQtBCHAgVatV+YorZWRvmfKyWq32XnTtzcjee5lqNRZX3wcIQuVCEAKMrF3H+Mh9TXlw7LZnRSgj3/e+97nd7kF/g2GCUaMAAIqj1Wp9Pp/P57tCnU6nI4cidTGz2WwoFLrCgtiwKwQhAMBQUqvVNIp10A0Zeri+rFztdrtWqw26FUpRq9Uee+yxQbdCKSRJ+qd/+qdBt0Ipstns5z//+UG3Qini8fiTTz456FYMGQThPovFYp/5zGfe//73P/TQQ3vVWVtbe/DBB48cOXLq1KlkMrlXNVrf/MY0c/hkMhn86pdFo9F/+Zd/GXQrlGJtbe1LX/rSoFuhFBcvXjx9+vSgWzFkEIT7LBQKrayscBx37ty5XSt0u90HHnjgyJEj3/3udw0Gw6lTp/rcQgAA6IV7hPvszjvvvPPOO8+ePfv1r3991wrPPfdcLpd79NFH1Wr13/3d37lcruXl5fn5+T63EwAACHqE/fbaa6/dcsst9PSP2Wyen59/7bXXBt0oAIDRhR7hNctkMq+88srO429729uuZk7eTCbDsqy8a7PZ0un0rjU1Gk23252YmGAYRqVS+Xw+lUp1va0eeu12O5lMzszMDLohitBsNtPpNM4GaTQa2WwWZ4PUajWtVjvoVgwZBOE1W19f/+xnP7vz+C233HI1QWi1WsvlsrxbLBb3mkvJ5/M9//zz7XabYRiDweBwOK63yQdEvV7H/+EynI1eOBu9rFbroJswZBCE1+y222773ve+d91vn56e/sIXvkDlVqsVCoWmp6f3qnzHHXdc938IAACuBu4R7rN2u10oFIrFYqfTKRQKkiTR8X/8x3/87//+b4Zh7rvvvlwuR1H65JNP8jx/2223DbLFAACjDT3CfRYKhY4fP07lmZmZo0ePPv/88wzD/Md//AfLssePH9fpdF/+8pc/9KEPqdXqiYmJf//3fx/lO38AAAOHSbcHo91uS5LEsixSEABgsBCEAAAw0nBpVIlisdj58+eTyeS73/3uQCCwa51z5859+9vfdjgcH/rQhw72kivdbvcrX/nK+fPnZ2ZmPvzhD+8cHPj8889fvHiRyiqV6iMf+Ujf23hjffvb3z579qzP5/ud3/kds9m8s8LS0tLp06fVavWpU6cWFhb638J+euaZZ86cOcPz/Ic//OGdQ6mXlpZ++tOfyru/8Ru/cVBXuO12u2tra+fPnxdF8dSpUwaDYdc6Tz311AsvvDA1NfWRj3xk1zrAYLCMMh07duyxxx77+Mc/vrS0tGuFp59++td+7dcCgcDm5ubx48flITkH0p/+6Z/+7d/+7dzc3NNPP/3rv/7rOyucPn369OnToS39b+EN9Q//8A8f//jHZ2Zmfvazn/3Kr/xKp9PZVmFpaenkyZM6nU6j0Zw4cWJ5eXkg7eyPf/u3f3vkkUemp6eXlpZ++Zd/eedkvM8+++xnP/tZ+Yeh2WwOpJ19sLq6euLEic9//vMf/ehH9/oN8Oijj/7lX/7l7OzsM888c//99/e5hcOkC8rTbre73e7U1NT3v//9XSvcdtttX/ziF6n89re//XOf+1z/GtdfhULBaDRevHix2+2Wy2WLxfI///M/2+p89KMf/dSnPjWI1t1wjUbD4/H85Cc/6Xa7zWYzGAyeOXNmW53f/u3f/tjHPkbl3//93//d3/3dfreyXzqdzsLCwlNPPUXlm2+++fTp09vq/PM///MHPvCBQbSu3+i3RD6fZxgmkUjsrFAul20220svvdTtduv1usvl+ulPf9rvVg4J9AiViCZg20utVnvxxRfvvvtu2r3nnnvOnj3bl3YNwMsvv2y32+lyn8FgOHny5K6zmb/88suf/vSnv/71rx+w9TpWVlby+fzb3vY2hmE0Gs1dd92189/67Nmz99xzD5UP9g9DOp2+dOkSfVmVSnX33Xfv+mVDodCnP/3pL33pS4VCoe9t7J8r/5ZgGObVV19VqVS/9Eu/xDDMxMTE29/+9gP8s/EmIQiHTyKRYBhGXo2T5/l4PD7QFt1AyWTS5XLJu7t+Wb/f73a7BUH4zGc+c+zYsWKx2N823kDJZNLhcIyNjdHurl8/kUjIp4jjOPrxOJASiYRWq5WnTdn1bNhstoWFBUmSvvrVry4sLKyurva9mUpxNf/vAEEQDobL5dLs8KlPfepq3js+Ps4wTKvVot1msznsk0stLi7uPBt/9Ed/xDCMRqOhSebIrl/2L/7iLx5//PG//uu/fuGFF7RarTxxzwGg0Wjkf2hmj6/fW6fVatHktAcS/TB0twa673o2Hn744SeffPKv/uqvfvCDH9xzzz1X+f/UgXQ1PzxAMGp0MDKZzHW/l+f5sbGxWCxGFwxjsZjH49m/pg2APOZzJ6/XG4/Hu90uPXAZi8XoOuGuxsbGTpw4cZDGy3i93nw+X61W9Xo9wzCxWGznil0+n0/+Sz8Wi3m93n63sl98Pl+r1UqlUjRM+g1/8k+ePPm1r32tX61THK/Xm0qlWq2WRqNhGCYWi911112DbpRCoUc4NCKRyPnz5xmGGR8fv/fee7/xjW8wDNNsNp9++ukHHnhg0K27UU6cOKFSqZ577jmGYWKx2IsvvnjfffcxDJNMJmnKOoZhqtUqFcrl8o9//OOjR48OqLH7b3Z2dm5u7lvf+hbDMIIg/PCHP6R/63w+L98rfeCBB5566ikqP/XUU+9973sH1dobzWaz3XHHHfRlq9Xq9773PTobxWKRxhMxPT8MnU7nv/7rv2666aYBNnggLly4sLKywjDML/zCLzgcjjNnzjAMk8lkzp49e4B/Nt6sAQ/Wgd385m/+5rFjxyYmJubm5o4dO3bp0qVut/vYY4/dfvvtVOHll192OBwPP/zw8ePH3/GOdzQajYG298Z64oknOI77rd/6rUOHDv3Jn/wJHXzyyScPHz5MZY/H8573vOfhhx/2+/3vfOc76/X64Bq7/77zne84nc5HHnnkyJEjH/zgB+ngmTNnzGYzlePxeDAYfM973nPffffNzs6mUqnBNfaGe+655xwOxwc/+MFbbrnl/vvv73Q63W73pZdeYhiG/i+4884777nnnlOnTi0uLh49ejSZTA66yTfQiRMnbr75ZoZh3vrWtx47dozOxqlTp+SRw1/96lddLtcjjzwyNzf3e7/3ewNtrKJhZhklunTpUu9STYuLiwaDIZlMFgqFxcVFOphOp5999lm73X7XXXfRpY8D7NKlS6+88srMzIw8QXk2m00kEm95y1sYhgmHw6+88kqtVpubm/vFX/zFgbb0htjc3PzZz37m9/vvuOMOukQsSdLly5ePHTtGFUql0o9+9CMaSGk0Ggfa2BsuHo+fO3eO47h3vOMdNHKyUqm89tprt956q0qlymQyL730kiiKk5OTJ06ckMcZHUg///nPe3+B089DKBQaGxubmpqig6urqy+99FIwGLz99tsH08phgCAEAICRhnuEAAAw0hCEAAAw0hCEAAAw0hCEAAAw0hCEAAAw0hCEAAAw0hCEAAAw0hCEAAAw0hCEAAAw0hCEAAAw0hCEAAAw0v4fzBZG6fuhXD8AAAAASUVORK5CYII=", + "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" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] }, - "execution_count": 19, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "ps = streamlines(r,θ,sys)\n", - "plot!(ps,b,legend=false,markerstrokewidth=0,color=cgrad(:RdBu,rev=true),clim=(-0.025/(2π),0.025/(2π)),markersize=3,xlim=(-1,1),ylim=(-1,1))" + "ps = streamlines(xg,yg,ζg,(b,fs_circle,ambient_ω_ζ),xlim=(-1,1),ylim=(-1,1))\n", + "plot!(ps,b)" ] }, { @@ -638,15 +1922,15 @@ "lastKernelId": null }, "kernelspec": { - "display_name": "Julia 1.8.2", + "display_name": "Julia 1.9.2", "language": "julia", - "name": "julia-1.8" + "name": "julia-1.9" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.8.2" + "version": "1.9.2" } }, "nbformat": 4, From 3ea66e58a12590c30048e79cf09a343f6894fce8 Mon Sep 17 00:00:00 2001 From: Jeff Eldredge Date: Tue, 29 Aug 2023 15:34:01 -0700 Subject: [PATCH 11/11] Updated notebooks and removed PyPlot dep --- Project.toml | 5 ++--- binder/notebooks/Moving bodies.ipynb | 4 ++-- binder/notebooks/Pitching Plate - K07.ipynb | 6 +++--- binder/notebooks/Point Source Demo.ipynb | 6 +++--- "binder/notebooks/Translating Plate - 20\302\260.ipynb" | 6 +++--- "binder/notebooks/Translating Plate - 60\302\260.ipynb" | 4 ++-- binder/notebooks/Vortex Sheet Roll-up.ipynb | 4 ++-- src/plot_recipes.jl | 6 +++--- 8 files changed, 20 insertions(+), 21 deletions(-) diff --git a/Project.toml b/Project.toml index 7429ff5..3c85938 100644 --- a/Project.toml +++ b/Project.toml @@ -30,7 +30,7 @@ ForwardDiff = "<0.10.20" Interpolations = "0.12.10, 0.13, 0.14" MacroTools = "0.5.6" MappedArrays = "0.3.0" -PlotUtils = "1.0" +PlotUtils = "1.0, 1.1, 1.2, 1.3" RecipesBase = "1.0" Reexport = "0.2.0, 1" SchwarzChristoffel = "0.1.13" @@ -39,9 +39,8 @@ julia = "1.6" [extras] NBInclude = "0db19996-df87-5ea3-a455-e3a50d440464" Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" -PyPlot = "d330b81b-6aea-500a-939a-2ce795aea3ee" Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" [targets] -test = ["Test", "NBInclude", "Plots", "PyPlot", "Statistics"] +test = ["Test", "NBInclude", "Plots", "Statistics"] diff --git a/binder/notebooks/Moving bodies.ipynb b/binder/notebooks/Moving bodies.ipynb index 361f73c..e0fd708 100644 --- a/binder/notebooks/Moving bodies.ipynb +++ b/binder/notebooks/Moving bodies.ipynb @@ -2080,9 +2080,9 @@ "lastKernelId": null }, "kernelspec": { - "display_name": "Julia 1.8.2", + "display_name": "Julia 1.9.2", "language": "julia", - "name": "julia-1.8" + "name": "julia-1.9" }, "language_info": { "file_extension": ".jl", diff --git a/binder/notebooks/Pitching Plate - K07.ipynb b/binder/notebooks/Pitching Plate - K07.ipynb index b871f03..65f16b8 100644 --- a/binder/notebooks/Pitching Plate - K07.ipynb +++ b/binder/notebooks/Pitching Plate - K07.ipynb @@ -4407,15 +4407,15 @@ "lastKernelId": null }, "kernelspec": { - "display_name": "Julia 1.4.2", + "display_name": "Julia 1.9.2", "language": "julia", - "name": "julia-1.4" + "name": "julia-1.9" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.4.2" + "version": "1.9.2" } }, "nbformat": 4, diff --git a/binder/notebooks/Point Source Demo.ipynb b/binder/notebooks/Point Source Demo.ipynb index 84003a0..039138e 100644 --- a/binder/notebooks/Point Source Demo.ipynb +++ b/binder/notebooks/Point Source Demo.ipynb @@ -60667,15 +60667,15 @@ "lastKernelId": null }, "kernelspec": { - "display_name": "Julia 1.4.2", + "display_name": "Julia 1.9.2", "language": "julia", - "name": "julia-1.4" + "name": "julia-1.9" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.4.2" + "version": "1.9.2" } }, "nbformat": 4, diff --git "a/binder/notebooks/Translating Plate - 20\302\260.ipynb" "b/binder/notebooks/Translating Plate - 20\302\260.ipynb" index 58dc455..9fc8abd 100644 --- "a/binder/notebooks/Translating Plate - 20\302\260.ipynb" +++ "b/binder/notebooks/Translating Plate - 20\302\260.ipynb" @@ -14447,15 +14447,15 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.4.2", + "display_name": "Julia 1.9.2", "language": "julia", - "name": "julia-1.4" + "name": "julia-1.9" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.4.2" + "version": "1.9.2" } }, "nbformat": 4, diff --git "a/binder/notebooks/Translating Plate - 60\302\260.ipynb" "b/binder/notebooks/Translating Plate - 60\302\260.ipynb" index 412e687..5cb6733 100644 --- "a/binder/notebooks/Translating Plate - 60\302\260.ipynb" +++ "b/binder/notebooks/Translating Plate - 60\302\260.ipynb" @@ -8456,9 +8456,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.4.2", + "display_name": "Julia 1.9.2", "language": "julia", - "name": "julia-1.4" + "name": "julia-1.9" }, "language_info": { "file_extension": ".jl", diff --git a/binder/notebooks/Vortex Sheet Roll-up.ipynb b/binder/notebooks/Vortex Sheet Roll-up.ipynb index e05eeed..0391edc 100644 --- a/binder/notebooks/Vortex Sheet Roll-up.ipynb +++ b/binder/notebooks/Vortex Sheet Roll-up.ipynb @@ -14568,9 +14568,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.4.2", + "display_name": "Julia 1.9.2", "language": "julia", - "name": "julia-1.4" + "name": "julia-1.9" }, "language_info": { "file_extension": ".jl", diff --git a/src/plot_recipes.jl b/src/plot_recipes.jl index ab9b464..9c64e98 100644 --- a/src/plot_recipes.jl +++ b/src/plot_recipes.jl @@ -2,9 +2,9 @@ using RecipesBase using ColorTypes import PlotUtils: cgrad -const mygreen = RGBA{Float64}(151/255,180/255,118/255,1) -const mygreen2 = RGBA{Float64}(113/255,161/255,103/255,1) -const myblue = RGBA{Float64}(74/255,144/255,226/255,1) +const mygreen = RGBA(151/255,180/255,118/255,1) +const mygreen2 = RGBA(113/255,161/255,103/255,1) +const myblue = RGBA(74/255,144/255,226/255,1) @userplot Streamlines