The whole program is done using Julia language in Jupyter notebook need help in debugging my code
Question:
{
"cells": [
{
"cell_type": "markdown",
"id": "75aa83c9",
"metadata": {},
"source": [
" "
]
},
{
"cell_type": "markdown",
"id": "8dc42be7",
"metadata": {},
"source": [
"# Assignment 5 ",
" ",
" ",
"## A.5.1. Problem description ",
" ",
"We seek the capacitance per unit length of a circular conducting wire placed over the middle of a conducting strip. The wire radius is $a$, and the center of the wire is located at a height $H$ over the strip. The strip has width $w$ and thickness $b$. The geometry is assumed to be two-dimensional and the structure is located in free space. For the computation of the capacitance per unit, it is therefore appropiate to use the method of moments. ",
" ",
" ",
"For a capacitor where two plates have different shape, the two plates must have opposite total charges. However, they will not in general have opposite potentials. Since Poissons equation is linear, the charges and potentials must satisfy the linear relation ",
" ",
"$$ ",
"q_1 = C_{11}V_1 + C_{12}V_2 ",
"$$ ",
" ",
"$$ ",
"q_2 = C_{21}V_1 + C_{22}V_2 ",
"$$ ",
" ",
"where $q_i$ are the charges on the plates and $V_i$ their potentials. The matrix elements $C_{ij}$ of the capacitance matrix are referred to as capacitance coefficients. Note that the capacitance coefficients in themselves are not physically very relevant and they depend on how the normalizing distance is chosen in the expression for the potential from a line charge. The coefficients can be computed by considering two cases where $V_1$ and $V_2$ take linearly independent values, e.g., ",
" ",
"1. $V_1 = 1$ and $V_2 = 0$ yield the values for $C_{11}$ and $C_{21}$. ",
"2. $V_1 = 0$ and $V_2 = 1$ yield the values for $C_{11}$ and $C_{22}$. ",
" ",
"To define the capacitance, we require that the net charge is zero. This implies that $q_1 = -q_2 = q$. Then the capacitance is defined as ",
" ",
"$$ ",
"C = \\frac{q}{V_1-V_2} ",
"$$ ",
" ",
"# Assignments ",
" ",
"**Q1:** First express the net capacitance $C$ **analytically** in terms of the capacitance coefficients $C_{11}$, $C_{12}$, $C_{21}$ and $C_{22}$."
]
},
{
"cell_type": "markdown",
"id": "e93472d7-6595-4c9f-aee7-4c5648260cf1",
"metadata": {},
"source": [
"**A1:** *Place your answer in this markdown cell.*"
]
},
{
"cell_type": "markdown",
"id": "7f68aa48",
"metadata": {},
"source": [
"## Implementation ",
" ",
"The following function can be reused to obtain the charge $q$ and charge density $\\sigma$ per element. The function MoM2D was provided in the class and is based on the MATLAB function 2DMoM.m described in Sect. 7.2.2 of our textbook."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0c30251d",
"metadata": {},
"outputs": [],
"source": [
"const = 8.8541878128 ",
"function MoM2D(xs, ys, xe, ye, ) ",
" ",
" xobs = 0.5.*(xs + xe) # Observation points ",
" yobs = 0.5.*(ys + ye) ",
" h = sqrt.((xe-xs).^2 + (ye - ys).^2) # Length of elements ",
" A = zeros(Float64, length(xs),length(xs))#Matriz para integral ",
" ",
" #Loop over elements ",
" for k in eachindex(xs) ",
" s = ( (xobs .- xs[k])*(xe[k] .- xs[k]) ",
" + (yobs .- ys[k])*(ye[k] .- ys[k]))./h[k]^2; ",
" ",
" d = real(sqrt.(convert.(Complex{Float64}, (xobs .- xs[k]).^2 + (yobs .- ys[k]).^2 - s.^2 .* h[k]^2 .+ 1e-24))) ",
" # 1e-24 is a simple hack to avoid dealing with e/d blowing up to infinity for d=0 ",
" # note that d.*atan.(e./d) = 0 for d = 0 (analytically) ",
" # same is true for x*ln (x^2 + d^2) ",
" ",
" s = -s.*h[k] ",
" e = (1 .- s).*h[k] ",
" ",
" temp = 0.5*e.*log.(e.^2 + d.^2) - e + d.*atan.(e./d) - ",
" (0.5*s.*log.(s.^2 + d.^2) - s + d.*atan.(s./d)) ",
" A[:, k] = -temp[:]/(2**) ",
" end ",
" = (A\\) # Charge density ",
" q = h.* # Charge per element ",
" return q, ",
"end"
]
},
{
"cell_type": "markdown",
"id": "6e8388f9-2f5e-4892-921d-f0240b78420d",
"metadata": {},
"source": [
"The following struct can be used to save all the mesh information."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fe4411c4-9325-4ac6-8986-c04827e0e493",
"metadata": {},
"outputs": [],
"source": [
"using StaticArrays ",
"using Plots ",
" ",
"struct Mesh{I
" vertices::Vector{SVector{2, F}} ",
" segments::Vector{SVector{2, I}} ",
"end ",
" ",
"function numvertices() ",
" return length(.vertices) ",
"end ",
" ",
"function getvertices() ",
" return .vertices ",
"end ",
" ",
"function getsegments() ",
" return .segments ",
"end ",
" ",
"function numsegments() ",
" return length(.segments) ",
"end"
]
},
{
"cell_type": "markdown",
"id": "7e0f2b14-a98e-4652-96f6-936fd0ba6a0a",
"metadata": {},
"source": [
"**Q2:** Write a function that meshes a circle centered at the origin with segment length $h$ and radius passed via the keyword argument `radius`. ",
" ",
"**A2:** *Place your implementation in the code cell below.*"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "8af6c9b0-08b3-4a98-8868-97ab835a70f7",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"meshcircle (generic function with 1 method)"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"function meshcircle(h; radius=1.0) ",
" ",
" # Compute number of segments required to make a full circle ",
" n = ceil(Int, 2*pi*radius/h) ",
" # Compute angle increment for each segment ",
" delta = 2*pi/n ",
" # Generate vertices for circle mesh ",
" v = [(radius*cos(i*delta), radius*sin(i*delta), 0.0) for i in 1:n] ",
" # Generate line segments for circle mesh ",
" s = [(i, i % n + 1) for i in 1:n] ",
" # Return mesh object ",
" ",
" return Mesh(v, s) ",
"end"
]
},
{
"cell_type": "markdown",
"id": "11ecfcea-e698-4436-bdf1-f1422779ff03",
"metadata": {},
"source": [
"**Q3:** Write a function that meshes a rectangle of length $l$ and of width $w$ with segment length $h$. ",
" ",
"**A3:** *Place your implementation in the code cell below.*"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "53a41586-415b-45c1-8050-f4325fbeac37",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"meshrectangle (generic function with 1 method)"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"function meshrectangle(l, w, h) ",
" ",
" @assert l > h ",
" @assert w > h ",
" ",
" n_l = ceil(l/h) ",
" n_w = ceil(w/h) ",
" ",
" v = Vector{Vector{Float64}}() ",
" for i in 0:n_l-1 ",
" for j in 0:n_w-1 ",
" push!(v, [i*h, j*h]) ",
" end ",
" end ",
" ",
" s = Vector{Tuple{Int64,Int64}}() ",
" for i in 0:n_l-2 ",
" for j in 0:n_w-2 ",
" i1 = i*n_w + j + 1 ",
" i2 = i*n_w + j + 2 ",
" i3 = (i+1)*n_w + j + 1 ",
" i4 = (i+1)*n_w + j + 2 ",
" push!(s, (i1,i2,i4)) ",
" push!(s, (i1,i4,i3)) ",
" end ",
" end ",
" ",
" return Mesh(vs, s) ",
"end"
]
},
{
"cell_type": "markdown",
"id": "fe5e00cf-b5e5-4c92-809a-4ea452a7a5b5",
"metadata": {},
"source": [
"**Q4:** Write a function that translates a mesh `` by `v`. ",
" ",
"**A4:** *Place your implementation in the code cell below.*"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "e271c678-f2a0-4f7a-ab45-caccd0b5b846",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"translate (generic function with 1 method)"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"function translate(, v) ",
" ",
" vs = [v + v for v in .vertices] ",
" s = copy(.segments) ",
" for i in 1:length(s) ",
" s[i] = [findfirst(isequal(v), vs) for v in s[i]] ",
" end ",
" return Mesh(vs, s) ",
"end"
]
},
{
"cell_type": "markdown",
"id": "3049c7d4-a893-4417-9548-7968ed43bbd9",
"metadata": {},
"source": [
"**Q5:** Overload the base `+` operator such that you can generate a new mesh from two existing meshes `1`and `2` by writing ` = 1 + 2`. ",
" ",
"**A5:** *Place your implementation in the code cell below.*"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "54d2cad4-b387-46a6-8a22-6cdb00c8972d",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"+ (generic function with 1 method)"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
" ",
"function +(1::Mesh, 2::Mesh) ",
" new_vertices = [1.vertices; 2.vertices] ",
" offset = length(1.vertices) ",
" new_segments = [(i+offset, j+offset) for (i, j) in 2.segments] ",
" new_segments = [1.segments; new_segments] ",
" return Mesh(new_vertices, new_segments) ",
"end"
]
},
{
"cell_type": "markdown",
"id": "dffd1cbe-6deb-49f0-bbf4-397d3e8f2076",
"metadata": {},
"source": [
"**Q6:** Write a function that meshes a pair of circular wires with segment length $h$ and distance $d$ between the centers of the wires. ",
" ",
"**A6:** *Place your implementation in the code cell below.*"
]
},
{
"cell_type": "code",
"execution_count": 27,
"id": "cc6e4777-9928-4572-b8a0-dffdbb546057",
"metadata": {},
"outputs": [
{
"ename": "LoadError",
"evalue": "MethodError: no method matching +(::Int64, ::Int64) You may have intended to import Base.:+",
"output_type": "error",
"traceback": [
"MethodError: no method matching +(::Int64, ::Int64) You may have intended to import Base.:+",
"",
"Stacktrace:",
" [1] (::var\"#38#40\"{Int64})(i::Int64)",
" @ Main .\ one:0",
" [2] iterate",
" @ .\\generator.jl:47 [inlined]",
" [3] collect",
" @ .\\array.jl:787 [inlined]",
" [4] meshcircle(h::Float64; radius::Int64)",
" @ Main .\\In[18]:10",
" [5] get_wirepair(a1::Int64, a2::Int64, d::Int64, h::Float64)",
" @ Main .\\In[27]:4",
" [6] top-level scope",
" @ In[27]:16"
]
}
],
"source": [
"function get_wirepair(a1, a2, d, h) ",
" ",
" # Mesh the first circle ",
" mesh1 = meshcircle(h, radius=a1) ",
" # Mesh the second circle ",
" mesh2 = meshcircle(h, radius=a2) ",
" # Translate the second mesh along the x-axis by d ",
" mesh2 = translate(mesh2, [d, 0]) ",
" # Combine the two meshes ",
" mesh = mesh1 + mesh2 ",
" ",
" return mesh ",
" ",
"end ",
" ",
"get_wirepair(1, 1, 2, 0.4)"
]
},
{
"cell_type": "markdown",
"id": "31045dd5-01cd-4745-b6b8-edcfc17d7d48",
"metadata": {},
"source": [
"**Q7:** Write a function that meshes a circular wire above a rectangular plate (i.e., the original problem) with segment length $h$. ",
" ",
"**A7:** *Place your implementation in the code cell below.*"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "ba04bdd8-48a8-4135-bbdb-df164c3c1e01",
"metadata": {},
"outputs": [
{
"ename": "LoadError",
"evalue": "MethodError: no method matching +(::Float64, ::Float64, ::Int64) You may have intended to import Base.:+",
"output_type": "error",
"traceback": [
"MethodError: no method matching +(::Float64, ::Float64, ::Int64) You may have intended to import Base.:+",
"",
"Stacktrace:",
" [1] meshrectangle(l::Int64, w::Float64, h::Float64)",
" @ Main .\\In[7]:19",
" [2] get_geometry(a::Int64, w::Int64, b::Float64, d::Int64, h::Float64)",
" @ Main .\\In[24]:3",
" [3] top-level scope",
" @ In[24]:16"
]
}
],
"source": [
"function get_geometry(a, w, b, d, h) ",
" # Mesh the rectangular plate ",
" rectangle_mesh = meshrectangle(w, b, h) ",
" translate!(rectangle_mesh, (0, -b/2)) ",
" ",
" # Mesh the circular wire ",
" wire_mesh = meshcircle(h, a) ",
" translate!(wire_mesh, (0, d + a)) ",
" ",
" # Combine the two meshes ",
" combined_mesh = rectangle_mesh + wire_mesh ",
" ",
" return combined_mesh ",
"end ",
" ",
"get_geometry(1, 20, 0.5, 2, 0.01)"
]
},
{
"cell_type": "markdown",
"id": "28399c28-abb3-4fc5-9900-91b4fa9ae5db",
"metadata": {},
"source": [
"**Q8:** Write a function that plots a mesh. Take care the segments are represented via lines. ",
" ",
"**A8:** *Place your implementation in the code cell below.*"
]
},
{
"cell_type": "code",
"execution_count": 30,
"id": "a3840f4b",
"metadata": {},
"outputs": [
{
"ename": "LoadError",
"evalue": "UndefVarError: pkg not defined",
"output_type": "error",
"traceback": [
"UndefVarError: pkg not defined",
"",
"Stacktrace:",
" [1] top-level scope",
" @ In[30]:1"
]
}
],
"source": [
"pkg.add(plots) ",
"using plots ",
" ",
"function Plots.plot(::Mesh) ",
" x_coords = [.vertices[i,1] for i in .segments[:,1]] ",
" y_coords = [.vertices[i,2] for i in .segments[:,1]] ",
" x_coords_end = [.vertices[i,1] for i in .segments[:,2]] ",
" y_coords_end = [.vertices[i,2] for i in .segments[:,2]] ",
" ",
" x = [x_coords, x_coords_end] ",
" y = [y_coords, y_coords_end] ",
" plot(x, y, linetype = :path) ",
"end"
]
},
{
"cell_type": "markdown",
"id": "e6d400c3-3923-4adc-991b-b3a143ab0784",
"metadata": {},
"source": [
"**Q9:** Plot the geometry in question with with $a=1$ and $b=0.5$, $d=2$, $w=20$, and $h=0.01$. ",
" ",
"**A9:** *Place your implementation in the code cell below.*"
]
},
{
"cell_type": "code",
"execution_count": 40,
"id": "d144cae0-1aa6-46ce-a4b9-ff1871ca8aea",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"get_and_plot_geometry (generic function with 1 method)"
]
},
"execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"function get_and_plot_geometry(a, w, b, d, h) ",
" ",
"# Generate the mesh ",
" = get_geometry(a=1, w=20, b=0.5, d=2, h=0.01) ",
" ",
"# Plot the mesh ",
"Plots.plot() ",
"end"
]
},
{
"cell_type": "markdown",
"id": "37b6cce6-3790-42bc-858d-3451210110d4",
"metadata": {},
"source": [
"The MoM2D routine expects vectors of the start and end points. ",
" ",
"**Q10:** Write a function that given a `::Mesh` variable returns `xs`, `xe`, `ys`, `ye`. ",
" ",
"**A10:** *Place your implementation in the code cell below.*"
]
},
{
"cell_type": "code",
"execution_count": 42,
"id": "7cb608ed-156c-4c89-a19b-381d4929dcd7",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"get_xy (generic function with 1 method)"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Needed for the MoM routine from class ",
"function get_xy() ",
" n_segments = size(.s, 2) ",
" xs = zeros(n_segments) ",
" xe = zeros(n_segments) ",
" ys = zeros(n_segments) ",
" ye = zeros(n_segments) ",
" ",
" for i in 1:n_segments ",
" start_point = .v[:, .s[1, i]] ",
" end_point = .v[:, .s[2, i]] ",
" ",
" xs[i] = start_point[1] ",
" xe[i] = end_point[1] ",
" ys[i] = start_point[2] ",
" ye[i] = end_point[2] ",
" end ",
" ",
" return xs, xe, ys, ye ",
" ",
" ",
"end"
]
},
{
"cell_type": "markdown",
"id": "261bff06-90d8-4bc8-89dd-68e4ffe153f2",
"metadata": {},
"source": [
"**Q11:** Write a function that computes the capacitance matrix for a pair of wires. ",
" ",
"**A11:** *Place your implementation in the code cell below.*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "12e7d3bd-9535-456f-9457-b99e1575a4d3",
"metadata": {},
"outputs": [],
"source": [
"function get_capacitancewpmatrix(a1, a2, d, h) ",
" ",
" # Your implementation here ",
" ",
" C = [C11 C12; C21 C22] ",
" return C ",
" ",
"end"
]
},
{
"cell_type": "markdown",
"id": "b75990e0-4ac4-4875-b960-9ab830830205",
"metadata": {},
"source": [
"**Q12:** Write a function that computes the capacitance for a pair of circular wires. ",
" ",
"**A12:** *Place your implementation in the code cell below.*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e988d7e3-8447-4fa1-bffe-55a447d7bc63",
"metadata": {},
"outputs": [],
"source": [
"\"\"\" ",
" get_capacitance(a, w, b, d, h) ",
" ",
"Returns the capacitance of a pair of circular wires. ",
" ",
"Arguments: ",
" a1 = wire radius (top wire) ",
" a2 = wire radius (bottom wire) ",
" d = distance of centers of wires ",
" h = mesh size ",
" ",
"Returns: ",
" C = capacitance ",
"\"\"\" ",
"function get_capacitancewp(a1, a2, d, h) ",
" ",
" # Your implementation here ",
" ",
"end"
]
},
{
"cell_type": "markdown",
"id": "6448b450-2ecc-4276-b7ec-71e9f745622f",
"metadata": {},
"source": [
"**Q13:** Write a function that computes the capacitance matrix for the wire above rectangular plate case. ",
" ",
"**A13:** *Place your implementation in the code cell below.*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2f4cfe29-28cb-48ab-b039-75d5fb4b1466",
"metadata": {},
"outputs": [],
"source": [
"function get_capacitancematrix(a, w, b, d, h) ",
" ",
" # Your implementation here ",
" ",
" C = [C11 C12; C21 C22] ",
" return C ",
" ",
"end"
]
},
{
"cell_type": "markdown",
"id": "a54d12c8-6258-4189-a4e1-7c0baedabc5f",
"metadata": {},
"source": [
"**Q14:** Write a function that computes the capacitance for the circular wire above rectangular plate case. ",
" ",
"**A14:** *Place your implementation in the code cell below.*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "eaac6701",
"metadata": {},
"outputs": [],
"source": [
"\"\"\" ",
" get_capacitance(a, w, b, d, h) ",
" ",
"Returns the capacitance of a circular conducting wire placed over the middle of a conducting strip. ",
" ",
"Arguments: ",
" a = wire radius ",
" w = width of the strip ",
" b = thickness of the strip ",
" d = height of center of the wire over the strip ",
" h = mesh size ",
" ",
"Returns: ",
" C = capacitance ",
"\"\"\" ",
"function get_capacitance(a, w, b, d, h) ",
" ",
" # Your implementation here ",
" ",
"end"
]
},
{
"cell_type": "markdown",
"id": "d7bee7ff-c5de-42c1-bb18-9eed3d263708",
"metadata": {},
"source": [
"The analytical formula for the capacitance of pair of circular wires with distance $d$ and radius $a$ is ",
"\\begin{equation*} ",
"C = \\frac{\\pi \\varepsilon}{\\log\\left(\\frac{d}{2a} + \\sqrt{\\frac{d^2}{4 a^2}-1} \ ight)}\\, , ",
"\\end{equation*} ",
"which is implemented by the following Julia function:"
]
},
{
"cell_type": "code",
"execution_count": 38,
"id": "20cac72e-4ab7-4f59-9595-ffa0a9eee363",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Cwirepair (generic function with 3 methods)"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Analytical solution of wirepair ",
"Cwirepair(d, a) = */log(d/(2*a) + sqrt(d^2/(4*a^2) - 1) ) "
]
},
{
"cell_type": "markdown",
"id": "e4c0886b-63ae-491b-8a5d-6ca842cdfd4a",
"metadata": {},
"source": [
"# Extra Test with Analytic Solution for Pair of Circular Wires ",
"**Q15:** Implement a test that shows convergences against the analytic solution. Ensure that you include a plot with the relative error in decibels. ",
" ",
"**A15:** *Place your implementation in the code cell below*."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d1a4e82d-44a7-46ab-b92d-be55e9db04ef",
"metadata": {},
"outputs": [],
"source": [
"# Your implementation here"
]
},
{
"cell_type": "markdown",
"id": "55c81922-6e00-4e7f-b418-291d1f85c326",
"metadata": {},
"source": [
"**Q16:** Estimate the order of convergence. ",
" ",
"**A16:** *Place your answer in this markdown cell and the corresponding code below.*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c8e6ba9c-887b-4d91-979d-a17be3177b94",
"metadata": {},
"outputs": [],
"source": [
"# Your implementation here"
]
},
{
"cell_type": "markdown",
"id": "c3971ce5",
"metadata": {},
"source": [
"# Numerical Test #1 ",
"Test the program by running the case $a =$ 1 mm, $b=$ 0.5 mm, $d =$ 2 mm, and $w =$ 20 mm. Determine the order of convergence and make an extrapolation to zero grid size within 1% accuracy. ",
" ",
"**Q17:** Propose a technique to ensure 1% accuracy ",
" ",
"**A17:** *Place your answer in this markdown cell and the corresponding code below.* "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2ff17e00",
"metadata": {},
"outputs": [],
"source": [
"# Your implementation here"
]
},
{
"cell_type": "markdown",
"id": "1012b6f3-4d6c-499a-b565-e365991b3208",
"metadata": {},
"source": [
"**Q18:** Determine order of convergence. ",
" ",
"**A18:** *Place your answer in this markdown cell and the corresponding code below.* "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "05dbf796",
"metadata": {},
"outputs": [],
"source": [
"# Your implementation here"
]
},
{
"cell_type": "markdown",
"id": "a03a8269-631e-47d2-abdf-60f9ebc5ae70",
"metadata": {},
"source": [
"**Q19:** Extrapolate to $h \ ightarrow 0$. ",
" ",
"**A19:** *Place your answer in this markdown cell and the corresponding code below.* "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5191acde",
"metadata": {},
"outputs": [],
"source": [
"# Your implementation here"
]
},
{
"cell_type": "markdown",
"id": "dab9f489",
"metadata": {},
"source": [
"## Numerical Test #2 ",
" ",
"Verify that your result for $C$ is reasonably close to the analytical result for an infinite plate, i.e., $w = \\infty$. ",
" ",
"The analytic formula can be found in Wikipedia (Wire parallel to wall) ",
"\\begin{equation} ",
" C_\\text{ana}(d, a) = \\frac{2 }{\\ln\\left(\\displaystyle\\frac{d+\\sqrt{d^2-a^2)}}{a}\ ight)} ",
"\\end{equation} ",
"provided as code:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c3a8c7bd-b1dc-49b8-85b6-bcd53289153e",
"metadata": {},
"outputs": [],
"source": [
"C_ana(d, a) = 2**/log((d+sqrt(d^2-a^2))/a) "
]
},
{
"cell_type": "markdown",
"id": "a6ee40c0",
"metadata": {},
"source": [
"**Q20:** Demonstrate convergence ",
" ",
"**A20:** *Place your answer in this markdown cell and the corresponding code below.*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "92b141f6",
"metadata": {},
"outputs": [],
"source": [
"# Your implementation here"
]
},
{
"cell_type": "markdown",
"id": "cf76509f",
"metadata": {},
"source": [
"## Numerical Test #3 ",
" ",
"Keeping all the other parameters the same, set $w =$ 0.5 mm. Check the order of convergence and extrapolate to zero grid size, with at most 1% error. ",
" ",
"**Q21**: Repeat tasks from **Q17**-**Q19**. ",
" ",
"**A21**: *Place your answer in this markdown cell and the corresponding code below.* "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "64215110",
"metadata": {},
"outputs": [],
"source": [
"# Your implementation here"
]
},
{
"cell_type": "markdown",
"id": "33775220-7190-45d6-ad7c-7ff058960d1e",
"metadata": {},
"source": [
"# Numerical Test #4 ",
" ",
"Now you have some idea of what resolution is required. Based on this experience, compute and plot the capacitance as a function of width for the interval 0.2 mm
]
},
{
"cell_type": "markdown",
"id": "30d27804",
"metadata": {},
"source": [
"**Q22:** What $h$ should be choosen? ",
" ",
"**A22:** *Place your answer in this markdown cell.* "
]
},
{
"cell_type": "markdown",
"id": "b3eb3075-2257-430b-a532-965b6ee2fe71",
"metadata": {},
"source": [
"**Q23:** Compute capacitances and plot. ",
" ",
"**A23:** *Place your answer in this markdown cell and the corresponding code below.*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c882a0f1-e568-490f-ba4b-a08bda284fac",
"metadata": {},
"outputs": [],
"source": [
"# Your implementation here"
]
}
],
"metadata": {
"@webio": {
"lastCommId": "842ebac5-b055-4ba3-8cae-b2a219761c91",
"lastKernelId": "dbb48e53-ee91-4c5c-a4ff-13a679e4d1bc"
},
"kernelspec": {
"display_name": "Julia 1.8.5",
"language": "julia",
"name": "julia-1.8"
},
"language_info": {
"file_extension": ".jl",
"mimetype": "application/julia",
"name": "julia",
"version": "1.8.5"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
Attachments:
Expert Answer:
