diff options
Diffstat (limited to 'Antennas_and_Wave_Propagation')
22 files changed, 4984 insertions, 0 deletions
diff --git a/Antennas_and_Wave_Propagation/README.txt b/Antennas_and_Wave_Propagation/README.txt new file mode 100644 index 00000000..d97e6a43 --- /dev/null +++ b/Antennas_and_Wave_Propagation/README.txt @@ -0,0 +1,10 @@ +Contributed By: Koushik S +Course: be +College/Institute/Organization: Visvesvaraya Technological University +Department/Designation: Electronics and Communication +Book Title: Antennas and Wave Propagation +Author: John. D. Kraus, Ronald J Marhefka and Ahmad S Khan +Publisher: Tata McGraw Hill Education Private Limited, New Delhi - 110 008 +Year of publication: 2012 +Isbn: 987-0-07-067155-3 +Edition: Fourth Edition
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter11.ipynb b/Antennas_and_Wave_Propagation/chapter11.ipynb new file mode 100644 index 00000000..5d30b647 --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter11.ipynb @@ -0,0 +1,100 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 11: Broadband and Frequency-Independent Antennas<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 11-1.1, Page number: 423<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "d = 4 #spacing (mm)\n", + "D = 100 #distance between the openings (mm)\n", + "\n", + "#Calculation\n", + "lambda_short = 10*d #Shortest wavelength (mm)\n", + "lambda_long = 2*D #Longest wavelength (mm)\n", + "bandwidth = lambda_long/lambda_short #Bandwidth (unitless)\n", + "\n", + "#Result\n", + "print \"The approximate bandwidth is\", bandwidth,\"to 1\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The approximate bandwidth is 5 to 1\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 11-7.1, Page number: 438<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import atan,pi,log\n", + "\n", + "#Variable declaration\n", + "gain_dbi = 7.0 #Gain (dBi)\n", + "bandwidth = 4 #Relative bandwidth (unitless)\n", + "s_lambda = 0.15 #Spacing (lambda)\n", + "k = 1.2 #Scale constant (unitless)\n", + "\n", + "#Calculation\n", + "alpha = atan((1-1/k)/(4*s_lambda))*180/pi #Apex angle (degrees)\n", + "n = round(log(bandwidth)/log(k)) #Number of elements(unitless)\n", + "n += 1\n", + "n += 2 #Number of elements considering conservative design (unitless)\n", + "\n", + "#Result\n", + "print \"The apex angle is\", round(alpha,1), \"degrees\"\n", + "print \"The number of elements is\", n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The apex angle is 15.5 degrees\n", + "The number of elements is 11.0\n" + ] + } + ], + "prompt_number": 2 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter12.ipynb b/Antennas_and_Wave_Propagation/chapter12.ipynb new file mode 100644 index 00000000..5d140dce --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter12.ipynb @@ -0,0 +1,195 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 12: The Cylindrical Antenna and the Moment Method (MM)<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 12-12.1, Page number: 472<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi\n", + "import numpy as np\n", + "\n", + "#Variable declaration\n", + "N = 3 #Piecewise sinusoidal dipole modes (unitless)\n", + "l = 1/10.0 #Dipole length (lambda)\n", + "z11_exact = 0.4935 - 3454j #Exact impedence vector(ohm)\n", + "z11_apprx = 0.4944 - 3426j #approximate impedence vector(ohm)\n", + "z12_exact = 0.4935 + 1753j #Exact impedence vector(ohm)\n", + "z12_apprx = 0.4945 + 1576j #approximate impedence vector(ohm)\n", + "z13_exact = 0.4935 + 129.9j #Exact impedence vector(ohm)\n", + "z13_apprx = 0.4885 + 132.2j #approximate impedence vector(ohm)\n", + "\n", + "#Calculations\n", + "N2 = N + 1 #Number of equal segments (unitless)\n", + "d = l/4 #Length of each segment (lambda)\n", + "Rmn = 20*(2*pi*d)**2 #Real part of elements of Z-matrix, Zmn (VA)\n", + "zmat_apprx = np.array([[(z11_apprx+z13_apprx), z12_apprx],\n", + " [2*z12_apprx, z11_apprx]])\n", + " #Z(impedence) matrix (unitless)\n", + "vmat = np.array([0,1]) #Voltage matrix (unitless)\n", + "i1,i2 = np.linalg.solve(zmat_apprx,vmat) #Current matrix (unitless)\n", + "i_ratio = i2/i1 #Current ratio (unitless)\n", + "zin = vmat[1]/i2 #Input impedence (ohm)\n", + "\n", + "\n", + "zmat_exact = np.array([[(z11_exact+z13_exact), z12_exact],\n", + " [2*z12_exact, z11_exact]])\n", + "i1_e,i2_e = np.linalg.solve(zmat_exact,vmat) #Current matrix (unitless)\n", + "i_ratio_exact = i2_e/i1_e #Current ratio (unitless)\n", + "zin_exact = vmat[1]/i2_e #Input impedence (ohm)\n", + "\n", + "\n", + "#Result\n", + "print \"The current ratio is \", np.around(i_ratio,4)\n", + "print \"This is nearly equal to 1.9,\" \\\n", + " \"indicating a nearly triangular current distribution\"\n", + "print \"The input impdence is \", np.around(zin,3), \"ohm using approximate values\"\n", + "print \"The input impedence is \", np.around(zin_exact,3), \"ohm using exact values\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The current ratio is (2.09+0.0013j)\n", + "This is nearly equal to 1.9,indicating a nearly triangular current distribution\n", + "The input impdence is (1.891-1917.848j) ohm using approximate values\n", + "The input impedence is (2.083-1605.074j) ohm using exact values\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 12-12.2, Page number: 473<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import tan, pi\n", + "import numpy as np\n", + "\n", + "#Variable declaration\n", + "z_load = 2.083 + 1605j #conjugate matched load (ohm)\n", + "e0 = 1.0 #Electric field magnitude (unitless)\n", + "l = 1/10.0 #length of dipole (lambda)\n", + "imag = 0+1j #Imaginary number \n", + "\n", + "z11_exact = 0.4935 - 3454j #Exact impedence vector(ohm)\n", + "z11_apprx = 0.4944 - 3426j #approximate impedence vector(ohm)\n", + "z12_exact = 0.4935 + 1753j #Exact impedence vector(ohm)\n", + "z12_apprx = 0.4945 + 1576j #approximate impedence vector(ohm)\n", + "z13_exact = 0.4935 + 129.9j #Exact impedence vector(ohm)\n", + "z13_apprx = 0.4885 + 132.2j #approximate impedence vector(ohm)\n", + "\n", + "#Calculation\n", + "d = l/4 #Length of each segment (lambda)\n", + "vm = (2*e0/(2*pi))*tan(2*pi*d/2) #Voltage vector (VA)\n", + "z22 = z11_exact + z_load #Impedence matrix for loaded dipole (VA)\n", + "zmat_exact = np.array([[(z11_exact+z13_exact), z12_exact],\n", + " [2*z12_exact, z22]])\n", + " #Z(impedence) matrix (unitless)\n", + "vmat = np.array([vm,vm]) #Voltage matrix (unitless)\n", + "i1,i2 = np.linalg.solve(zmat_exact,vmat) #Current matrix (unitless)\n", + "i3 = i1 #Current vector (unitless)\n", + "\n", + "e_zn = (60*tan(2*pi*d/2))*imag #Free space electric field (V/m)\n", + "\n", + "e_s = i1*e_zn + i2*e_zn + i3*e_zn #Scattered field (V/m)\n", + "\n", + "sigma = 4*pi*(abs(e_s)**2)/(abs(e0)**2) #Radar Cross section (lambda**2)\n", + "\n", + "#Result\n", + "print \"The radar cross section using exact values of Z matrix is\", round(sigma,4),\\\n", + " \"lambda^2\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The radar cross section using exact values of Z matrix is 0.1805 lambda^2\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 12-12.3, Page number: 475<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import numpy as np\n", + "\n", + "#Variable declaration\n", + "z11_exact = 2-1921j #Exact impedence vector (ohm)\n", + "z12_exact = 1.9971-325.1j #Exact impedence vector (ohm)\n", + "\n", + "z11_apprx = 1.9739-1992j #Approximate impedence vector (ohm)\n", + "z12_apprx = 1.9739-232.8j #Approximate impedence vector (ohm)\n", + "\n", + "vmat = np.array([1,0])\n", + "\n", + "#Calculations\n", + "zmat_exact = np.array([[z11_apprx, z12_apprx],\n", + " [z12_apprx, z11_apprx]]) \n", + " #Impedence matrix (unitless)\n", + "i1,i2 = np.linalg.solve(zmat_exact,vmat)\n", + " #Current matrix (unitless)\n", + "zin = 1/i1\n", + "\n", + "#Result\n", + "print \"The input impedence for order N = 2 is\", np.around(zin,3), \"ohm\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The input impedence for order N = 2 is (1.539-1964.795j) ohm\n" + ] + } + ], + "prompt_number": 4 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter15.ipynb b/Antennas_and_Wave_Propagation/chapter15.ipynb new file mode 100644 index 00000000..223fe26f --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter15.ipynb @@ -0,0 +1,830 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 15: Antennas for Special Applications<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 15-2.1, Page number 524<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "freq = 100e3 #Frequency (Hz)\n", + "height = 150 #Height of antenna(m)\n", + "RL = 2 #Loss resistance (ohm)\n", + "c = 3e8 #Speed of light (m/s)\n", + "\n", + "#Calculations\n", + "wave_lt = c/freq #Wavelength (m)\n", + "hp = height/wave_lt #Antenna (physical) height (lambda)\n", + "he = hp/2 #Effective height (lambda)\n", + "\n", + "Rr = 400*(hp**2) #Radiation resistance (ohm)\n", + "\n", + "R_E = Rr/(Rr+RL) #Radiation efficiency (unitless)\n", + "\n", + "#Results\n", + "print \"The Effective height of the antenna is \", he, \"lambda\"\n", + "print \"The Radiation resistance for 150m vertical radiator is\", Rr, \"ohm\"\n", + "print \"The radiation efficiency is\", round(R_E,2), \"or\", round(R_E*100,2), \"%\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Effective height of the antenna is 0.025 lambda\n", + "The Radiation resistance for 150m vertical radiator is 1.0 ohm\n", + "The radiation efficiency is 0.33 or 33.33 %\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 15-4.1, Page number: 529</h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%pylab inline\n", + "import numpy as np\n", + "from math import pi, sin, sqrt, radians\n", + "from pylab import *\n", + "from cmath import sqrt\n", + "import matplotlib.pyplot as plt\n", + "\n", + "#Variable declaration\n", + "eps_r1 = 16 #Real part of relative permittivity of ground (unitless)\n", + "sigma = 1e-2 #conductivity of ground (mho per meter)\n", + "eps_0 = 8.85e-12 #Air permittivity (F/m)\n", + "f1 = 1e6 #Frequency (Hz)\n", + "f2 = 100e6 #Frequency (Hz)\n", + "\n", + "#Calculation\n", + "eps_r11 = sigma/(2*pi*f1*eps_0) #Loss part of relative permittivity for f1 (unitless)\n", + "eps_r11_2 = sigma/(2*pi*f2*eps_0) #Loss part of relative permittivity for f2 (unitless)\n", + "\n", + "eps_ra = eps_r1 -(1j)*eps_r11 #Relative permittivity for f1 (unitless)\n", + "eps_rb = eps_r1 -(1j)*eps_r11_2 #Relative permittivity for f2 (unitless)\n", + "\n", + "n1 = sqrt(eps_ra) #Refractive index for f1 (unitless)\n", + "n2 = sqrt(eps_rb) #Refractive index for f2 (unitless)\n", + "E_perp1 = [1 + (abs((sin(alpha) - n1)/(sin(alpha)+n1))*exp(1j*(2*pi*sin(alpha) + angle((sin(alpha) - n1)/(sin(alpha)+n1))))) \\\n", + " for alpha in arange(0,pi/2,pi/180)] \n", + "\n", + "E_perp2 = [1 + (abs((sin(alpha) - n2)/(sin(alpha)+n2))*exp(1j*(2*pi*sin(alpha) + angle((sin(alpha) - n2)/(sin(alpha)+n2))))) \\\n", + " for alpha in arange(0,pi/2,pi/180)]\n", + "\n", + "E_perp1_rel = E_perp1/max(E_perp1) #Relative electric field for f1 (unitless)\n", + "\n", + "E_perp2_rel = E_perp2/max(E_perp2) #Relative electric field for f2 (unitless)\n", + "\n", + "theta = arange(0,pi/2,pi/180)\n", + "\n", + "polar(theta,E_perp1_rel,'g',label=\"1MHz\")\n", + "polar(theta,E_perp2_rel,'b--',label=\"100MHz\")\n", + "legend(loc=\"upper left\")\n", + "\n", + "\n", + "#Result\n", + "print \"The loss parameter for 1MHz is \", round(eps_r11)\n", + "print \"The loss parameter for 100MHz is \", round(eps_r11_2,2)\n", + "print \"The relative permittivity for 1MHz is \", np.around(eps_ra)\n", + "print \"The relative permittivity for 100MHz is \", np.around(eps_rb,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The loss parameter for 1MHz is 180.0\n", + "The loss parameter for 100MHz is 1.8\n", + "The relative permittivity for 1MHz is (16-180j)\n", + "The relative permittivity for 100MHz is (16-1.8j)\n" + ] + }, + { + "output_type": "stream", + "stream": "stderr", + "text": [ + "/usr/lib/python2.7/dist-packages/numpy/core/numeric.py:460: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " return array(a, dtype, copy=False, order=order)\n" + ] + }, + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAARMAAAENCAYAAAAsdYFTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzsnXdcU+f3xz9hCKiAgqAMUQERF2jddVJ33VpbV92tteNb\n26+t3a11FrXWaq17gbMuhuAWEVcVEBEQEBkiO8wECCQ5vz/4kS+RlYT7JAHzfr3y0pv73HNOLsm5\nzzjPOTwiIujQoUNHA9HTtAE6dOhoGuiciQ4dOjhB50x06NDBCTpnokOHDk7QORMdOnRwgs6Z6NCh\ngxN0zkRHjWzbtg09e/ZEjx49sG3bNgBAbm4uRo8eDRcXF4wZMwb5+fmy9osXL0avXr1w4cIFTZms\nQ8PonImOajx58gT79u3DgwcPEBERAX9/fyQkJGDjxo0YPXo04uLiMHLkSGzcuFHW3sHBAaGhoThy\n5IiGrdehKXTOREc1nj59igEDBsDY2Bj6+voYPnw4zpw5A19fXyxYsAAAsGDBApw/fx4AYGBgAKFQ\nCJFIpEmzdWgYnTPRUY0ePXrg1q1byM3NRXFxMQICApCamorMzEy0bdsWANC2bVtkZmYCAFxdXSEW\nizF8+HB88sknmjRdhwYx0LQBOrQPV1dXrFq1CmPGjEGLFi3Qq1cv6Ovry7Xh8Xjg8Xiy461bt6rb\nTB1ahq5noqNGFi9ejIcPH+LmzZto3bo1XFxc0LZtW2RkZAAA0tPTYW1trWErdWgTOmeio0aysrIA\nACkpKTh79izmzJmDyZMn4/DhwwCAw4cPY+rUqZo0UYeWwdPtGtZRE8OGDQOfz4ehoSG2bt0KDw8P\n5Obm4t1330VKSgo6duyIU6dOoVWrVpo2VYeWoHMmOnTo4ATdMEeHDh2coHMmOnTo4ASdM9GhQwcn\n6JyJDh06OEHnTHTo0MEJughYHfVCRBCLxbIXEcHQ0BAGBgYwMDCQi4TV8fqicyavIVKpFHw+H+np\n6UhLS5P9+/LlS6SlpSEzM1P2b3l5OaRSKQwMDKCvry9zHlWdi56eHpo1a4bWrVvD3t4ednZ2sLW1\nhY2Njezfyv+3adMGenq6DnFTRBdn0sTJzMxEaGgoQkNDcf/+fURGRiI9PR2mpqZo1aoV7Ozs0KlT\nJ9ja2sLc3BwdO3ZE+/btYWNjg7Zt28LY2Bh6enq19j6ICFKpFCKRCFlZWXLOKSoqCoWFhTLHlZKS\nguLiYtjY2MDd3R1vvPEG+vbtiz59+sDGxkbNd0YH1+icSROiquMIDQ3Fv//+C6FQiH79+qFPnz7o\n2bMn+vfvDwcHBxgbG2vERpFIhNTUVDx69Aj+/v5ITk5GREQEjI2N0bNnTwwcOFDnYBopOmfSiOHz\n+QgICICfnx/u3r2LwsJCdOnSBR4eHujTpw/69OkDR0dHzuc0goKCMGLECM7kERGSk5Nx7949hIeH\nIzw8HKGhodDX18eQIUMwefJkTJgwAVZWVpzp1ME9OmfSyIiLi4Ovry/8/PwQHh4ONzc3LF68GMOH\nD2fiOGqCa2dSE0SExMRE3Lp1C35+frhy5Qo6d+6MmTNnYvLkyXB1ddVN/GoZOmei5UgkEty9exe+\nvr7w8fEBn8/HO++8g8mTJ8PDwwMmJiaaNlEtiEQi3LhxA35+fvD19YWRkREmTZqEKVOmYMiQITAw\n0K0laBqtciYWFhbIy8vTtBlNntatWyM3N1fTZqgMESE8PBwnTpzAtWvXkJSUhHHjxmHRokUYOXKk\nrseiIbTKmfB4PGiROU2Wht5ndQxzlCE1NRV79+7FsWPHoKenh+XLl2PhwoW69AhqRrfgr6PRY29v\nj9WrVyMuLg779+/Hv//+CwcHByxduhRhYWGaNu+1QdczeQ15He5zZmYm9u/fj127dsHOzg7Lly/H\nu+++q7El8dcBnTN5DXmd7rNYLIafnx/Wrl2LlJQULFq0CF988YUuhoUBumGODqUJCgrStAkKY2Bg\ngGnTpiE0NBR37tyBSCRCt27d8O2338pVJNTRcHTORMdrQ+fOnbFt2zY8evQIKSkpcHFxwebNm1FS\nUqJp05oEOmeiIDt27EDfvn1hbGyMRYsWyd4PCgqCnp4epk+fLtc+IiICenp68PDwkL2np6eH58+f\ny7X75Zdf8P7777M1nmO0aSVHFTp06ICjR48iKCgIt2/fhqOjI/bv3w+xWKxp0xo1OmeiIHZ2dvjx\nxx+xePHiauesrKxw7949udiNw4cPw8XFpd6YB11MhObo1q0bzp07h9OnT8PLywtubm44d+7cazOf\nxDU6Z6Ig06ZNw5QpU2BpaVntXLNmzTB16lScOHECQEXU6qlTpzB37lylvpienp4wNTWVvQwNDeV6\nQdpCY5ozUYTBgwfjxo0b2LJlC77//nv069cPN2/e1LRZjQ6dM1GS2pzD+++/jyNHjgAALl26hB49\nesDW1rbe66sef/311ygqKkJRURFiYmJgbW2NWbNmcWi9jtrg8XgYP348njx5gi+++ALvv/8+li1b\nhsLCQk2b1mhodBsaeKu5GRbQz6p1ZWsblgwaNAi5ubmIi4vDkSNHsGDBAhQXF1dr98Ybb8glByot\nLcXMmTPl2pSUlGDKlClYsWIFxo4dq5KdLGnscyZ1oaenh7lz52LixIlYuXIlunbtikOHDmH06NGa\nNk3raXTORFUnwJn+OoYt77//PrZv346goCAcOnQI3t7e1dqEh4fD0dFRdrx69Wo8e/ZMrs2SJUvQ\ntWtXfPXVV9wZrkMpzM3NsXfvXly4cAFLlizB+PHjsWnTJpiZmWnaNK1FN8xRkromTOfNm4e///4b\nEyZMUDjS8lXntHHjRjx79gz79+9vkJ0saWpzJnUxYcIEREZGQiqVonv37rh69aqmTdJaGl3PRFNI\nJBKUl5dDLBZDIpFAJBJV2/beqVMnBAcHy/U8lCEwMBDbt2/H/fv3YWRkxIXZOjigspfi4+ODRYsW\n4e2338bmzZthamqqadO0Cl3PREHWrFmD5s2b47fffoO3tzdMTEywbt068Hg8ud7Km2++iXbt2gFA\ntXM19Wqqtjl16hRycnLQtWtX2YrOxx9/zPiTKU9TnjOpiylTpuDJkyeQSqXo0aNHg3opEokEvXv3\nxqRJkwBUxBvZ29ujd+/e6N27NwIDA2VtFy9ejF69euHChQsN/gxMIS1Cy8xpstR1nwsKCqi0tFR2\nfPnyZcrIyJAdnzx5klJTU2XH58+flzuflpZGIpGIY4u1jxMnTpC1tTWtXbuWpFKp0tdv2bKF5syZ\nQ5MmTSIiol9++YW2bNlSrV1kZCT9/PPPJBaL6d13322w3SzR9Uxec7y8vOQmgC9fvgw+ny877tKl\nC8zNzWXH48ePx9OnT2XHgwcPljsfGhoqF7y3a9cupKeny47T09ObRFDYe++9h/DwcPj6+mL27Nk1\nrtzVRmpqKgICArB06VLZvSCiGu+LgYEBhEIhRCIRZ7YzQ7O+TB4tM6fJ0tD7fOPGDZWvPXXqFOXk\n5MiOr127RmVlZQ2yR5OUlJTQ7NmzqWfPnpSSkqLQNe+88w6FhYVRUFAQTZw4kYgqeiYdOnQgNzc3\nWrx4MeXl5cnar1ixgvr27Us3b95k8hm4Qtcz0aE0DZkzmTlzplwUcYsWLWRzRmKxGL6+vg01T60Y\nGxvj6NGjmDdvHgYOHIg7d+7U2d7f3x/W1tbo3bu3XE9k+fLlSExMxKNHj2BjY4P//ve/snNbt27F\ngwcPMGzYMGafgxM07c2qomXmNFm09T5LJBKKiIiQHRcUFFB0dLQGLVKOgIAAsrKyon379tXa5ttv\nvyV7e3vq2LEjtWvXjpo3b07vv/++XJvExETq0aMHa3M5R6u+Vdr6JW9qNPQ+N2SYowwCgUBOlyoT\nneomKiqK7O3t6fPPP6fy8vI621Yd5qSlpcne//3332n27NlM7WSBbpijQ2tp0aKF3JDq/v37ckum\n2ki3bt3w+PFjPH36FOPHj6+z2gIRyYZ4X3/9Ndzc3ODu7o6bN29i69at6jKZM3RpG19Dmsp9Pnv2\nLIYOHaqVlf7EYjG+/PJLXL16FUFBQbC2tta0SczROZPXkKZynwsLC8Hj8bQ2EpWI8NVXX+HChQu4\ndu1ajbvImxK6YY4OpdGWvTlmZmYyR1JWVoZ169Zp2CJ5eDweNm/ejAULFmD48OFISUnRtElM0TkT\nBaktbSMAXLt2Da6urmjRogXeeuutal+aVatWoU2bNmjTpg2++eYbuXN6enpo27YtJBKJ7L3y8nJY\nW1vLpSoYMWJEtc1/QUFBaN++PVcfsVHTrFkzfP/997Lj0tJSDVojzzfffIOlS5di8ODB1dJ2NiV0\nzkRBakvbmJOTgxkzZmDdunXIy8tD37598d5778nO7969Gz4+Pnj8+DEeP34MPz8/7N69W06GhYWF\n3MRiYGAgLCwsqu3r0ZYUj41hb05YWJhWZUtbtWoVvvnmmxofNk0FnTNRkNrSNp49exY9evTAjBkz\n0KxZM/zyyy+IiIhAXFwcgIpcsCtXroStrS1sbW2xcuVKHDp0SE5G1SxtAHDkyBHMnz9fqXmNu3fv\nyqV8NDY2RqdOnVT/wI2cN998E8OHD5cda7KGdXFxMSQSCT755BOsWLECI0eORFpamsbsYYXOmSjJ\nqz/wqKgouLu7y46bN28OZ2dnREVFAQCio6Plzru5ucnOVTJlyhQEBwejsLAQeXl5CAkJwZQpU+rV\nXZVBgwbJUj7m5eVh4MCBmDNnjkqfsT60Zc5EUaRSKby8vDQ26Xz8+HFZ+scVK1Zg6tSpGDFiBLKy\nsjRiDysanTP55ReAx6v++uUXxdvX1lYRXh1qCIXCatm3zMzMUFRUBAAQCARyG+HMzMwgEAjk2hsb\nG2PSpEk4ceIETp48iSlTplRLrkRE+M9//oPWrVvLXpMmTapx6PPZZ5/BzMxM6yYkNYWenh7+85//\nyIXtq5MlS5agdevWsuNNmzZhzpw5GDVqlNymyMZOo3QmRNVfdTkTRdsqwqtPt5YtW1ZLOlxQUCBb\nZXj1fEFBAVq2bCnXnsfjYf78+Th8+DC8vLxqHOLweDxs374deXl5spe/v3+1drt370ZwcDCOHTum\n+oesh8YwZ1IXAQEBiIiIYKpDKBTi5cuXtZ7/+eefMWrUKMycORPl5eVMbVEXjc6ZaJpXewLdu3eX\n+2IKhUIkJCSge/fusvOPHj2SnY+IiECPHj2qyR06dCgyMjKQlZWFwYMHK2TLq47k1q1b+Omnn+Dj\n41PNYen4H5MnT5YberLgzp07MDQ0rPU8j8fDpk2bUFBQgC+//JKpLepC50wURCKRoLS0VC5to0Qi\nwbRp0/DkyROcPXsWpaWlWL16NXr16gUXFxcAwPz58/H7778jLS0NL1++xO+//46FCxfWqMPPz6/O\nXbN1jflfvHiBd999F15eXnB2dm7QZ62PxjZnUhdxcXE4deoU53JHjx5db9Srvr4+rl69iitXrmDv\n3r2c26B21LsVqG60zBw5fv75Z+LxeHKv1atXExHR1atXydXVlUxMTMjDw4OSk5Plrv3666/JwsKC\nLCwsaNWqVXLn9PT0KCEhoZq++Ph40tPTkx2PGDGC9u/fL9fmxo0b1L59eyIiOnjwIOnp6VHLli1l\nr9p2njb0Pqtro5+64CqfikAgoNu3byt9XWxsLFlbW9OtW7c4sUNT6MLpX0N097lmRCIRIiIi0L9/\nf5Wuj4uLg7m5Odq2bav0tQEBAVi4cCEePnwIBwcHlfRrGt0wR4eO/6dZs2ayVThVcHFxUcmRAMDb\nb7+Nb775BlOmTIFQKFTZBk2icyY6lKYpzZlUhcfjYeTIkUpdIxQKcfz4cU70f/HFF3B3d8fChQsb\nZc9R50x01ItAIJCLzcjOzm4cCY4bgEQiUShOR09PD6NGjeJEJ4/Hw65du/DkyROsWbOGE5nqROdM\ndCAuLg4FBQWy4927d8tllD979izy8/Nlx0ZGRnJd8Z07dyIzM1N2vH37duTk5MiOpVIpK9OZoa+v\nX21TZk2YmJhwmk/F2NgYV69exb59+3Dx4kXO5KoFjU7/voKWmdNkAUCxsbGy4+DgYLls6FyzZcsW\nKiwslB1XTVHYGJBKpZSbmys7FovFtGHDBqY6r127Ru3bt6f8/HymerhEt5rzGsLj8VBeXl6tvKmi\nBAUFqRwFS0TYu3cvli5dCj09PUgkEkgkEjRr1kwleeqgvLwcu3fvxqeffip7TyQSMS/hunjxYkil\n0mobQ7UWzfoyeVq3bk0AdC/Gr9atWzfo78RlnEl+fj7t2LGDM3kskUgkatVXWFhIDg4OFBAQoFa9\nqqJVzkRZBAIBOTg4kJ+fn9p0SqVSkkgk9Ouvv6pNp7JER0dTcHCwps1QifDwcDp79qymzaiRtWvX\nUnZ2NsXExKhN57Vr18je3p7pMJQrtGqYoyyffvopsrKymIRD10R5eTk8PT3lMnppA5V2fffdd1qT\nQKkhUJWs7WlpabCxsdGazyWRSHD58mWMHz9e4WtEYhFi+bFIzk9GWlEa0orSkFeahzJJGcokZQAA\nCxMLWJhYwN7MHu5t3dHVqiua6VcM/ZYvX46SkhKtH+40WmcSFBSEefPmITIyUm57N2uqftGBii9X\ncXGx2pMaS6VSiMVi2VzDq3axpCFzJspy/fp1tG/fHp07d1aLvlcRCoVo1qxZnZv2qiISixCaHorb\nKbdx/+V9PMl6guSCZDi2dkSnVp1ga2oLmxZ2aCayBU9iDBMjA0BPjBJeNoqk2UgqSEJERgSS8pMw\nrMMwzOw2E2Pbj8WAXgOwb98+pZyY2tFgr0hlBAIBdezYUW3Dm7rGyvn5+XVWcGPFsWPH6Pnz52rX\nS6S5vTnFxcV04cIFteo8dOgQZWdn13guLCyMBAIBRWRE0IZbG2jYwWHUYl0L6vVXf5r91wb64o+b\nFJkZSSKxSO667GyiNm2I7OyI2rYlsrAgataMyNn5f22KREV08slJmnFyBll5WtEH2z7Q+uFOo+yZ\nfPrpp3j27Jna1uG3bt2KJUuWVEuCpG6ysrJei/ortUFEiIyMhJubm0btkEglCEkJwcGQgwh8FIiW\n7U3ROf0HGKWNwIuo9oiJ1kenToC7O3D0KKCnQDQXEZCfD9TUyb4dE48fA/5A3AUfjOowCocOHuL8\nM3GChp2Z0oSEhJCdnZ3cur+2kJKSwiwuICcnh44fP85EdmPl8uXLlJOTw7lcgUBQY68vNC2U/hPw\nH7LZbEPuf7vT+uD1FJtTEa+zdCmRpydRSAhRcTG39oSEEFlZSan3mDtkbGZCly9f5lYBRzQqZyKV\nSmnQoEF05MgRtelTBj6fT1euXOFUf2lpKWfyuEJbUhDk5eUxCYC7ceMGZWRkEBFRbnEu7bi/g3r8\nPoQs535On3n/QU+zn1a75uHDh5zbUZW8PKIvviAyMTtEnbu6qn2ZWhEalTPx8fGhDh06kFgsZq4r\nMTGRDh48yFxPXfj4+FBkZKRGbagJbXEmVcnKyqIXL15wJi8yM5IWnV5Ozee+T3b971PzlmU0cZKU\nwsJqbu/j46OWwuqnTpWTYfPuWtlLbTTORCwWU/fu3en8+fNq0VcZT6Iqt27dalSh0I2d4uJiCgwM\nVPl6gUBA169fpwtxF2jk4ZHUavE8MjET0uBhItq3r6JnoC28veh3smpnSyKRqP7GaqTROJNDhw7R\nkCFD1OL9uYDP51NcXJzS1/3xxx9UVFTEwKLXC2UeBGKJmHZc3EHdPbtTz5096cijI5SaLqJXEuYp\nREZGBvOec7Ywm1o6taS//vqLqR5laRTOpKSkhOzt7SkkJIS5rj179pBAIGCupza07WlTE9o4zKmK\nWCxWKEJZIpXQjmtnyOXPLjRg7wDyferb4IdVVFQU8+hjqVRKxh8bk42NjUa/q6/SKJzJli1baOjQ\noWrRxefzOZfp7e1NBQUFtZ5PTExsND0uIu13JvUhlUppu981Mu93gnjNdpFXUEijuv9ERFaeVjR1\nxlRas2aN3PuLFi0ia2vrWvP/EhF99tln5OzsTG5ubhRW2ySQCmi9MykoKCBra2t6/Pixpk1Rmdzc\nXCopKan1/KFDh7Rydr4pIJVK6ebNm7LjfX6PqJX7TTIwy6Y5nz2m+PiaA9K40s2CMnEZGf5qSDFP\nY8jc3FxueTw4OJjCwsJqdSYXLlyg8ePHExHRvXv3aMCAAZzZpfXJkTZv3oxx48ahZ8+eTPWwLHLd\nunXrahX6qrJgwQLoKRLZpENpeDwexGIxEnIT8OZ/t2DZPGtMHm+M/HQLHP2zJ5yd2zDRW1BQgD//\n/JOJ7IS8BNiZ2cG1iytmzZqFDRs2yM4NHTq0zu0lvr6+WLBgAQBgwIAByM/Pl0ts1RC0+hucmZmJ\nbdu2YfXq1Uz1EBEkEglTHZVs3LgRYrEYJ06cUHuZSq5oTDlghWVCXKWr6L+vP0aPK0NGsim6mF5F\ni+Zsv/rm5uZy+U+4JDA+EKMdR+O774BFi37GwYMHkZKSotC1L1++RPv27WXH9vb2SE1N5cQurXYm\nf/zxB2bPno2OHTsy1cPj8fDWW28x1VHJf//7XxgYGKBPnz4qJyfSUT9EhPNPz6Pbzm5Iyk9C5PJI\n/DBiJc6ePIavvvpKLTbo6+szkesb54txnSZhxw6gc2cbzJ8/H56engpfTzWUnuUEzgZMHFNaWkrW\n1tZy6QVZUNdcBmvUEXz3ulFURPT5V/n0xufryHWHK117fo2I/nevKyNb1YVUKiUfHx/O5D3OeEzt\nNrejG8Gl1KtXxXuJiYlkbm4uCylITEysdc5k2bJlcgFvXbp04eyeaG3P5PTp0+jZs6eszCYLysvL\nsX37dmbyX+XEiROyRM1isRgbN25Um+6mDhFw+IgU9o4C7Lp6GR6DWyLiowi81amix7l582aIRCKV\n69qoCo/Hg729PWfyPO944vMBnyPAzwhjxlS817FjR4wYMUKhYvWTJ0/GkSNHAAD37t1Dq1atuLsn\nnLgkBvTr14+OHTumaTM4RZu3j7/K+fPn5ezdunWrbHPljRs35I6JiP7880+5pNHqJDycqM+AYmrZ\nMZp6fLuUorOi670mNjaW0x6DOojOiibL3ywpNSePLC2JqlaVvXTpErm5udF7771HNjY2ZGhoSPb2\n9rR//37atWsX7dq1S9b2k08+IScnJ3Jzc6PQ0FDO7NNKZxIeHk729vZUXl6uaVPUgkgkqjMORR3s\n2bOHUlJSZMdJSUm13v+a4kxEIpHc8vbatWvVEoAnkUjJpW8qtZi+grbc3kpiyf+GjgKBoM5hrLrv\neUMCzCRSCQ09MJS2399OR48STZnyynmJhOzt7VWqdcwVWulMPvjgg2rBOFwilUrp1KlTzORXJSMj\ng06cOFFnm7y8PDp8+LBa7KnE39+fwsPD1aKruLiYSWmItMI0Gus1lvrs7ltjb+TYsWOUlZXFuV5V\nkEqltGnTphrPBQYGUpcuXcjZ2Zk2btxY7Xx2djZ1H9SdTOxNqHv37rR//0HKzKwuZ+3atTRnzhyu\nTVcYrXMmeXl5ZGZmRunp6cx0lJWV0dOn1beRs6C4uFgrQp6lUqncdn1Nhu3HxMQ0OIr2QtwFare5\nHf10/ScqE5c1SNaBAwc0lupBLBaTk5MTJSYmUllZGbm7u1N0tLxj/Ozrz8jEw4TC08MpOzubLCws\nauw18vl8Mjc3p8yaPI0a0LoJ2MOHD+PNN99Eu3btmOkwNDREly5dmMmviomJCVq0aKFw++fPn8tV\n1+OK6OhoPHv2THbckDo1DY0z6dKli9IT60TAP/8A2bkifHnpS3zk/xFOvnMSqz1Ww1D/f/lZhUIh\n4uLilJI9YcIEjQUN/vvvv3B2dkbHjh1haGiIWbNmwcfHR3a+uLwYZ1PPop9lP/Rq1wuFhYWwtLSs\nMazAwsIC06dPx/79+9X5EWRolTMhIvz999/49ttvmelQV6DYpUuXIBAIlL6uVatWePToESc2nD9/\nHuXl5QCA7t27Y+jQoZzIbSg8Hg+2tray40OHDiExMbHW9tnZwDvvAN//VIZRf8/F87znePTRIwzr\nMKxa24iICLRq1Uope6ytrRVOGN1Q8vLycOfOHdlxTUFkL1++BFDxe/jI/yOMmD4CvOyKe+bu7o5t\n27bVKn/ZsmXYsWOH2oIwq6JVzuTGjRswMDBg+qXfuHGjWqoGtmvXDi1btlT6OgsLCwwfPpwTG5yc\nnJj8SLjOTL9w4cJaAxP9/CpyqepZPkfBAme87zEQ5947BwsTixrbv/nmmyrnyX369Cln0aC10apV\nK7lgtroCxtYEr0FkViQcI53QuXMvpKWl4dGjR/jkk09QVFRU4zUDBgyAnZ0dAgMDObe9PrTKmezd\nuxczZ85kWrLh+++/V0tJCHd39wbLuHHjhlJDnuLiYrmnHuv9TFxS+TdJTU3Fvn37IJUCy5cD//kP\nYeJ3XrjjOhT/zPbGyjdXVvv7CYVCXLlypcE2dOjQARkZGQ2WUxc8Hg8DBgyQHdvZ2eHFixey4xcv\nXsDe3h47H+zEkYgjCJgTCK/DDxAbOxNAxQOiU6dOiI2NrVXHsmXLcODAAXYfojY0MlNTA2VlZWRh\nYSG3PNkY4bL8BJ/Pp8TERIXbJyQkcJq6sDZYpyCo3G37955SmnpoPg3YO4BeFr6stX1qaqrGJh1V\npfIzlpeXk6OjIyUmJpJIJCJ3d3fa7LOZ7LbYUUJuAv32G5Gl5Re0atUvRFSxOmhnZ1dnqozs7Gwy\nNTVVe3S31vRMbt++jU6dOsmNH7kkNTUVaWlpTGRXQkQIDg7mTJ6FhUW9+5KICGVlFVXhHB0dOY22\n1BQ8Hg+phanYJRkAfkQibiy4AVtT21rb29nZcVoCRCKRoLCwkDN5NXH27FnExMTAwMAAO3bswNix\nY9GtWze4DHPBprhNWCRZhNUrrmDnTuDGje8QFfUQ7u7uGDVqFDw9PWFhUfMwDwDatGmDjh074vr1\n60w/QzXU6rrqYMWKFbR69Wpm8m/evNmoc7IePHiwxghTPz8/tcWLqIuHLx+S3RY78gzxpNjY2Brz\nggiFQtraMUGYAAAgAElEQVS7dy8T/UVFRbR79+4az9UXE0JU0XPr1asXde/enYYPH15jm/Ly8mqf\n669//yL73+0pKiuK9u8nsrEhUrWs8aZNm2jZsmWqXawiWuFMpFIptW/fvsn9KLgkLy+PysoaFk+h\nrTx8SPToUcX/fZ/6UhvPNnQm+ky1dlV/fGKxmElWvLpQJCYkLy+PunXrJhtu1lYNsCpSqZTWB68n\nx22O9Dy3Ypi8bx9RQ/a4xsbGkq2trVozyGnFMOfp06cAuJm01AREhM2bNzPV0apVK9nKDJ/PR0xM\nDFN9dcFVPhMiYPduYPx4IDUV2Be2Dx/6f4gLcy5getfp1dr/+uuvkEqlACq299fV1WdBfTEhAHDs\n2DHMmDFDNtxs06b25EtEhISkBHzo9yGOPzmOW4tuoVPrTgCAJUuAhuxxdXFxgZGREcLCwlQXoiRa\n4Ux8fX0xadIkZqssXl5eTORWwuPxsGzZMqY6qvLdd9/BxsZGbfpYIBQC8+cDf/0F3LpFCGu5BhtC\nNiB4YTD62/Wv8Zoff/wRa9euVcvSPgAUFhbKOYu6YkIqiY+PR25uLjw8PNC3b986v3v8Ej7Grx6P\nrOIs3F58u855IVV46623qjk7lmiFM/Hx8cHkyZOZyCYiDBo0iInsqpiamjLXUcnOnTuVDszikobG\nmcTFAQMHVtTgvXuXsDvpvzgdcxq3F99GZ8vOtV6np6eH77//HkDFMjhrzMzM0L17d9mxIg+78vJy\nhIWFISAgAJcuXcKaNWsQHx9frd2TrCfov7c/ZsydgTMzz8HUiPvvz4IFC+Dn58e53NrQuDPJyspC\nZGQk54FQlfB4PDg7OzORDQCJiYmyrjdLysrKcOnSJQDyGbwqI1wbExERwKefAvsPSPCfq0txL/Ue\nghYEoV3LmrdQVP2M+vr6KC4uVlscRdXvTm0xIVVp3749xowZAxMTE1haWmLYsGGIiIiQnSciHAw/\nCI/DHvjV41dMN9+AN3rrIT+fe9sHDRqEFy9eKJzSscGobXamFg4cOEDvvPOOps1QmcOHD6tlkisz\nM7NazIlIJKp1RYElXMSZlEvKae6ZueRxyIOKRHUXHdu0aRMJhcIG61SVkpISkkgkNcaEvDoBGxMT\nQyNHjiSxWExCoZB69OhBUVFRRERUWFpIc8/MpW5/daPH6U9oyxaiNm2I1q69xcz2SZMm0Y4dO5jJ\nr4rGncm0adOYbb9PTk4mLy8vJrJfZxrqTMol5TTr9CwafWQ0Ccsa5iTUkfoyJCREVlgrICCAXFxc\nyMnJidavX09EVC350KZNm6hbt27Uo0cP2rZtGxERhaWFUec/O9NSn6WUmCqk8eOJBgwgev68ojwF\nqwCzgwcP0ujRo5nIfhWNOhOpVEpt27alpKQkJvIlEonGtpZzRVRUlELlQoVCodbF0ZSXEz14IP+e\nWCKmuWfm0ugjo6m4rLjWawUCgUKZ27y9venZs2cNNZUZZeIyWh20mqw8rejY42NUUkLUsSPRt98S\nqWOlPysri8zNzdVSl0mjcyZpaWkoLS2Fg4MDE/l6enowMjJiIjslJQX//vsvE9lVSUxMRPPmzett\nJxKJEBAQwNweRZBKAV9f4I03gJ9/rlgCBgApSfGB3wdIK0rD+VnnYWJoUquMwMBAlJSU1Ktr7ty5\ncHJyqvHcxYsX4erqis6dO+O3336rVcaDBw9gYGCAs2fP1qtPGSIyItB/X3/cS72HsGVhmN1zNoyN\ngZAQYP16QB0bla2srGBubo6EhAT2ypi7qzrw8fGhsWPHMpEtEomYJgBKTk5uVDlduaS2Yc727UTv\nv09kb0/Upw/R2bNEldNJUqmUVgSuoEH7BtU7R8IFigSYVbbz8PCgCRMm0OnTp+uU+eDVblYtiMQi\nWW/kYPhBhebU7ty5w2xf2vDhw+Uy0rNCoz2T0NBQ9OnTh4nsoKAgREVFMZENAA4ODkyXZxuyShMb\nG8skwVJ9mJoCI0YAly8DDx8C06YBlaup62+tx/Wk67gw5wJaNqs5NYNQKFT5bxYTE4OQkBDZsSIB\nZgCwfft2vPPOO7CysqpXR2Vlgbq4+vwq3P52w4O0B7g+MwILey1UaEnZycmpQQmr6mLIkCF4+PAh\nE9lV0agz+ffff5k5kzFjxqB3795MZKsDT09PlYOzrKysEB0dzbFFFT+8kpIS2TL+0aNHZZsMAWDB\nAmDxYqBrV/nrDoQfwP7w/bg49yJam9ReujI6OrrOiNG6cHV1RadOnWTHigSYvXz5Ej4+Pli+fDmA\n+uNIJk2aVOu51MJUvPvPu/jA7wOsH74FQ1L8MKKvDaokt6sTa2trZmU4hgwZopZIWI05EyJi2jNh\nyaZNm5hHYTYk74qFhQUngXpbtmyR6+EsWrRIrmbykCFDZOkDxWIx1q1bV+2+XHx2Ed9d+w4X512E\njWndUbv9+vVT+QfF4/FgZ2cnd1wfK1aswMaNG8Hj8UAVixFK6y0Vl+K3kN/Qa1cvdG3TFVs6PsWq\n6RNw+zZw7x7AMMRJYfr06YOwsDD28VDMB1K1kJqaSpaWlkxiNAQCgVxNF65RZHVFW7h48aLCqzzn\nz5+nJ0+e1NuutjmTqisGBQUF9G/Sv9TGsw2FJIfUKksgENCFCxcUsk8RsrKyqLS0lO7evSs3H7d+\n/fpqMTmdOnWijh07UseOHally5ZkbW1dby0df3//irgTqYSOPDpCHbZ2oCnHp9DtJ4k0bhyRiwtR\nQIBqtgcGBjKbN7G2tqa4uDgmsivRmDPx8fGhMWPGMJF99+5dioiIYCKbNTdu3OB04pjP59PLl7Un\nFqqKorEOisSZPIp7RFaLrOjo46N1tsvMzOS0ZGd0dDQFBwcrFGBWlYULF9KZM9V3Kr/K8+fP6Vz4\nOeq1qxcN3DeQbiVXBJwJhUQ7dxI15E+Xl5fHrJDZxIkTmU/Caqxy9sOHD+Hq6spE9sCBA5nIBYDS\n0lK5rj7XGBgYcDoRV9fO2uLiYuzZswcrVqwAAIU/V31bH8okZfgs5DN8OO9DzOk5R6arpiVuLpMa\nAUDXKhM2lUmHJBIJlixZgq5du2L37t0AoNLGzHup9/BTyE9Iyk/ChpEbML3rdNlwqnnzijSTDYHl\nhP7AgQMRGhqKWbNmMdOhsZ7JuHHj1F54igvWrVunaRNUZs+ePXJDNKlUyiTy8tMLn9LEYxNJIv3f\nsMfT01MWrVpSUkJ///13tevqSzzk7e1Nbm5u1LNnT3rzzTfV1vsMSQ6h0UdGk8NWB1rv500htxtf\npcnAwEDy8PBgqkNjzsTe3p7TfKmVSKVSim1IVpkmTEFBAUkkkgYPK+oa5nhHeJPzn86UV1J7DI5U\nKq02j6NIXMidO3dk1wUGBtKAAQNq1eHv76/AJ6mb4KRgGnl4JHX8oyP9evokLVgoJgsLoo8+ClQq\nN68ybNu2jUm0amZmJpmZmXEutyoaWc2RSCTIyMhgkq9UKBQyWRZlTVpaGk6ePMlUh5mZGYRCIS5f\nvsxE/tOcp1hxaQVOzzyNVsY1d9mJCDdv3oS5ubnc+4rEhQwaNEh23YABA+osS2Ftba3S6oxEKsG5\nmHMYcmAIFpxfgIG8z9AnJAHbl78Lx076ePYM2LhxkMpL2PUxf/58JnKtrKxQVlYGoVDIRD6goaXh\nrKwsmJubM6np0rJlS0ydOpVzuQCQmZnJRC4AWFpaYuLEiczkV2Jqaop58+bh119/VXl5u6Y5k1Jx\nKd47/R7WvbUO7u2qZ8wjIvz666+y/7+qW5G4kKrs378fb7/9dq3n+/Xrp9TSenF5MXY+2AnXv1yx\n8fZGfD7gc8R+GocH3lPw5iA9PH8O/PQT0Lo1YG5urlJNJEVo1aoVk+qCPB4PNjY2CgXeqYpGJmDT\n09OZeXaWnDlzBh9//DET2UZGRsz2EQEVqR7Nzc1hYGAAHo+HH374gdPMdquurIKLpQs+eOODGs9X\n1enh4VHjeUW5ceMGDhw4gNu3b6tsbyVJ+UnYE7oH+8L2YbDDYBycchCD2w+W2fP/KWSaBJXOhFV+\nH430TNLT0+Ho6MhEdmRkJBO5AJg5ErFYzDwIzsfHRy5Ev+rTTyQSKSXr1RywVxKu4OzTs9g9cXc1\npyASiWSf7dUn7vPnz2WBVIokHgKAx48f44MPPoCvry9at649mhYAAgICakwMJJFKcCHuAiYem4g+\nu/rh6f32+Mn6Ec69dw5DHIYo5Nh27tyJ0tLSetupgqenJxO5+vr6THsmGnEmaWlpzHKY1lXpTFvx\n9/fHkydPmOpYvHgxTEyq79ItLS3FX3/9pbLcgtICLPFdggOTD9RYsnPPnj211lzm8/myv1ffvn0R\nHx+PpKQklJWV4eTJk9VSeaakpGD69Onw9vZW6Ok6ZMgQuaXxl4Uvsf7Wejj96YTvzv0Nw5BfYbo7\nE0mnl8OymXL5V+fPn8+sPvGnn37KRG7Pnj2Z1o7iEetHYg2sXr0a+fn52Lp1q7pVq0x6ejosLS2Z\nbcYiIrWULeWapb5Loc/Tx+5JuxssKzAwECtWrJDFhXz77bdycSFLly7FuXPnZCkrDA0N600DUVxe\njPNPz+NwxGE8ePkAU51mI2bHesRFmmPWrIos8G+80WDTGwUbNmxAfn5+nekYGgTTtaJa+OCDD2jT\npk2aUK0y3t7ejTLR0rFjxxQO/y8oKFAqwdLVhKvU/vf2VFBaIPc+6+0M9SGWiOlG4g1a4rOEWm9s\nTeO8x9HxyOOyZEwBARURq68bhw4donnz5jGTr5FhTmZmZq0JbRpCSUmJrAYP18ydO5fJBGl5eXmt\nFe25YOjQoQqvPIjFYly9erXedkFBQRCUCfCB3wfYNXEXzIzM5M5fu3ZNqRQKBw8ehEQiUbh9TUik\nEtxMuolPLnwC240uWLzBHxbCgfi+5ffwHueNWT1myZIxjR9fEbHaUDZs2NBwITVw4MABJgXU27Vr\nh6SkJM7lVqKR1Zy0tDTY2nJbIwQABAIBcnJyOJfLkmfPniE5ORnjxo1jIl+ZWB4LCwvMmDFDobZf\nXPwCwzoMw9udqy/PKlu2ZOzYsZBKpXJZ9xVBJBbhZvJN+Mb64p8HQTBKeActEj6H8PGf6PWmPmY4\nAm5TS5gNTSu3IXDNvHnzZLuxucTOzg58Pp9zuZVoZM7ExsYG9+/fZ5aukQUJCQlMelMsoQbMw0RG\nRsLBwaFacNmDlw/w2+3f8DTnKe4suSPrlQiFQsTHx6NXr14NtrsusoXZCIgPgF+cH64+v4quVl1h\nn/gtLv45AePG6mPaNODttwENlhXSWvh8PpydnZGXl8dEvkZ6Jnw+n1kiGFbcvn270TmTNWvW4Kef\nflLpWjs7O8THx6Nv375y7zc3bI6xTmOxf/J+ueHNs2fPmPQ2RWIR7qbexeVnV3DxcRgSyu5gZKeR\nmOQyCTsn7IR1C2sIhYDhTwCjDkiTwcLCAgKBAGVlZWx6a8xmY2pBIpEQACZ5TOLj46mgoKD+hlpE\nZmYmM9msykBwUTfnVby9vSkpKYlEYhHdSblDG4M9acjGZWQ0eQVZ9L1ELVoXUo8+eVRarvwkOKvN\nmTt37qScnBzO5ebk5NDOnTs5l0tEZGxszCwfT53OZNGiRWRtbU09evSQvXf//n3q168f9erVi/r2\n7Uv//vuv7Nz69evJ2dmZunTpQpcuXZK97+vrS25ubrR06VIqKysjAwMDBh+F6NatWwpVndcm1FUg\nqSH4+fnJrfJUOhOBQEDnz59vkOxMQSb5x/rTd5e+o+EHhlPL9S3JbXt/MmoppHYOhTR7XikdOkTU\nkH11rFbhysrKmDwUpVIplTGqg2Fubl5nIvSadm4nJCRQv3796K233qrz2jqdSXBwMIWFhck5k+HD\nh9PFixeJqKIg0YgRI4ioor6Lu7s7lZWVUWJiIjk5Oclu9HvvvUcSiYR+/PFHevDgARkZGSn40bWD\n4uJievHihabNUAqRSMTZF53P51NWVla193NzcxXuWUmlUkrJT6HzTwLp88N7acDnv5PZWzvJfLU9\njToyir67+h0FxAVQfkmF03pNE/8zx9LSstYHbm07t1euXElJSUl07dq1Oh9+dc6ZDB06tNpSko2N\njSwvaH5+vizvpo+PD2bPng1DQ0N07NgRzs7OuH//PgYOHAipVAqRSITi4mLo6+szixxkRUFBAWJi\nYpjscmbFjh07sHz58hqjXpWltgRLNYWzF5QWILkgGc/zniOOH4fYnFjE8mPxYM9iSBJGgAregnnb\nfDh3KcXC/s3x06fLYGlRPUJBN4HKBgMDA4jF4hrPVd25DUC2c9vAwAACgQACgaDO367SE7AbN27E\nkCFDsHLlSkilUty9exdAxXJv1QxnVXd9fvjhhxg6dChGjhyJDh06MHMmYWFh6N27N+eRpO3atUO7\ndjUX1W4omZmZTCajv/zyS85lAsDvv/+O08GnYemyEi+fm6OokIfCfAMI8o1Rmm+OZjM+hFNPPjq1\n7gQXCxf0t+uPeW7zUNzBHY62FnByApo1qzm72rp16/D9999zbvPatWvxww8/cC73ypUrMDMzw4AB\nAziXzcpmsVhcqzOpaef2/fv3sWrVKsybNw+tWrXCsWPHapWttDNZsmQJ/vzzT0ybNg3//PMPFi9e\njCtXrtTYtvJHPWrUKFndjlfXuSs3jVVua2/I8YsXL1BQUAAej8eJPHUcb9iwAVOnTtUae+o7fvLk\nCeLC4tC1eTTs242ARRdDiAsj0a5Nc0yb8Dbe6B6E+/dvVpPRQv8xunatW8eCBQuY2Gxubo6goCDO\n74mVlRVMTEyY3POqe2i4lM/j8WrNUl/bQ9je3r7a5s4aqW+MlZiYKDdnYmpqKvu/VCqVZW/asGED\nbdiwQXZu7NixdO/evWryCgoKqEWLFvWp1Spe9zmTV2GxmqNDPVhbW1NaWlqN5xTJ6F8XSofTOzs7\n4+bNiifP9evX4eLiAqAi6vHEiRMoKytDYmIi4uPj0b9//2rXGxgYNDh0Wt0IhUKmqQ1Y4OXlhays\nLE5kCYVCFBYWyo4rn3hCoVAjlQN1qI5EIql1mkGRndt1UpenmTVrFtnY2JChoSHZ29vTgQMH6MGD\nB9S/f39yd3engQMHUlhYmKz9unXryMnJibp06SJb8XkVkUjEbGk4NjaWWakAVnBZ5oEVp0+frnHV\nhs/n04kTJzjRER4eTnfv3uVE1qtUDVPgkoSEBCouLuZcrlgsZvY9rm9pOCAggFxcXMjJyYnWr1+v\nlOwmFbR2584dpkFgLGAVnMQSFsOcgoICEggEnMslIgoJqb0IWEMIDAxUape1oqSnp5O3tzfncomI\nTExMmAWtaWRvjoGBAYqLi5ltwGJBfHw8OnfurGkzlCIvL6/ebGS1IRQK8fz5c/Ts2bPauaqTmZXE\nxMTA1ta22l4eHdoDEcHIyAhFRUVMdsBrJAVBmzZtOBvPq4v6kvBoI4cPH1Y5HWRMTEytBbJqSijd\ntm1bxMTEqKRLh3rIz8+HiYkJs1zDGnEmdnZ2THJRFhUVMUvbOHfuXCZyS0tLmTnWFStWqBxz07dv\nX6XiXywsLFSupHj79m3cuHFDpWvr48mTJ8xyeLBKtSkQCJTKB6Mo6enpzNKlAhpyJra2tsxyUbLM\nccmC8vJyXL9+XdNmAKgY2vj7+9fbrr6Yg4sXLyq1yjNw4EAMGzZM4fbKYGhoyKzsJqtEXP7+/kzy\n8rx8+ZJpVQiNOBNra2skJCRwLtfU1LTGMgpcEB8fz+RpYWpqyrT+a1pamlzW97ooKSlBv379Gqyz\nf//+KC4uVri9vr6+0omRFKVLly7MnMk777zDRO6sWbOY9CDS09PlIly5RiPOxN7enmnKfRakpqYi\nNzdX02YoTatWrRR23G3atFFoaFNf4XILCwuFfwzPnj1TqJ2OhpOens50f5nGhjn5+flMZLOaKPXw\n8GCW0CknJ4fZvEnz5s3r/PE3tNRFfezevbvWkpTl5eWybRYsSE1NRUhICBPZ8fHxcoF8XMIqtWKT\nnDNhWaYwOzubiVyWlJWVMRt/V6WmPRlGRkaYN2+eUnIU2qfx/8yePbvWncuVNYVZYWxsjC5dujCR\nnZyczCRPK4A6N9M1hMePHzc9Z2Jra8usezthwgQmcgEgPDyciVxbW1tmE5CVZGRkYM+ePdXe5/F4\nTGNDzMzMaqydq44tFW3atIGVlRUT2aNGjUJzLlLc18Bnn33GRG5paSmT1JqVaKxn0hjnH5KTkzVt\ngsq0a9cOy5YtA1ARvLR69WpOC5fXR1Wdd+7c0ZoVrNeJrKwspj0TjUTAisVimJiYoKSkhPOuokgk\nwqNHj5jkmGCJRCJBUFAQRo4cqRZdPB6vxh4DS6RSqdp0Hj16FB4eHkyexOnp6SgqKpJtcuWSzMxM\nWFpacv67ICK0aNECmZmZMDU15VR2JRrpmRgYGMDKyopJTEizZs1qrW2rzejr6zOLTKyksoi4j48P\noqKiVJajzJxJVapOurMq+l3J5MmTmXXpi4qKmA1x/Pz8mJSJzc3Nhb6+PjNHAmjImQBAt27dmMy0\n83g8pk93VpGaQEWhbZbs2bMHRUVFmD59eo17bliSmJgo+3uXlJTg77//ZqqP5Y/GxcWF2RLr0qVL\nmcTchIeHM69ppDFn0r9/fzx69EhT6lWmMRYXr+Szzz6DmZl8Kc+HDx/i8ePHSslRZc6kU6dOstwY\nJiYm+OKLL5SWoSiNbd+XOggNDa1WA4lrNOZM+vbt26Cudl3Exsbi+fPnTGSr8kNSBn9/f0RHR3Mm\nTygU1hm30Lt3b5V3FteHj48PQkND62xTUFDAaYIloVCICxcucCbvVZ48ecJs/1dubi6z8rahoaHo\n06cPE9mVaMyZ9OnTB6GhoSqvKNSFpaVlrUlztZ0xY8ZwWjnw+vXrdS7D6uvry4VY//7777UGmVVS\n25wJEcmF7k+ZMqXeL7BEIsG1a9fqbKMMLVq0wKJFiziT9yrGxsbMhjjR0dHMitjfunWLuTNRe3Kk\nSqRSKbVu3ZpSU1M1ZYLKHDt2jCQSiabNYEJ5ebkscVVJSQkdPXq0WpvK5EhlZWUUHR0tez8lJaXW\nDHs6NEdubi6Zmpoyq/BYicZ6JjweD3379q23G6yNDBw4kHnPJyoqSuVem1AoRFhYmErXGhgYyOaF\njIyM5CaFCwsLsWXLFtlQTyQSyW3vb9++PcaOHauSXqAiQlPVIQ8RMYscbeyEhoaiV69ezDZTVqIx\nZwIA/fr1Y+ZMwsLCEBcXx0R2p06dmGeJKywsRGpqqkrXJiQkcNIV5/F4cHBwkB2bmZnhv//9r+y4\nZcuWGD9+fIP1VGJvb69yZLRUKuVkx3Nd/Pnnn8widzMzM5kFRT58+JD9EAcadiaV8yYscHR0ZLo8\nCIDJfE8lgwYNUnm7uJubW61Z0rhA1TiT+rCwsFD5S6+vr888reb777/P7OmekZHBbKXQ39//9XAm\nd+/eZfKjbNWqFdPQ4ZcvX+LgwYPM5FcilUoVuj9CoRDnzp1jbo+68PPzU3jIEx8fz9iaClitegGA\nu7u7XC+QS9LT09XiTDQSTl8JEcHKygoRERGymsWNifLycuZ1k8PCwpCWloaJEyfW2a6goAAikYhp\nj0Sd5ObmQiqV1psZLCMjA5GRkRg9ejRTewoKChplsuy8vDx06NABeXl5TXvOhMfjYdCgQbh16xYT\n+VlZWfD29mYiG4BaCrC/8cYbCu2ENjc3bzKOBKgY8iiSYrBdu3bMHUlqaiouXrzITH5QUBCz3CjX\nr19Hv379mDsSQMPOBAAmTpwIPz8/JrKtra2ZpiQA1NPFrm0sXVZWhm3btjHX/yqs5kxqY8eOHdXS\nQBYVFdVaM5dr7O3t8d577zGT37JlS2bze/v372f+G6hEa5wJi/yqANtxLgDExcWpLZ3C+vXr5VYT\nmjVrhqVLl6pFtyZZtGhRtQRLx44dUyrPrDbTt29fJpOvUqkUYWFhmDJlCueya0KjcyaV9OvXD56e\nnsySQYtEIuY7ctWBWCyGgYEBiKhR7xFqCOr+7JcuXWpQ7IwmuX//PhYvXsxs28qraLxnAlRsF2c1\n1AGALVu2MJOtTipzXKxdu7bRbhdoCCKRCF9//TXTJfmqEFG1jZFcs2PHDmayT548iUmTJjGTXw2m\n8bUK8ujRI3JycmJSf1hd7NmzR232FxcX08aNG9WiqyZY1BpWhCtXrtDz5881opsV2dnZzGQ7OTnR\nnTt3mMl/Fa0Y5hARbG1tce3aNXTr1k3T5qhEeno62rZtyyyTWElJCYyMjNSeHa0maqo1rG6ICCUl\nJcySFKlj2Z8liYmJGDhwINLS0tSykgNoyTCHx+NhxowZ8PX1ZaYjISGh3t2wDcHGxobpD93Ly6vG\n5UORSKS2MXEl6nQkUVFRNZYvEQqFzIIGiQi//fYbE9mVlJeXQyQSMZPv5+eHCRMmqM2RAFriTICK\neROWzkQikTDLcVIVVkvFH374YY2V6QwNDZt0IauWLVvWGL3ZsmVLfPLJJ0x08ng8/PDDD0xkVxIc\nHMysVjFQsdpVmYxKXWjFMAeALHozPj6+UQdf/fPPP5g0aRKMjY0bLEsoFKKoqAjt2rVT+Bp1JG1m\nPcwpLCyEkZGRwitwOTk5MDQ0bJQRqiwoKCiAnZ0dMjMz0aJFC7Xp1ZqeiZGREUaNGoWjR49q2pQG\nMXPmTE4cCVCR0EbZZdDNmzc3+vgLX19flJSUKNxeT08PwcHBDdZbVlbWJNIY+Pv7Y/jw4Wp1JAC0\nYzWnkgsXLlDfvn2Z6jhw4IBaVl20YWVKG2xQlMLCQk2bQCUlJfTy5UvmeoKCgpjKHzZsGP3zzz9M\nddSE1vRMAGDs2LHg8/l48OABMx2jRo1SS5yCj4+PShUAhUIh7t+/z4kNDx48YJoPlSuysrI42/Ec\nGhqqcoIlY2NjphXvgIoSHyxXiR4/fozY2Fi1Rb1WRWvmTCr57bffcPv2baaTseqCVIjWjImJgYWF\nBaQUcvIAABjCSURBVJMi6S9fvuRkdzYXcyYRERFwcHDgfLtDbm4uXr58qVQpj4yMDAgEAjg7O3Nq\niyb46KOP0LZtW6xevVrturWqZwIAS5Yswc2bN5lVggcqfuSsdmlWRZWw765duzJxJEBFeDXL+6oM\nRUVFTMb0FhYWStcESkhIYJr7Rl0UFRXh1KlT+PDDDzWiX+ucSZs2bTBlyhQcOnSIqZ69e/cylV+J\nWCzG5s2b62wjFApx8uRJ5rZMnz4dlpaWACq62xs2bFBJjiq9kitXrsgVXRsyZAjz1JdnzpxRaMgz\nePBgtUxWrlu3jql8Ly8vvPXWW5rLDaT2WRoFuHv3Ljk5OTWZDPBCobDO8wKBgDIzM9VkTc2kpqbS\n7t27ZccSiUSpCVypVEolJSWy49DQUDp//jynNioLn8+ngoKCWs9HRkaq0Rqi0tJSZrKlUik5ODjQ\ntWvXmOmoD63rmQDAgAEDYGJi0igmDxWhvpDvFi1aaDy2xs7OTq57nJSUJJdYKi4uTrZsHxQUhLi4\nOLll1KdPn8olEHrjjTc0MglYFQsLi1o36pWVlak92I/lzvWQkBCYmJgw23mvEBpzY/Wwd+9emjRp\nElMdUqmUvLy8mOqoSkhICN28eZOIKurTeHp6qk03l2hqo19D2LJlC9OeQV2oY7PdrFmzaNu2bcz1\n1IXWreZUIhQK4eDggLCwMHTo0IGZnmfPnql1Fr+kpESW6Kfq/3WwpfJeR0ZGwsnJidkGwZq4ePEi\nxo0bx0x+eno6unbtiqSkpBq3XKgLrRzmABVd/3nz5jHPRaLu5cDK6Fgi0jkSNVJ5r1+8eMFZhLKi\nsHQkQEW+nhkzZmjUkQDQ3mEOEVFycjKZmZlRWloac13Pnj1jroOI6Ndff6Xy8nLy9vamuLg4tejk\nmsY4zKlEIpHQ6tWr1aKrrKyMuY6cnByytLTUiu+S1vZMAMDBwQFLly7FmjVrmOu6ffu2WiJjf/jh\nBxgYGGDu3LlNIkiqMXDp0iVZdUQ9PT38+OOPzHWKRCJs3bqVuZ4NGzZg5syZzAuQKYLWzplUwufz\n0aVLF9y7d6/R/viKi4vRrFkzWdrFV0lISICjo+Nrm9eVNUlJSejYsWO196VSKYqLi9GyZUv1G8UB\nKSkpcHNzQ0xMjFYE3Wl1zwQALC0t8fnnn+Pjjz9Wiz4WvvXEiRN1Bk9lZGSoJdfK64REIpH9LWty\nJAAgEAga9S7hX375BcuXL9cKRwJAu+dMKhEIBNS2bVsKDQ1lrmvnzp2UkZHBXE9jpjHMmezYsYP4\nfL7a9SYmJpKfnx9zPVFRUWRlZUV5eXnMdSmK1g9zKtm5cyd8fHxw6dIlpnqIo1IKQqEQfD5f6fqx\ngYGBsLa2VkttWFXRhhywXJOWloYWLVo0OMFSYWEhjI2NmW8VmDBhAjw8PLBy5UqmepRCw85MYUQi\nETk6OtLFixc1bYpCXL16VeUejkgk4tiapo9UKqWdO3eqvAWDz+c3mu/W3bt3qV27dlRcXKxpU+Ro\nNM6EiOjYsWPk6uqqlqQ/fD6f9u7dy1xPXSQnJ9OjR480akNjQpPD03PnzqllKVgqldLw4cNp3759\nzHUpi9ZPwFblvffeg7GxMc6ePctcl4WFBWbNmqXUNUKhUG5nbEOxs7OTKweqLai71nBtlJSUyN1v\nrlI33L17V+kES87OzmopjXHx4kVkZmZiwYIFzHUpS6NyJnp6evD09MRXX30FgUDAXJ+yS4bp6elw\ncXHhTL++vj7eeOMN2XF4eLjaqtk1BrKzs9G+fXvO5Xbp0gXp6elKXdOjRw/O7XiV0tJSLFu2DBs2\nbKg1zECTNJoJ2KrMnz8fQqEQZ86cUYu+Y8eOYcyYMWjTpo1a9NXGpUuXMGzYsNc6DD80NBQdO3aU\n5WXRJHl5eYiOjsbgwYPVom/VqlVISEjA6dOn1aJPaTQ8zFKJ3NxcsrW1VdsSZVFRkVyujqoIBALy\n9vZWix1Vefr0KUVFRaldr6a5c+cOicVitek7fvw45efn13guNjZWbUuzd+/epbZt22o8701dNEpn\nQkTk7+9Pjo6OVFRUpFE7SktLmdaLrQ2RSKT25D6VqDPOJCEhgc6dO6c2fa+Sm5tbb3Ir1pSUlJCT\nkxOdPHlSo3bUR6OaM6nKhAkTMGTIEHz66adq00lE1fZbGBkZaWT406xZM7lx+qFDh5CYmKh2O1hA\nVUbe1tbWmDhxosZsad26tVy6AiLC+fPn1WrDjz/+CDc3N7z77rtq1as0GnZmDSI3N5fatWun1idl\nbm4uSSQS2rBhg9p0KkrlkrlUKqWwsLBGVTenkvLyclqzZo1W2v7bb7+RQCBQa4+wMQxvKmnUzoRI\nc8MdkUiklV94oopt9j4+PrIALrFYrNX5dPfu3Uvp6emaNqNe1B1MWFJSQq6urlo/vKmk0Q5zKqkc\n7qxatYq5LqlUKvu/WCzGpk2bmOtUBT09PUyePFlWc5jP52PPnj2y81U/hyo0NM4kKCgIkZGRsuP5\n8+crVU9Z3RARtmzZIhdH0tB7qAiff/45XF1dtX94U4mmvRkX5ObmkrW1NV29epWpnvXr18s9nbS1\nZ1IfMTExdOLECdlxVlaWUtGjyg4rr1y5QiEhIbLj7OzsRnfvqma5F4vFtGbNGqb6GtPwppJGGWdS\nExcuXMDHH3+MBw8eqD3Te1lZGYRCIefV6dRFcnIyMjMz0b9/fwDAnTt3UFRUhLFjxwKoqDJYXl4O\nNzc3AMDz588hEonQtWtXABXFvYqKijBq1CgAwM2bNyGRSPDWW28BqHiKV/aSGhNisVgjwWF5eXno\n378/1q9fj5kzZ6pdv8po2ptxyQ8//EBDhgzhdGwrEAjqzWpeUFBAR44c4UyntsHn8+VSZ6alpVFy\ncrLsuKysTKvnZFRl3bp19ca0lJeXc1p0vby8nNzd3WnFihWcyVQXTaZnAlQ8AadMmQIDAwOcPXuW\nk1QC3t7eGDdunMajX7WJppiCQFXy8/Nx7tw5LFq0iBN5X3zxBaKiohAQEKCVIfN10fj6nnWgp6eH\nY8eOIT4+Hjt37uRE5rx585RyJAKBAEeOHOFEtw71c/nyZaX2P7Vq1YozR3Lw4EFcuHABJ0+ebHSO\nBEDTGuZUkpCQQG3btlW5VKJAIGhQtnp1ZNPXwT1SqbRBBbOSkpJqDb2vj6CgILKwsKCYmBiV9Wua\nJtUzqcTR0RHHjx/HzJkzkZCQoPT1YWFhMDU1VVl/1Zycyu4+1aF+ysrKAAA8Hg+DBg1SWY6pqSlC\nQ0OVvu7FixeYM2cOvLy84OrqqrJ+TdMknQkAeHh4YPXq1ZgyZQqKioqUunbo0KGcrAgREfz9/dUS\nk6BOtCWfCRfw+Xzs37+fE1kWFhayFSxFKS4uxtSpU7FixQq8/fbbnNihKZrUBOyrEBE++ugjZGRk\n4Ny5c3UuTwqFQty/f1/pL8PriG4Ctn6Cg4Ph7u5eZ05ZIoKHhwfs7e3h5eXV6EudNNmeCVDRbd2+\nfTtyc3Mxb968Otvy+Xx0796dqT1HjhxRadilbTR2R3L79m1cv36dqY4ePXogJyenzjZr166FUCjE\nvn37Gr0jAZp4z6SS7OxsDBkyBIsXL1ZL2L0O7aa8vFwtKRbrYvv27fjjjz9w69Yt2NraatQWrmjS\nPZNKrKyscP36dezduxfbtm2TvV9cXIyDBw9qxKaEhAQcPXpUI7obSmOcM9m1axdKSkoAQO2OxMvL\nC4WFhbLjNWvWwNPTE9evX28yjgRA01waro2kpCSyt7eX7asoLy+nnJwcjdmjzoxhXNIYinC9Sm5u\nrkZ1V0ZlHz58mGxtbSk+Pl5j9rDitXImRETPnj0je3t72r9/v6ZNkeOPP/7QSAW6psrTp0/pzJkz\nmjZDjuPHj5ONjQ1FR0dr2hQmvBZzJq8SGxuLUaNG4YcffsCyZcs0bQ6A/2UXawoTcdpAaWkpjIyM\ntOZ+/vnnn1i3bh2uXr2Knj17atocJrwWcyav0qVLFwQFBWHNmjVYv369ps0BUOFEKr/4iYmJOHTo\nkGYNqgNtnTNZt24dRCIRAMDY2FhrHMmePXvg6emJoKCgJutIALxecyavkpSURI6OjrRx40ZNm1In\n0dHRtWbH1wTaMmciEom0fmi4detWcnBwaJJzJK/yWvZMKunQoQOCg4Nx8OBBfPnll1odqZqUlKRp\nE2RoS5zJjRs3kJeXp2kzaoSI8OOPP2Lr1q24efMmnJ2dNW0SezTtzZQhJSWFRowYQd26daPu3bvT\ntm3biIho5cqV5OrqSm5ubjRt2jTZZqvExEQyNjamXr16Ua9evf6vvfuNaep64wD+ZYLKhrItslpg\nDAIqLUoLhVYSGaKwOBmEgRHZIJsBSeayRBc3zJYte0HmsjeLxrEsJsSEsQlzE0qHSXUGhspAChnj\nj1gEU6EwyHT8q0Jbnt8L4s06/ClIoS08n1ece2/bc8vl4Zx7zzkPvfPOO8J7qdVqCg8Pp9zcXPrr\nr79IpVJRcnKyw1NnzMbnn3/uVC2VxaLX66m4uNjR1Xis8fFx2rdvH0VHR1NfXx/du3ePlEolyWQy\nkkgkdPToUSIiKisrI6lUSk899RTpdDrh9bO9bp2NSwWT/v5+am5uJqLpxFgbN26k9vZ20mq1wuI8\n+fn5lJ+fT0TTv5TNmzc/9L0yMjLIarXSJ598Qq2trXT//n3KycmhLVu2UHd39+KckB3cvXuXzp8/\nv6ifuVjdHIvFQjU1NULZFRZgMhgMFBYWRm+++SaZTCZh+4PcO2azmVQqFdXW1lJHRwd1dnbS9u3b\nZwST2V63zsSlujnr16+HXC4HMJ0HWCKRwGg0IjExUZh3o1Kp0Nvb+9j3mpqawsTEBEwmE1auXIlV\nq1bh1KlTOHDgAKKjo6HVahf0XOxl7dq1CAwMFMoDAwMuPWS/u7sbFotFKP/7JqqzL/1YV1cHlUqF\n7OxsFBcX26RxfZB7Z3JyElarFc8//zxCQ0PnnJv6v9etU3F0NHtSPT09FBAQMKNb8tprr1FJSYlw\nzDPPPENyuZzi4uKotrZWOO7ChQukUCjoww8/nPHeFy9epBdeeIEKCwsX9iQWwJ07d+j3338Xyj09\nPWQwGBxYo0fr7u62WfawrKzssctkOqOioiLy8fGhX3755aH7rVYryWQy8vLyog8++MBm38NaJk9y\n3TqaSwaT0dFRUigUM9JGFhQUUFpamlCemJgQRj7qdDp68cUXZ71eZ1dXF0mlUsrLy1v0fCn2ZDQa\nbZJG/fbbbw5LK0pEdOXKFbp165ZQ1mq1T7ygkDMwm82Um5tLQUFBs1rY6J9//iGVSmXTVfxvMJnP\ndetIzt1ufAiz2Yz09HRkZWUhNTVV2H769GlUVVXZzHdZuXKlsGJ8ZGQkgoODodfrZ/U5wcHBqKur\nQ29vL+Li4jA0NGTfE1kkYrHYJo2oUqmEn5+fUK6qqkJ9fb1QbmhosEkzOj4+btPtAGzHmVgsFmFx\nIWB6Yal/P3k6e/YsWltbbeojEomEcmJi4iOn6Tuzu3fvYvfu3TAYDNDpdLNa2Mjb2xtJSUlobGz8\nv8fM57p1KEdHs7mYmpqi7OzsGSt3nz9/nqRS6YwE4kNDQ8L8l5s3b5Kfn9+cs9ZbrVb66KOPKDAw\n0Ka5uVT19/fbzFfSarX0xx9/COXy8nL69ttvhbJGo7Fp6fT09Mz5O3ZFly5dopdeeonef/99MpvN\njzx2aGhI+E5MJhPFxsba5Hjavn07NTY22hw/3+vWEVwqmNTW1pKbmxvJZDLhsVlVVRWFhIRQQEDA\njEdpZ8+epbCwMJLL5RQZGUkajeaJP7u8vJxEIhFlZmYKd+bZ8nPv3j3Kz88nHx+fWaftbGlpoYiI\nCJLJZLRlyxb68ssviYjo559/Jn9/f1q9ejWJRCLatWsXEdn3ul1My3JuzpP6+++/8d5776GxsRFF\nRUXYtm2bo6vEFtHVq1eRm5sLiUSCwsJCm+4ag2t1c5zFuXPnSCwWU1ZW1rJspTjLcPrF8qA1sm7d\nOjpz5ozLpTZdLC53A9YZpKam4s8//4TZbIZcLsfly5cdXSW2QBoaGhAZGQm9Xo/W1lZkZGQ4zQRC\nZ8PdnHkqLy/HwYMHkZSUhOPHjwuDk5hru3//Pj799FMUFRXh66+/xt69ezmIPAa3TObpQStldHQU\n4eHh0Gg0c8oIx5wLEUGr1UKhUODmzZtoa2vj1shsObaXtbRoNBqSSqUUExNDly5dcnR1FsxSvWdS\nX19PCoWCgoOD6aeffuJ7I3PELRM7SkpKQktLC/Ly8pCdnY2UlBSbAVvMOXV2dmLPnj1IS0tDXl4e\nrl+/jrS0NG6NzBEHEztbsWIF3n77bXR1dSE+Ph47d+5EWlqaU61HMl/Osp7JfPX29iI3Nxdbt25F\nVFQUbty4gby8PNdMGu4EOJgskNWrV+Pw4cO4ceMGpFIpFAoFDh8+7LLD8peSO3fu4MiRI5DJZFi3\nbh26u7tx9OhRvnk+TxxMFpi3tzcKCgrQ3t4Os9mMTZs24a233nLphObOugbs4wwODqKgoAAhISEY\nHh5GS0sLvvjiC2EeDJsfDiaLRCQS4eTJk7h27RpWrVoFqVSKjIwM1NTU8NOfBUREqKmpQVJSEjZu\n3Iju7m7U1dXh1KlTNhMe2fzxOBMHGR4eRnFxMU6cOAEiwqFDh5CdnY21a9c6umpLwtjYGL7//nsU\nFhZibGwMBw8exP79+7kVsoA4mDgYEaG6uhqFhYX49ddfkZCQgI8//hgymczRVXNJHR0d+Oabb3D6\n9Gns2LED7777Lnbu3On0q7QtBfwNO5ibmxvi4+Px448/orW1FVKpFLt378bLL7+MkpISDA8PO7qK\nMzjbPZPR0VGcPHkS27Ztw44dO+Dt7Y22tjaUl5fbLOnJFha3TJyQ2WyGWq1GUVERqqurERMTg5SU\nFCQnJyMoKMjR1UN1dbXDHw8bDAZUVFRAo9Hg6tWr2Lp1K3JycpCWluZ8a6MuExxMnNz4+DguXLgA\ntVqNyspKeHt7Y9++fUhJSUFUVNSy+a9LRGhqaoJarYZarYbBYMCrr76K119/Ha+88grWrFnj6Cou\nexxMXIjVakV9fT0qKyuhVqsxODiI2NhY7N+/H7GxsXj22WcdXUW7GhkZweXLl6FWq1FRUQFPT0+k\np6cjJSUFMTExPLjMyXAwcWFdXV1Qq9XQaDRoaGjAc889B5lMhri4OCgUCkRGRi5IgFmIbs7IyAia\nmpqg0+mg0+lw7do19Pb2QqlUIjk5GcnJydi0aZNdP5PZFweTJcJqteL69evCH6NOp0NTUxNEIhGU\nSiUUCgXkcjmio6Pn/Xh0vsFkeHgYzc3NqKqqgsFgQFNTE/r6+hAaGoqYmBhERUVBoVBAIpFw68OF\ncDBZwqxWKzo7O9HY2AidToe6ujp0dHQAmF4l3tPTEyEhIQgMDIRYLIaPjw8CAgIgFovh6+uLNWvW\nzGmy2+joKIxGI/r7+2E0GtHR0YHx8XEMDAygv78fer0eIyMjsFqtkMlkiIiIQHR0NAeOJYKDyTJD\nRBgZGRH+4Pv7+4WfDQYDBgcHMTAwAKPRCLPZDE9PT7i7u8Pd3R1TU1N4+umn4ebmBovFApPJBGA6\naE1MTAAA/Pz84OvrC19fX4hEIvj7+0MsFgsBSiwWw9vbm2fkLkEcTNj/ZTKZMDk5CYvFArPZDIvF\nAovFAiKCh4eHEGQ8PDzg4eEhBBq2PHEwYYzZxfIYpMAYW3AcTBhjdsHBhDFmFxxMGGN2wcGEMWYX\nHEwYAOD27duIj49HWFgYNm/ejBMnTgAAMjIyEBERgYiICAQFBSEiIkJ4zbFjx7BhwwaEhoZCq9UK\n2ysrKyGTyXDgwIFFPw/mODzkkAEAPDw88NVXX0Eul2NsbAwKhQKJiYkoLS0Vjjly5Igw16e9vR2l\npaVob29HX18fEhISoNfr4ebmhpKSEjQ3N+Ozzz5DW1sbwsLCHHVabBFxy4QBANavXw+5XA4A8PLy\ngkQigdFoFPYTEcrKypCZmQkAqKioQGZmJjw8PBAYGIiQkBDU19cDAKampjAxMQGTycRriywjHEzY\nDLdu3UJzczNUKpWwrba2FiKRCMHBwQAAo9EIf39/Yb+/vz/6+voAAHl5eYiNjcWKFSuwYcOGxa08\ncxju5jAbY2Nj2LNnD44fPw4vLy9h+w8//IA33njjka99MJQ+ISEBjY2NC1pP5nw4mDCB2WxGeno6\nsrKykJqaKmy3WCw4d+4cmpqahG1+fn64ffu2UO7t7eXUEcscd3MYgOl7Ijk5OZBKpTh06JDNvosX\nL0IikcDX11fYlpKSgjNnzmBychI9PT3Q6/VQKpWLXW3mRLhlwgAAV65cwXfffYfw8HDh8e+xY8ew\na9culJaWCjdeH5BKpdi7dy+kUinc3d1RWFjIM4aXOZ41zBizC+7mMMbsgoMJY8wuOJgwxuyCgwlj\nzC44mDDG7IKDCWPMLjiYMMbs4n+vNvwywIT7aAAAAABJRU5ErkJggg==\n", + "text": [ + "<matplotlib.figure.Figure at 0x7f9dca6680d0>" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 15-12.1, Page number: 541</h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "%pylab inline\n", + "from math import pi,acos,sqrt,log10,atan\n", + "import cmath\n", + "import numpy as np\n", + "from pylab import *\n", + "\n", + "#Variable declaration\n", + "f = 60e6 #Frequency(Hz)\n", + "dep = 20 #Depth of antenna location (m)\n", + "sigma = 1.33e-2 #Conductivity (mho per m)\n", + "eps0 = 8.85e-12 #Air Permittivity (F/m)\n", + "epr1 = 80 #Real part of relative permittivity (unitless)\n", + "alphat = 10 #Elevation angle (degrees)\n", + "cl = 1 #Circumference (lambda)\n", + "pitch = 12.5 #Pitch angle (degrees)\n", + "c = 3e8 #Speed of light (m/s)\n", + "\n", + "dir_gb = 3 #Directivity of George Brown turnstile (unitless)\n", + "Aer_gb = 6 #Effective aperture of George Brown turnstile (unitless)\n", + "r = 1e3 #Distance between transmitter and receiver (m)\n", + "Pt = 100 #Transmitted power (W)\n", + "\n", + "\n", + "\n", + "#Calculations\n", + "epr11 = sigma/(eps0*2*pi*f) #Loss term of relative permittivity (unitless)\n", + "epr = epr1 + 1j*epr11 #Relative permittivity (unitless)\n", + "alphac = acos(sqrt(1/epr1)) #Critical angle (degrees)\n", + "alpha = acos(cos(radians(alphat))/sqrt(epr1)) #Angle of incidence (degrees)\n", + "\n", + "n1=12 #Number of turns\n", + "rad = cl/(2*pi) #Radius of loop (lambda)\n", + "sl = tan(radians(12.5))\n", + "hpbw1 = 52/(cl*sqrt(n1*sl)) #Half power beamwidth for 12 turns(degrees)\n", + "dir1 = 12*(cl**2)*n1*sl #Directivity for 12 turns (unitless)\n", + "n2 = n1*2 #Number of turns\n", + "hpbw2 = 52/(cl*sqrt(n2*sl)) #Half power beamwidth for 24 turns(degrees)\n", + "dir2 = 12*(cl**2)*n2*sl #Directivity for 24 turns (unitless)\n", + "num = 20 #Number of turns chosen\n", + "\n", + "p_perp = [(sin(theta)-cmath.sqrt(epr - cos(theta)**2))/(sin(theta)+cmath.sqrt(epr - cos(theta)**2)) \\\n", + " for theta in arange(0,pi,pi/180)]\n", + " #Reflection coefficient (unitless)\n", + "p_pall = [(epr*sin(theta)-cmath.sqrt(epr - cos(theta)**2))/(epr*sin(theta)+cmath.sqrt(epr - cos(theta)**2)) \\\n", + " for theta in arange(0,pi,pi/180)]\n", + " #Reflection coefficient (unitless)\n", + "\n", + "Sr = 0.5*(np.absolute(p_perp)**2 + np.absolute(p_pall)**2) #Relative power density reflected (unitless)\n", + "St = 1 - Sr #Relative power density transmitted (unitless)\n", + " \n", + "theta = arange(0,pi,pi/180)\n", + "subplot(1,2,1)\n", + "plot(theta,St)\n", + "xlim([0,pi/2])\n", + "title(\"Relative power vs Elevation angle\")\n", + "\n", + "\n", + "subplot(1,2,2, polar=True)\n", + "plot(theta,St)\n", + "title(\"Pattern of transmission\")\n", + "\n", + "wave_lt = c/f #Wavelength (m)\n", + "diam = wave_lt/(sqrt(epr1)*pi) #Submerged helix diameter (m)\n", + "att_cons = (pi*epr11)/(wave_lt*sqrt(epr1)) #Attenuation constant for water (Np/m)\n", + "att_d = 20*log10(exp(-att_cons*dep)) #Attenuation in the water path (dB)\n", + "Dir = 12*(cl**2)*num*sl #Directivity for 20 turn helix (unitless)\n", + "Ae = Dir*(wave_lt**2)/(4*pi) #Effective aperture (m^2)\n", + "\n", + "Pr = Pt*Ae*dir_gb/((r**2)*(wave_lt**2)) #Received power(W)\n", + "\n", + "St = np.around(St,2)\n", + "loss_inter = 10*log10(St[10]) #Loss at the interface for alpha = 83.68 (dB)\n", + "tot_loss = round(abs(att_d + loss_inter)) #Total loss (dB)\n", + "Pr_act = Pr/(10**(tot_loss/10)) #Net Actual received power (W)\n", + "\n", + "\n", + "#Results\n", + "print \"Half power beamwidth for 12 turns is \", round(hpbw1), \"degrees\"\n", + "print \"Directivity for 12 turns is \", round(dir1,1)\n", + "print \"Half power beamwidth for 24 turns is \", round(hpbw2), \"degrees\"\n", + "print \"Directivity for 24 turns is \", round(dir2,1)\n", + "print \"A helix of \", num, \"turns is chosen for reasonable compromise\"\n", + "print \"The signal level at the distance of 1km is\", round(Pr_act,10), \"W\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Half power beamwidth for 12 turns is 32.0 degrees\n", + "Directivity for 12 turns is 31.9\n", + "Half power beamwidth for 24 turns is 23.0 degrees\n", + "Directivity for 24 turns is 63.8\n", + "A helix of 20 turns is chosen for reasonable compromise\n", + "The signal level at the distance of 1km is 8e-09 W\n" + ] + }, + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEKCAYAAADw2zkCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nDgaMMcYA/B/PBcUPbKxwhwAAAABJRU5ErkJggg==\n", + "text": [ + "<matplotlib.figure.Figure at 0x7fdf86780510>" + ] + } + ], + "prompt_number": 43 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 15-13.1, Page number: 546<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import atan,pi\n", + "\n", + "#Variable declaration\n", + "freq = 3e9 #Frequency (Hz)\n", + "Re_Zc = 14.4e-3 #Real part of intrinsic impedence of copper (ohm)\n", + "Zd = 377 #Intrinsic impedence of air (ohm)\n", + "\n", + "#Calculation\n", + "tau = atan(Re_Zc/Zd)*180/pi #Tilt angle (degrees)\n", + "\n", + "#Result\n", + "print \"The tilt angle is\", round(tau,4), \"degrees\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The tilt angle is 0.0022 degrees\n" + ] + } + ], + "prompt_number": 88 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 15-13.2, Page number: 546<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import atan,pi,sqrt\n", + "\n", + "#Variable declaration\n", + "freq = 3e9 #Frequency (Hz)\n", + "eps_r = 80 #Relative permittivity of water (unitless)\n", + "\n", + "#Calculation\n", + "tau = atan(1/sqrt(eps_r))*180/pi #Forward Tilt angle (degrees)\n", + "\n", + "#Result\n", + "print \"The forward tilt angle is\", round(tau,1), \"degrees\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The forward tilt angle is 6.4 degrees\n" + ] + } + ], + "prompt_number": 89 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 15-13.3, Page number: 550<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import acos,pi\n", + "\n", + "#Variable declaration\n", + "lambda_g = 1.5 #Wavelength in guide (lambda)\n", + "m = -1 #Mode number\n", + "\n", + "\n", + "#Calculation\n", + "phi = acos((1/lambda_g)+m)*180/pi #Forward Tilt angle (degrees)\n", + "\n", + "#Result\n", + "print \"The beam angle is\", round(phi,1), \"degrees\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The beam angle is 109.5 degrees\n" + ] + } + ], + "prompt_number": 90 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 15-14.1, Page number:552<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi, log10, sqrt\n", + "\n", + "#Variable declaration\n", + "freq = 4e9 #Frequency (Hz)\n", + "T_sys = 100 #System Temperature (K)\n", + "S_N = 20 #Signal to Noise ratio (dB)\n", + "bandwidth = 30e6 #Bandwidth (Hz)\n", + "P_trans = 5 #Satellite transponder power (W)\n", + "dia = 2 #Satellite parabolic dish diameter (m)\n", + "sat_spacing = 2 #Spacing between satellites (degrees)\n", + "r = 36000e3 #Downlink distance (m)\n", + "k = 1.38e-23 #Boltzmann's constant (J/K)\n", + "c = 3e8 #Speed of light (m/s)\n", + "\n", + "#Calculation\n", + "wave_lt = c/freq\n", + "s_n = (wave_lt**2)/(16*(pi**2)*(r**2)*k*T_sys*bandwidth) \n", + "s_n = 10*log10(s_n) #Signal to noise ratio for isotropic antennas (dB)\n", + "\n", + "Ae = 0.5*pi*(dia**2)/4 #Effective Aperture (m^2)\n", + "Gs = 4*pi*Ae/(wave_lt**2) \n", + "Gs = 10*log10(Gs) #Antenna Gain (dB)\n", + "\n", + "Ge = 20 - s_n - Gs - 10*log10(P_trans) #Required earth station antenna gain(dB)\n", + "Ae_e = (10**(Ge/10))*(wave_lt**2)/(4*pi) \n", + " #Required earth station effective aperture (m^2)\n", + "Ap = Ae_e*2 #Required Physical aperture (m^2)\n", + "\n", + "De = 2*sqrt(Ap/pi) #Required diameter of earth-station antenna(m)\n", + "hpbw = 65/(De/wave_lt) #Half power beam width (degree)\n", + "bwfn = 145/(De/wave_lt) #Beamwidth between first null (degree)\n", + "\n", + "#Results\n", + "print \"The required parabolic dish diameter of earth station antenna is\"\\\n", + " , round(De,1), \"m\"\n", + "print \"The Half power beamwidth is\", round(hpbw,1), \"degrees\"\n", + "print \"The beamwidth between first null is\", round(bwfn,1), \"degrees\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The required parabolic dish diameter of earth station antenna is 3.1 m\n", + "The Half power beamwidth is 1.6 degrees\n", + "The beamwidth between first null is 3.5 degrees\n" + ] + } + ], + "prompt_number": 93 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 15-20.1, Page number: 568<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import *\n", + "\n", + "#Variable declaration\n", + "Tr = 45 #Satellite receiver temperature (K)\n", + "rcp_gain = 6 #Right circularly polarized antenna gain (dBi)\n", + "rcp_quad_gain = 3 #RCP gain of quadrifilar helix antenna (dBi)\n", + "bandwidth = 9.6e3 #Bandwidth (Hz)\n", + "snr = 10 #Required Signal-to-Noise ratio (dB)\n", + "c = 3e8 #Speed of light (m/s)\n", + "f = 1.65e9 #Frequency (Hz)\n", + "r = 780e3 #Distance to the satellite (m)\n", + "Ta = 300 #Antenna temperature (K)\n", + "k = 1.4e-23 #Boltzmann's constant (J/K)\n", + "theta = 10 #Zenith angle (degree)\n", + "Tr_handheld = 75 #Hand held receiver temperature (K)\n", + "Tsky = 6 #Sky Temperature (K)\n", + "theta_horz = 80 #Zenith angle for horizontal dipole (degree)\n", + "\n", + "#Calculations\n", + "wave_lt = c/f #Wavelength (m)\n", + "Ld = (wave_lt/(4*pi*r))**2 #Spatial loss factor(unitless)\n", + "Ld_db = 10*log10(Ld) #Spatial loss factor(dB)\n", + "\n", + "Tsys_up = Ta + Tr #Satellite system temperature (K)\n", + "N = k*Tsys_up*bandwidth #Noise power(W)\n", + "N_db = 10*log10(N) #Noise power (dB)\n", + "\n", + "E_vert = cos(pi*cos(theta*pi/180)/2)/sin(theta*pi/180)\n", + " #Pattern factor for vertical lambda/2 dipole (unitless)\n", + "E_vert_db = 20*log10(E_vert)\n", + "\n", + "Pt_vert_up = snr - (2.15 + round(E_vert_db,1) - 3) - \\\n", + " rcp_gain + round(N_db) - round(Ld_db)\n", + " #Uplink power for vertical lambda/2 antenna (dB)\n", + "Pt_vert_up = 10**(Pt_vert_up/10) \n", + " #Uplink power for vertical lambda/2 antenna (W)\n", + "\n", + "Ta_down = 0.5*(Ta)+0.5*(Tsky)+3 #Downlink antenna temperature (K)\n", + "Tsys_down = Ta_down + Tr_handheld #System temperature(K)\n", + "N_down = k*Tsys_down*bandwidth #Noise power (W)\n", + "N_down_db = 10*log10(N_down) #Noise power (dB)\n", + "Pt_vert_down = snr -(2.15+ round(E_vert_db,1) - 3) - \\\n", + " rcp_gain + round(N_down_db) - round(Ld_db)\n", + " #Downlink power for vertical lambda/2 antenna (dB)\n", + "Pt_vert_down = 10**(Pt_vert_down/10)\n", + " #Downlink power for vertical lambda/2 antenna (W)\n", + "\n", + "E_horz = cos(pi*cos(theta_horz*pi/180)/2)/sin(theta_horz*pi/180)\n", + " #Pattern factor for horizontal lambda/2 dipole (unitless)\n", + "E_horz_db = round(20*log10(E_horz),1)\n", + "Pt_horz_up = snr -(2.15 + E_horz_db - 3) - \\\n", + " rcp_gain + round(N_db) - round(Ld_db)\n", + " #Uplink power for horizonal lambda/2 dipole (dB)\n", + "Pt_horz_up = 10**(Pt_horz_up/10)\n", + " #Uplink power for horizonal lambda/2 dipole (W)\n", + "\n", + "Pt_horz_down = snr -(2.15 + E_horz_db - 3) - \\\n", + " rcp_gain + round(N_down_db) - round(Ld_db)\n", + " #Downlink power for horizonal lambda/2 dipole (dB)\n", + "Pt_horz_down = 10**(Pt_horz_down/10)\n", + " #Downlink power for horizonal lambda/2 dipole (W)\n", + "\n", + "Pt_quad_up = snr -(rcp_quad_gain + E_horz_db) - \\\n", + " rcp_gain + round(N_db) - round(Ld_db)\n", + " #Uplink power for RCP quadrifilar helix antenna (dB)\n", + "Pt_quad_up = 10**(Pt_quad_up/10)\n", + " #Uplink power for RCP quadrifilar helix antenna (W)\n", + "\n", + "Ta_quad = 0.85*(Tsky) + 0.15*(Ta) #Downlink antenna temperature (K)\n", + "Tsys_quad = Ta_quad + Tr_handheld #System temperature(K)\n", + "N_quad = k*Tsys_quad*bandwidth #Noise power (W)\n", + "N_quad_db = 10*log10(N_quad) #Noise power (dB)\n", + "\n", + "Pt_quad_down = snr -(rcp_quad_gain + E_horz_db) - \\\n", + " rcp_gain + round(N_quad_db) - round(Ld_db)\n", + " #Downlink power for RCP quadrifilar helix antenna (dB)\n", + "Pt_quad_down = 10**(Pt_quad_down/10)\n", + " #Downlink power for RCP quadrifilar helix antenna (W)\n", + "\n", + "#Results\n", + "print \"The Uplink power for vertical lambda/2 dipole is\", round(Pt_vert_up,1),\"W\"\n", + "print \"The Uplink power for horizontal lambda/2 dipole is\", round(Pt_horz_up,3),\"W\"\n", + "print \"The Uplink power for RCP quadrifilar helix antenna is\", round(Pt_quad_up,3),\"W\"\n", + "\n", + "print \"The downlink power for vertical lambda/2 dipole is\", round(Pt_vert_down,1),\"W\"\n", + "print \"The downlink power for horizontal lambda/2 dipole is\", round(Pt_horz_down,3),\"W\"\n", + "print \"The downlink power for RCP quadrifilar helix antenna is\",\\\n", + " round(Pt_quad_down,3),\"W\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Uplink power for vertical lambda/2 dipole is 25.4 W\n", + "The Uplink power for horizontal lambda/2 dipole is 0.507 W\n", + "The Uplink power for RCP quadrifilar helix antenna is 0.209 W\n", + "The downlink power for vertical lambda/2 dipole is 16.0 W\n", + "The downlink power for horizontal lambda/2 dipole is 0.32 W\n", + "The downlink power for RCP quadrifilar helix antenna is 0.066 W\n" + ] + } + ], + "prompt_number": 94 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 15-20.2, Page number: 571<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import *\n", + "\n", + "#Variable declaration\n", + "f = 1.6e9 #Frequency (Hz)\n", + "r = 1400e3 #Height (m)\n", + "r_sep = 3500e3 #Height for 10 degree seperation (m)\n", + "c = 3e8 #Speed of light(m/s)\n", + "Ta = 300 #Satellite antenna temperature (K)\n", + "Tr = 45 #Satellite receiver temperature (K)\n", + "k = 1.3e-23 #Boltzmann's constant (J/K)\n", + "bandwidth = 9.6e3 #Bandwidth (Hz)\n", + "snr = 6 #Signal to noise ratio (dB)\n", + "rcp_gain = 3 #Helix gain(dB)\n", + "beam_angle = 25 #RCP spot beam (degree)\n", + "Tsky = 6 #Sky Temperature (K)\n", + "Tr_handheld = 75 #Hand held receiver temperature (K)\n", + "\n", + "\n", + "#Calculations\n", + "wave_lt = c/f #Wavelength (m)\n", + "Ld = (wave_lt/(4*pi*r))**2 \n", + "Ld = 10*log10(Ld) #Propagation loss factor (dB)\n", + "sat_gain = 40000/(beam_angle**2)\n", + "sat_gain = 10*log10(sat_gain) #Satellite gain (dB)\n", + "\n", + "Tsys = Ta+Tr #System temperature (K)\n", + "N = k*Tsys*bandwidth #Noise power (W)\n", + "N_db = 10*log10(N) #Noise power (dB)\n", + "\n", + "Pt_up = snr - (rcp_gain) - (sat_gain) + N_db - Ld #Uplink power (dB)\n", + "Pt_up = 10**(Pt_up/10) #Uplink power (W)\n", + "\n", + "Ta_quad = 0.85*(Tsky) + 0.15*(Ta) #Downlink antenna temperature (K)\n", + "Tsys_quad = Ta_quad + Tr_handheld #System temperature(K)\n", + "N_quad = k*Tsys_quad*bandwidth #Noise power (W)\n", + "N_quad_db = 10*log10(N_quad) #Noise power (dB)\n", + "\n", + "Pt_down = snr - (rcp_gain) - (sat_gain) + round(N_quad_db) - round(Ld) \n", + " #Downlink power (dB)\n", + "Pt_down = 10**(Pt_down/10) #Downlink power (W)\n", + "\n", + "Ld_sep = (wave_lt/(4*pi*r_sep))**2 \n", + "Ld_sep = 10*log10(Ld_sep) #Propagation loss factor(dB)\n", + "\n", + "Pt_sep = snr - (rcp_gain) - sat_gain + ceil(N_db) - round(Ld_sep)\n", + " #Uplink power (dB)\n", + "Pt_sep = 10**(Pt_sep/10) #Uplink power (W)\n", + "\n", + "#Results\n", + "print \"The Satellite gain is\", round(sat_gain,1),\"dB\"\n", + "print \"The Uplink power required is\", round(Pt_up,3),\"W\"\n", + "print \"The Downlink power required is\",round(Pt_down,4),\"W\"\n", + "print \"The uplink power required for 10 deg. from horizon is\",round(Pt_sep,3),\"W\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Satellite gain is 18.1 dB\n", + "The Uplink power required is 0.012 W\n", + "The Downlink power required is 0.0039 W\n", + "The uplink power required for 10 deg. from horizon is 0.078 W\n" + ] + } + ], + "prompt_number": 97 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 15-20.3, Page number: 572<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import *\n", + "\n", + "#Variable declaration\n", + "f = 30e9 #Frequency (Hz)\n", + "Tr = 300 #Receiver temperature (K)\n", + "Ta = 275 #Satellite antenna temperature (K)\n", + "h = 1400e3 #Height (m)\n", + "bw = 9.6e3 #Bandwidth per channel (Hz)\n", + "rcp_gain = 10 #RCP satellite gain (dBi)\n", + "rain_att = 10 #Rain attenuation (dB)\n", + "k = 1.4e-23 #Boltzmann's constant (J/K)\n", + "snr = 10 #Required SNR (dB)\n", + "ap_eff = 0.7 #Aperture efficiency (unitless)\n", + "Ta_2 = 10 #Dish antenna temperature (K)\n", + "\n", + "#Calculations\n", + "wave_lt = c/f #Wavelength (m)\n", + "Ld = (wave_lt/(4*pi*r))**2 #Spatial loss factor(unitless)\n", + "Ld_db = 10*log10(Ld) #Spatial loss factor(dB)\n", + "Tsys = Ta+Tr #System temperature (K)\n", + "\n", + "N = k*Tsys*bw #Propagation loss due to rain (W)\n", + "N = 10*log10(N) #Propagation loss due to rain (dB)\n", + "\n", + "Dr = -rcp_gain + snr - Ld_db + N + rain_att #Antenna gain (dB)\n", + "Dr = 10**(Dr/10) #Antenna gain (unitless)\n", + "\n", + "Dr_req = Dr/ap_eff #Required antenna gain (unitless)\n", + "Dr_req_db = 10*log10(Dr_req) #Required antenna gain (dB)\n", + "\n", + "dish_dia = 2*wave_lt*sqrt(Dr_req/28) #Required diameter of dish (m)\n", + "\n", + "hpbw = sqrt(40000/Dr_req) #Half power beam width (degrees)\n", + "\n", + "Tsys2 = Ta_2 + Tr #System temperature(K)\n", + "N2 = k*Tsys2*bw #Propagation loss due to rain(W)\n", + "N2 = 10*log10(N2) #Propagation loss due to rain(dB)\n", + "\n", + "Pt_db = snr - Dr_req_db - rcp_gain + N2 - Ld_db + rain_att \n", + " #Transmitted power (dB)\n", + "Pt = 10**(Pt_db/10)\n", + "\n", + "#Results\n", + "print \"The uplink antenna gain required is\", round(Dr_req_db,0), \"dB\"\n", + "print \"The required dish size\", round(dish_dia,3), \"m\"\n", + "print \"The HPBW is\", round(hpbw,1), \"degrees\"\n", + "print \"The downlink satellite power required is\", round(Pt,3), \"W\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The uplink antenna gain required is 35.0 dB\n", + "The required dish size 0.221 m\n", + "The HPBW is 3.4 degrees\n", + "The downlink satellite power required is 0.377 W\n" + ] + } + ], + "prompt_number": 102 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 15-21.1, Page number: 574</h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi\n", + "\n", + "dia = 1000 #diameter of asteroid (m)\n", + "prc = 0.4 #Power reflection coefficient of asteroid (unitless)\n", + "f = 4e9 #Frequency (Hz)\n", + "P = 1e9 #Power (W)\n", + "s = 20e3 #Asteroid speed (m/s)\n", + "ast_dis = 0.4 #Distance of asteroid (AU)\n", + "au = 1.5e11 #Astronomical Unit (m)\n", + "c = 3e8 #Speed of light (m/s)\n", + "k = 1.38e-23 #Boltzmann's constant (m^2 kg s^-2 K^-1)\n", + "Tsys = 10 #System temperature (K)\n", + "B = 1e6 #Bandwidth (Hz)\n", + "snr = 10 #Signal to noise ratio (dB)\n", + "eap = 0.75 #Aperture efficiency (unitless)\n", + "\n", + "sigma = prc*pi*s**2 #Radar cross section (m^2)\n", + "ast_dm = au*ast_dis #Astroid distance (m)\n", + "lmda = c/f #Wavelength(m)\n", + "\n", + "d4 = (64*(lmda**2)*(ast_dm**4)*k*Tsys*B*snr)/((eap**2)*pi*(sigma)*P)\n", + "d = d4**(0.25) #Diameter of dish (m)\n", + "\n", + "delf = 2*s/lmda #Doppler shift (Hz)\n", + "delt = 2*(ast_dm)/c #Time delay (s)\n", + "\n", + "timp = ast_dm/s #Time before impact (s) \n", + "\n", + "\n", + "#Result\n", + "print \"The diameter of the dish is\", round(d), \"m\"\n", + "print \"The doppler shift is %.1f Hz\" % delf\n", + "print \"The time delay for the radar signal is\", delt, \"s\"\n", + "print \"The time before impact is\", timp, \"s\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The diameter of the dish is 292.0 m\n", + "The doppler shift is 533333.3 Hz\n", + "The time delay for the radar signal is 400.0 s\n", + "The time before impact is 3000000.0 s\n" + ] + } + ], + "prompt_number": 153 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 15-26.1, Page number: 584<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import sqrt\n", + "\n", + "#Variable declaration\n", + "t1 = 0.3e-9 #Echo time off the top of pavement (s)\n", + "t2 = 2.4e-9 #Echo time off bottom of pavement (s)\n", + "t3 = 14.4e-9 #Echo time off bottom of water pocket (s)\n", + "er_1 = 4 #Relative permittivity of pavement (unitless)\n", + "er_2 = 81 #Relative permittivity of water pocket (unitless)\n", + "c = 3e8 #Speed of light (m/s)\n", + "\n", + "#Calculations\n", + "d1 = (t2-t1)*c/(2*sqrt(er_1))\n", + "d2 = (t3-t2)*c/(2*sqrt(er_2))\n", + "\n", + "#Result\n", + "print \"The thickness of pavement is\", round(d1,2),\"m\"\n", + "print \"The thickness of water pocket is\", round(d2,2), \"m\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The thickness of pavement is 0.16 m\n", + "The thickness of water pocket is 0.2 m\n" + ] + } + ], + "prompt_number": 104 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter16.ipynb b/Antennas_and_Wave_Propagation/chapter16.ipynb new file mode 100644 index 00000000..00fc2d2e --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter16.ipynb @@ -0,0 +1,101 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 16: Practical Design Considerations of Large Aperture Antennas<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 16-2.1, Page number: 608<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import cos, pi, log10\n", + "\n", + "#Variable declaration\n", + "delta = 1/20.0 #rms deviation (lambda)\n", + "\n", + "#Calculations\n", + "del_phi = 4*pi*delta*180/pi #Phase error (degrees)\n", + "kg = cos(del_phi*pi/180)**2 #Gain-loss (unitless)\n", + "kg = 10*log10(kg) #Gain-loss (dB)\n", + "\n", + "#Result\n", + "print \"The gain reduction is\", round(abs(kg),1), \"dB\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " The gain reduction is 1.8 dB\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 16-2.2, Page number: 609<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import tan,pi, log10\n", + "\n", + "#Variable declaration\n", + "del_phi = 36.0 #rms phase error (degrees)\n", + "n_irr = 100.0 #Number of irregularities\n", + "\n", + "#Calculations\n", + "max_side = tan(del_phi*pi/180)**2\n", + "max_side = -10*log10(max_side)\n", + " #Maximum side-lobe level (dB)\n", + "ran_side = (1/n_irr)*tan(del_phi*pi/180)**2\n", + "ran_side = -10*log10(ran_side)\n", + " #Random side-lobe level (dB)\n", + "\n", + "#Result\n", + "print \"The maximum side lobe level from main lobe is\", round(max_side,1),\"dB\"\n", + "print \"The random side lobe level from main lobe is\", round(ran_side,1),\"dB\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The maximum side lobe level from main lobe is 2.8 dB\n", + "The random side lobe level from main lobe is 22.8 dB\n" + ] + } + ], + "prompt_number": 4 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter17.ipynb b/Antennas_and_Wave_Propagation/chapter17.ipynb new file mode 100644 index 00000000..e9d63ef2 --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter17.ipynb @@ -0,0 +1,323 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 17: Antenna Temperature, Remote Sensing and Radar Cross Section<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 17-1.1, Page number: 623<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi\n", + "\n", + "#Variable declaration\n", + "Ta = 0.24 #Antenna temperature (K)\n", + "ang = 0.005 #Subtended angle (degrees)\n", + "hpbw = 0.116 #Antenna half power beamwidth (degrees)\n", + "\n", + "#Calculations\n", + "Ts = Ta*(hpbw**2)/(pi*(ang**2/4))\n", + "\n", + "#Result\n", + "print \"The averate temperature of the surface is\", round(Ts), \"K\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The averate temperature of the surface is 164.0 K\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 17-1.2, Page number: 625<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi, sqrt\n", + "\n", + "#Variable declaration\n", + "eff_aper = 500 #Antenna effective aperture (m^2)\n", + "wave_lt = 20e-2 #Wavelength (m)\n", + "Tsky = 10.0 #sky temperature (K)\n", + "Tgnd = 300.0 #Ground temperature (K)\n", + "beam_eff = 0.7 #Beam efficiency (unitless)\n", + "aper_eff = 0.5 #Aperture efficiency (unitless)\n", + "\n", + "#Calculations\n", + "phy_aper = aper_eff/eff_aper #Physical aperture (m^2)\n", + "diam = 2*sqrt(phy_aper/pi) #Antenna diameter (m)\n", + "diam_l = diam/wave_lt #Antenna diameter (lambda)\n", + "\n", + "ta_sky = Tsky*beam_eff #Sky contribution to antenna temp. (K)\n", + "ta_side = 0.5*Tsky*(1-beam_eff) #Side-lobe contribution to antenna temp. (K)\n", + "ta_back = 0.5*Tgnd*(1-beam_eff) #Back-lobe contribution to antenna temp. (K)\n", + "\n", + "Ta = ta_sky + ta_side + ta_back\n", + "\n", + "#Result\n", + "print \"The total antenna temperature is\", Ta, \"K\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The total antenna temperature is 53.5 K\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 17-2.1, Page number: 629<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Tn = 50.0 #Noise temperature (K)\n", + "Tphy = 300.0 #Physical temperature (K)\n", + "Eff = 0.99 #Efficiency (unitless)\n", + "Tn_stg = 80.0 #Noise temperature of first 3 stages (K)\n", + "gain_db = 13.0 #Gain (dB)\n", + "Tphy_tr = 300 #Transmission line physical temperature (K)\n", + "Eff_tr = 0.9 #Transmission line efficiency (unitless)\n", + "\n", + "#Calculations\n", + "gain = 10**(gain_db/10)\n", + "T_r = Tn_stg + Tn_stg/(gain) + Tn_stg/(gain**2)\n", + " #Receiver noise temperature (K)\n", + "Tsys = Tn + Tphy*(1/Eff - 1) + Tphy_tr*(1/Eff_tr - 1) + (1/Eff_tr)*T_r\n", + " #System temperature (K)\n", + "\n", + "#Result\n", + "print \"The system temperature is\", round(Tsys), \"K\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The system temperature is 180.0 K\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 17-2.2, Page number: 630<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import sqrt\n", + "\n", + "#Variable declaration\n", + "phy_aper = 2208 #Physical aperture (m^2)\n", + "f = 1415e6 #Frequency (Hz)\n", + "aper_eff = 0.54 #Aperture efficiency (unitless)\n", + "Tsys = 50 #System temperature (K)\n", + "bw = 100e6 #RF Bandwidth (Hz)\n", + "t_const = 10 #Output time constant (s)\n", + "sys_const = 2.2 #System constant (unitless)\n", + "k = 1.38e-23 #Boltzmann's constant (J/K)\n", + "\n", + "#Calculations\n", + "Tmin = sys_const*Tsys/(sqrt(bw*t_const)) #Minimum detectable temperature(K)\n", + "eff_aper = aper_eff*phy_aper #Effective aperture (m^2)\n", + "Smin = 2*k*Tmin/eff_aper #Minimum detectable flux density (W/m^2/Hz)\n", + "\n", + "#Result\n", + "print \"The minimum detectable flux density is %.1e W/m^2/Hz\" % Smin" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The minimum detectable flux density is 8.1e-29 W/m^2/Hz\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 17-3.1, Page number: 631<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi, log10\n", + "\n", + "#Variable declaration\n", + "k = 1.38e-23 #Boltzmann's constant (J/K)\n", + "trans_pow = 5 #Transponder power (W)\n", + "r = 36000e3 #Distance (m)\n", + "wave_lt = 7.5e-2 #Wavelength (m)\n", + "ant_gain = 30 #Antenna gain (dB)\n", + "earth_ant = 38 #Earth station antenna gain (dB)\n", + "Tsys = 100 #Earth station receiver system temperature (K)\n", + "bw = 30e6 #Bandwidth (Hz)\n", + "\n", + "#Calculations\n", + "s_n = wave_lt**2/(16*(pi**2)*(r**2)*k*Tsys*bw)\n", + "s_n = 10*log10(s_n) #Signal to Noise ratio (dB)\n", + "\n", + "trans_pow_db = 10*log10(trans_pow) #Transponder power (dB)\n", + "erp = ant_gain + trans_pow_db #Effective radiated power (dB)\n", + "\n", + "s_n_downlink = erp + earth_ant + s_n #Signal to Noise ratio downlink(dB)\n", + "\n", + "#Result\n", + "print \"The earth station S/N ratio is\", round(s_n_downlink,1), \"dB\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The earth station S/N ratio is 13.2 dB\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 17-4.1, Page number: 634<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import exp\n", + "\n", + "#Variable declaration\n", + "tf = 0.693 #Absorption co-efficient (unitless)\n", + "Te = 305 #Earth temperature (K)\n", + "Ta = 300 #Satellite antenna temperature (K)\n", + "\n", + "#Calculations\n", + "Tf = (Ta - Te*exp(-tf))/(1-exp(-tf))\n", + "\n", + "#Result\n", + "print \"The forest temperature is\", round(Tf), \"K\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The forest temperature is 295.0 K\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 17-5.1, Page number: 639<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "f = 10e9 #Frequency (Hz)\n", + "wind_speed = 350 #Wind speed (km/h)\n", + "c = 3e8 #Speed of light (m/s)\n", + "vr = 1e3 #Differential velocity (m/h)\n", + "\n", + "#Calculations\n", + "wave_lt = c/f #Wavelength (m)\n", + "freq_shift = 2*(wind_speed*1000/3600)/wave_lt \n", + " #Doppler Frequency shift (Hz)\n", + "T = 1/(2*freq_shift) #Pulse repetition interval (s)\n", + "prf = 1/T #Pulse repetition frequency (Hz)\n", + "\n", + "fmin = 2*(vr/3600)/wave_lt #Frequency resolution (Hz)\n", + "N = 1/(round(fmin,1)*T) #Number of pulses \n", + "\n", + "#Result\n", + "print \"The minimum pulse repetition frequency is\", round(prf,-3), \"Hz\"\n", + "print \"The number of pulses to be sampled is\", round(N)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The minimum pulse repetition frequency is 13000.0 Hz\n", + "The number of pulses to be sampled is 699.0\n" + ] + } + ], + "prompt_number": 14 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter19.ipynb b/Antennas_and_Wave_Propagation/chapter19.ipynb new file mode 100644 index 00000000..e7875d72 --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter19.ipynb @@ -0,0 +1,136 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 19: The Fourier Transform Relation between Aperture Distribution and Far-field Pattern<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 19-8.1, Page number: 690<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import sin, pi\n", + "\n", + "#Variable declaration\n", + "gal_ext = 400000 #Extent of galaxy (light-years)\n", + "alpha = 0.032 #Extent of galaxy (degrees)\n", + "f = 5e9 #Frequency (Hz)\n", + "a = 36e3 #Maximum VLA Spacing (m)\n", + "c = 3e8 #Speed of light (m/s)\n", + "wid = 0.03 #Width of image (degrees)\n", + "hei = 0.008 #Height of image (degrees)\n", + "flux_den = 2.5e-23 #Average flux density (W/m^2)\n", + "bw = 1e9 #Bandwidth (Hz)\n", + "\n", + "#Calculations\n", + "dist = gal_ext/sin(alpha*pi/180) #Distance to the galaxy (light-years)\n", + "dist_m = dist*(365*24*3600*c)\n", + "\n", + "wave_lt = c/f #Wavelength (m)\n", + "a_lambda = a/wave_lt #Spacing in wavelength (unitless)\n", + "pix_size = 51/a_lambda #Resolution or Pixel size (degrees)\n", + "pix_size_arc = pix_size*3600 #Pixel size (arc seconds)\n", + "\n", + "area = wid*hei #Area of image (square degrees)\n", + "area_arc = area*(3600**2) #Area of image (arc seconds)\n", + "num_pix = area_arc/pix_size_arc**2 #Number of pixels\n", + "\n", + "rad_pow = flux_den*4*pi*(dist_m**2)*bw\n", + "\n", + "#Result\n", + "print \"The distance to the galaxy is\", round(dist,-8), \"light years\"\n", + "print \"The resolution or pixel size is\", round(pix_size_arc,2), \"arc seconds\"\n", + "print \"The number of pixels is\", round(num_pix)\n", + "print \"The radio power of the galaxy is %.1e W\" % rad_pow" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The distance to the galaxy is 700000000.0 light years\n", + "The resolution or pixel size is 0.31 arc seconds\n", + "The number of pixels is 33218.0\n", + "The radio power of the galaxy is 1.4e+37 W\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 19-8.2, Page number:691<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi, log10\n", + "\n", + "#Variable declaration\n", + "f = 10e9 #Frequency (Hz)\n", + "c = 3e8 #Speed of light (m/s)\n", + "dia = 100 #Dish diameter (m)\n", + "aper_eff = 0.725 #Aperture efficiency (unitless)\n", + "\n", + "#Calculation\n", + "wave_lt = c/f #Wavelength (m)\n", + "hpbw = 66/(dia/wave_lt) #Half power beam width (degrees)\n", + "\n", + "gain = 41000/(hpbw**2) #Gain from beamwidth (unitless)\n", + "gain_db = 10*log10(gain) #Gain from beamwidth (dBi)\n", + "\n", + "gain_ap = 4*(pi**2)*(dia/2)**2*(aper_eff)/(wave_lt**2) \n", + " #Gain from effective aperture(unitless)\n", + "gain_ap_db = 10*log10(gain_ap) #Gain from effective aperture (dBi)\n", + "\n", + "side_lobe = -23 #First side lobe level from table (dB)\n", + "\n", + "#Result\n", + "print \"The Half Power Beamwidth is\", round(hpbw,3), \"degrees\"\n", + "print \"The gain from beamwidth is\", round(gain_db), \"dBi\"\n", + "print \"The gain from effective aperture is\", round(gain_ap_db), \"dBi\"\n", + "print \"The first side-lobe level is\", side_lobe,\"dB\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Half Power Beamwidth is 0.02 degrees\n", + "The gain from beamwidth is 80.0 dBi\n", + "The gain from effective aperture is 79.0 dBi\n", + "The first side-lobe level is -23 dB\n" + ] + } + ], + "prompt_number": 19 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter2.ipynb b/Antennas_and_Wave_Propagation/chapter2.ipynb new file mode 100644 index 00000000..84f28496 --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter2.ipynb @@ -0,0 +1,486 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 2: Antenna Basics<h2>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 2-3.1, Page number: 14<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "e_half_power = 1/math.sqrt(2) #E(theta) at half power (relative quantity)\n", + "\n", + "#Calculation\n", + "theta = math.acos(math.sqrt(e_half_power)) # theta (radians)\n", + "hpbw = 2*theta*180/math.pi # Half power beamwidth (degrees)\n", + "\n", + "#Result\n", + "print \"The half power beamwidth is \", round(hpbw), \"degrees\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The half power beamwidth is 66.0 degrees\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 2-3.2, Page number: 14<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "e_half_power = 1/math.sqrt(2) #E(theta) at half power(unitless)\n", + "e_null = 0 #E(theta) = 0 at null points (unitless)\n", + "theta_1 = 0 #theta' (degrees)\n", + "theta = 1 #theta (degrees)\n", + "\n", + "#Calculation\n", + "for x in range(3): #Iterate till theta = i\n", + " theta = 0.5*math.acos(e_half_power/math.cos(theta_1*math.pi/180)) \n", + " #theta(radian)\n", + " theta_1 = theta*180/math.pi #set i = theta for next iteration (degrees)\n", + " \n", + "hpbw = 2*(theta*180/math.pi) #Half-power beamwidth (Degrees)\n", + "theta = 0.5*math.acos(e_null) #theta (radians)\n", + "fnbw = 2*(theta*180/math.pi) #Beamwidth between first null (degrees)\n", + "\n", + "#Result\n", + "print \"The half power beamwidth is\", round(hpbw), \"degrees\"\n", + "print \"The beamwidth between first nulls is \", round(fnbw), \"degrees\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The half power beamwidth is 41.0 degrees\n", + "The beamwidth between first nulls is 90.0 degrees\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 2-4.1, Page number: 17<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import scipy.integrate\n", + "import math\n", + "\n", + "#Variable declaration\n", + "def integrand(x):\n", + " return math.sin(x) #Function sin(theta)\n", + "\n", + "def integrand2(x):\n", + " return 1 #Contant function\n", + "\n", + "#Calculation\n", + "omega = scipy.integrate.quad(integrand, 20*math.pi/180, 40*math.pi/180) \n", + "omega = omega[0]*(180/math.pi) * scipy.integrate.quad(integrand2 ,30 ,70)[0]\n", + "#Integration between the ranges gives solid angle, omega (square degrees)\n", + "\n", + "#Result\n", + "print \"The solid angle, omega is\", round(omega), \"square degrees\" " + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The solid angle, omega is 398.0 square degrees\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 2-4.2, Page number: 17<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import scipy.integrate\n", + "\n", + "#Variable declaration\n", + "def func1(x,y):\n", + " return (math.cos(x)**4)*math.sin(x)*1 #Function for integration\n", + "\n", + "#Calculation\n", + "beam_area = scipy.integrate.dblquad(func1, 0, 2*math.pi, \n", + " lambda x: 0, lambda x: math.pi/2)\n", + "#Beam area (steradians)\n", + "\n", + "#Result\n", + "print \"The beam area of the given pattern is\", round(beam_area[0], 2), \"sr\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The beam area of the given pattern is 1.26 sr\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 2-7.1, Page number: 21<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import scipy.integrate\n", + "from math import pi,sin,cos,log10\n", + "\n", + "#Variable declaration\n", + "n = 10 #Number of isotropic point sources\n", + "dr = pi/2 #Distance(radians)\n", + "hpbw = 40 #Half power beamwidth (degrees)\n", + "def integrand(x,phi):\n", + " E_norm = (sin(pi/20))*(sin((pi/2)*(5*cos(phi)-6))/sin((pi/20)*(5*cos(phi)-6)))\n", + " return (E_norm**2)\n", + "\n", + "#Calculation\n", + "gain = scipy.integrate.dblquad(integrand, 0, 2*pi,\n", + " lambda x: 0, lambda x: pi/2)[0]\n", + "gain = (4*pi)/gain #Gain (unitless)\n", + "gain_db = 10*log10(gain)#Gain (dB)\n", + "gain_hpbw = 40000/(hpbw**2) #Gain from approx. equation (unitless)\n", + "gain_hpbw_db = 10*log10(gain_hpbw) #Gain from approx. equation (dB)\n", + "gain_diff = gain_hpbw_db - gain_db #Difference in gain (dB)\n", + "\n", + "#Result\n", + "print \"The gain G is\", round(gain_db,2),\"dB\"\n", + "print \"The gain from approx. equation is\", round(gain_hpbw_db),\"dB\"\n", + "print \"The difference is\", round(gain_diff,2),\"dB\"\n", + "\n", + "#The solution is incorrect due to the incorrect integration of the normalized power pattern\n", + "#As a result, the difference in gain is slightly higher" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The gain G is 10.01 dB\n", + "The gain from approx. equation is 14.0 dB\n", + "The difference is 3.97 dB\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 2-7.2, Page number: 21<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import scipy.integrate\n", + "\n", + "#Variable declaration\n", + "theta_hp = 90\n", + "phi_hp = 90\n", + "\n", + "def integrand(theta, phi):\n", + " return ((math.sin(theta)**3)*(math.sin(phi)**2))\n", + "\n", + "#Calculation\n", + "direct_exact = 4*math.pi/scipy.integrate.dblquad(integrand, 0, math.pi,\n", + " lambda x: 0, lambda x: math.pi)[0]\n", + " #Exact Directivity(No unit) \n", + "direct_apprx = 41253.0/(theta_hp*phi_hp) #Approximate directivity (No unit)\n", + "db_diff = 10*math.log10(direct_exact/direct_apprx) #Difference (decibels)\n", + "\n", + "#Result\n", + "print \"The exact directivity is\", round(direct_exact, 1)\n", + "print \"The approximate directivity is\", round(direct_apprx,1)\n", + "print \"The decibel difference is \", round(db_diff, 1), \"dB\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The exact directivity is 6.0\n", + "The approximate directivity is 5.1\n", + "The decibel difference is 0.7 dB\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 2-10.1, Page number: 28<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "Z = 120*math.pi #Intrinsic impedence of free space (ohm)\n", + "\n", + "#Calculation\n", + "max_aper = Z/(320*math.pi**2) #Max. effective aperture (lambda^2)\n", + "direct = 4*math.pi*max_aper #directivity (unitless)\n", + "\n", + "#Result\n", + "print \"The maximum effective aperture is\", round(max_aper, 3), \"lambda^2\"\n", + "print \"The direcitivity is\", direct" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The maximum effective aperture is 0.119 lambda^2\n", + "The direcitivity is 1.5\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 2-10.2, Page number: 29<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "R_r = 73 #Radiation resistance (ohm)\n", + "\n", + "#Calculation\n", + "eff_aper = 30/(R_r*math.pi) #Effective aperture (lambda^2)\n", + "directivity = 4*math.pi*eff_aper #Directivity (unitless)\n", + "\n", + "#Result\n", + "print \"The effective aperture is\", round(eff_aper, 2), \"lambda^2\"\n", + "print \"The directivity is\", round(directivity,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The effective aperture is 0.13 lambda^2\n", + "The directivity is 1.64\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 2-11.1, Page number: 31<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "P_t = 15 #Transmitter power (W)\n", + "A_et = 2.5 #Effective aperture of transmitter (meter^2)\n", + "A_er = 0.5 #Effective aperture of receiver (meter^2)\n", + "r = 15e3 #Distance between the antennas (Line of sight) (m)\n", + "freq = 5e9 #Frequency (Hz)\n", + "c = 3e8 #speed of light (m/s)\n", + "\n", + "#Calculation\n", + "wave_len = c/freq #Wavelength (m)\n", + "P_r = (P_t*A_et*A_er)/((r**2)*(wave_len**2)) #received power (W)\n", + "\n", + "#Result\n", + "print \"The power delivered to the receiver is\", round(P_r,6), \"watts\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The power delivered to the receiver is 2.3e-05 watts\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 2-16.1, Page number: 40<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "E1 = 3 #Magnitude of electric field in x direction (V/m)\n", + "E2 = 6 #Magnitude of electric field in y direction (V/m)\n", + "Z = 377 #Intrinsic impedence of free space (ohm)\n", + "\n", + "#Calculation\n", + "avg_power = 0.5*(E1**2 + E2**2)/Z #average power per unit area (W/m^2)\n", + "\n", + "#Result\n", + "print \"The average power per unit area is\", avg_power, \"watts/meter^2\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The average power per unit area is 0.0596816976127 watts/meter^2\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 2-17.1, Page number: 43<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "AR_w = 4 #Axial Ratio for left elliptically polarized wave (unitless)\n", + "tau_w = 15 #Tilt angle for left elliptically polarized wave (degrees)\n", + "AR_a = -2 #Axial Ratio for right elliptically polarized wave (unitless) \n", + "tau_a = 45 #Tilt angle for right elliptically polarized wave (degrees)\n", + "tau_w2 = 20.7 #2*Tilt angle for left elliptically polarized wave (degrees) \n", + "tau_a2 = 39.3 #2*Tilt angle for right elliptically polarized wave (degrees)\n", + "\n", + "#Calculation\n", + "eps_a2 = 2*math.atan2(1,AR_a)*180/math.pi #polarisation latitude (degrees)\n", + "eps_w2 = 2*math.atan2(1,AR_w)*180/math.pi #antenna latitude (degrees)\n", + "gamma_w2 =math.acos(math.cos(eps_w2*math.pi/180)*math.cos(tau_w2*math.pi/180));\n", + " #great-circle angle - antenna (radians)\n", + "gamma_a2 =math.acos(math.cos(eps_a2*math.pi/180)*math.cos(tau_a2*math.pi/180));\n", + " #great-circle angle - wave (radians)\n", + "M_Ma = (gamma_w2*180/math.pi) + (gamma_a2*180/math.pi) \n", + " #total great-circle angle (degrees)\n", + "F = math.cos((M_Ma/2)*math.pi/180)**2 \n", + " #Polarisation matching factor (relative quantity)\n", + "\n", + "#Result\n", + "print \"The polarization matching factor is\", round(F,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The polarization matching factor is 0.44\n" + ] + } + ], + "prompt_number": 23 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter21.ipynb b/Antennas_and_Wave_Propagation/chapter21.ipynb new file mode 100644 index 00000000..270e96e9 --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter21.ipynb @@ -0,0 +1,343 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 21: Antenna Measurements<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 21-2.1, Page number: 720<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi\n", + "\n", + "#Variable declaration\n", + "f = 900e6 #Frequency (Hz)\n", + "length = 25e-3 #Length of antenna (m)\n", + "len_cell = 110e-3 #Length of handset chassis (m)\n", + "c = 3e8 #Speed of light (m/s)\n", + "del_L = 0.5 #Peak to Peak measurement uncertainty (dB)\n", + "\n", + "#Calculations\n", + "Dm = length + len_cell #Maximum Dimension of antenna (m)\n", + "wave_lt = c/f #Wavelength (m)\n", + "r_rnf = (wave_lt/(2*pi)) #Outer boundary of reactive near field (m)\n", + "\n", + "r_ff = 2*(Dm**2)/wave_lt #Fraunhofer region (m)\n", + "\n", + "r2_ff = r_rnf/(10**(del_L/40)-1) \n", + " #Minimum distance where effect of near field is small (m)\n", + "\n", + "r3_ff = 2*Dm/(10**(del_L/10)-1)\n", + " #Minimum distance where effect of rotation of AUT is small (m)\n", + "\n", + "#Result\n", + "print \"The Outer boundary of reactive near field is at a distance\", round(r_rnf,3),\"m\"\n", + "print \"The Fraunhofer region starts at a distance\", round(r_ff,3),\"m\"\n", + "print \"The Minimum distance where effect of near field is small enough is\",\\\n", + " round(r2_ff,1),\"m\"\n", + "print \"The Minimum distance where effect of rotation of AUT is small enough \\\n", + "is\", round(r3_ff,1),\"m\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Outer boundary of reactive near field is at a distance 0.053 m\n", + "The Fraunhofer region starts at a distance 0.109 m\n", + "The Minimum distance where effect of near field is small enough is 1.8 m\n", + "The Minimum distance where effect of rotation of AUT is small enough is 2.2 m\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 21-2.2, Page number: 720<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi\n", + "\n", + "#Variable declaration\n", + "horn_len = 350e-3 #Length of horn (m)\n", + "ap_wid = 200e-3 #Aperture width (m)\n", + "ap_hei = 150e-3 #Aperture height (m)\n", + "del_L = 0.2 #Peak to peak uncertainty (dB)\n", + "f = 10e9 #Frequency (Hz)\n", + "c = 3e8 #Speed of light (m/s)\n", + "\n", + "#Calculations\n", + "wave_lt = c/f #Wavelength (m)\n", + "r_rnf = wave_lt/(2*pi) ##Outer boundary of reactive near field (m)\n", + "\n", + "r_ff = 2*(ap_wid**2)/wave_lt #Fraunhofer region (m)\n", + "\n", + "r2_ff = r_rnf/(10**(del_L/40)-1) \n", + " #Minimum distance where effect of near field is small (m)\n", + "\n", + "r3_ff = 2*horn_len/(10**(del_L/10)-1)\n", + " #Minimum distance where effect of rotation of AUT is small (m)\n", + "\n", + "#Result\n", + "print \"The Outer boundary of reactive near field is at a distance\", round(r_rnf,4),\"m\"\n", + "print \"The Fraunhofer region starts at a distance\", round(r_ff,1),\"m\"\n", + "print \"The Minimum distance where effect of near field is small enough is\",\\\n", + " round(r2_ff,2),\"m\"\n", + "print \"The Minimum distance where effect of rotation of AUT is small enough \\\n", + "is\", round(r3_ff,1),\"m\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Outer boundary of reactive near field is at a distance 0.0048 m\n", + "The Fraunhofer region starts at a distance 2.7 m\n", + "The Minimum distance where effect of near field is small enough is 0.41 m\n", + "The Minimum distance where effect of rotation of AUT is small enough is 14.9 m\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 21-2.3, Page number: 721<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "D = 0.5 #Antenna diameter (m)\n", + "f = 300e9 #Frequency (Hz)\n", + "c = 3e8 #Speed of light (m/s)\n", + "\n", + "#Calculations\n", + "wave_lt = c/f #Wavelength (m)\n", + "r_ff = 2*(D**2)/wave_lt #Fraunhofer region (m)\n", + "\n", + "#Result\n", + "print \"The Fraunhofer region starts at a distance\", r_ff,\"m\"\n", + "print \"At 300 GHz the attenuation of the atmosphere is around 10dB/km making\\\n", + " the measurement difficult in full-size ranges\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Fraunhofer region starts at a distance 500.0 m\n", + "At 300 GHz the attenuation of the atmosphere is around 10dB/km making the measurement difficult in full-size ranges\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 21-4.1, Page number: 726<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi\n", + "\n", + "#Variable declaration\n", + "D = 1 #Diameter of antenna (m)\n", + "f = 10e9 #Frequency (Hz)\n", + "c = 3e8 #Speed of light (m/s)\n", + "\n", + "#Calculations\n", + "wave_lt = c/f #Wavelength (m)\n", + "hpbw = 70*wave_lt/D #Half power beamwidth (degrees)\n", + "mea_dist = 2*(D**2)/wave_lt #Measurement distance (m)\n", + "trav_dist = hpbw*pi*mea_dist/180 #Traverse distance (m)\n", + "taper = ((0.5/(trav_dist/2))**2)*(-3) #Amplitude taper (dB)\n", + "\n", + "#Result\n", + "print \"The amplitude taper is\", round(taper,1), \"dB\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The amplitude taper is -0.5 dB\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 21-4.2, Page number: 735<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import log10\n", + "\n", + "#Variable declaration\n", + "pat_lev1 = -22.3 #Pattern level maximum (dB)\n", + "pat_lev2 = -23.7 #Pattern level minimum (dB)\n", + "\n", + "#Calculations\n", + "S = abs(pat_lev2-pat_lev1) #Amplitude ripple (dB)\n", + "a = (pat_lev1+pat_lev2)/2 #Pattern level (dB)\n", + "\n", + "R = a + 20*log10((10**(S/20) - 1)/(10**(S/20) + 1))\n", + " #Reflectivity (dB)\n", + "\n", + "#Result\n", + "print \"The reflectivity is\", round(R),\"dB\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The reflectivity is -45.0 dB\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 21-5.1, Page number: 739<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi, sin, cos, log10\n", + "\n", + "#Variable declaration\n", + "En = 1 #Field illuminating the AUT (unitless)\n", + "tilt_diff = 88 #Difference in tilt angles (degrees)\n", + "\n", + "#Calculations\n", + "En_pol = En*sin(tilt_diff*pi/180) #Co-polar component of field (unitless)\n", + "En_crosspol = En*cos(tilt_diff*pi/180)\n", + " #Cross-polar component of field (unitless)\n", + "meas_cross = 20*log10(En_crosspol)\n", + "\n", + "#Result\n", + "print \"The measure cross-polar level is\", round(meas_cross), \"dB\\\n", + " relative to the co-polar field\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The measure cross-polar level is -29.0 dB relative to the co-polar field\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 21-5.2, Page number: 743<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi, log10\n", + "\n", + "#Variable declaration\n", + "f = 1.4e9 #Frequency (Hz)\n", + "Tant = 687 #Increase in antenna temperature (K)\n", + "phy_ap = 2210 #Physical aperture (m^2)\n", + "S = 1590 #Flux density of Cygnus A (Jy)\n", + "k = 1.38e-23 #Boltzmann's constant (J/k)\n", + "c = 3e8 #Speed of light (m/s)\n", + "\n", + "#Calculations\n", + "wave_lt = c/f #Wavelength (m)\n", + "gain = (8*pi*k*Tant)/(S*(10**-26)*wave_lt**2) #Gain(unitless)\n", + "gain_db = 10*log10(gain) #Gain (dBi)\n", + "\n", + "Ae = gain*wave_lt**2/(4*pi) #Effective area (m^2)\n", + "\n", + "eff_ap = Ae/phy_ap #Aperture efficiency (unitless)\n", + "\n", + "#Result\n", + "print \"The gain of the antenna is\", round(gain_db), \"dBi\"\n", + "print \"The aperture efficiency is\", round(eff_ap,2),\"or\",round(eff_ap*100),\"percent\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The gain of the antenna is 55.0 dBi\n", + "The aperture efficiency is 0.54 or 54.0 percent\n" + ] + } + ], + "prompt_number": 10 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter23.ipynb b/Antennas_and_Wave_Propagation/chapter23.ipynb new file mode 100644 index 00000000..48d55109 --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter23.ipynb @@ -0,0 +1,302 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 23: Ground Wave Propagation<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 23-1.1, Page number: 783<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "f1 = 0.1 #Frequency (MHz)\n", + "f2 = 1.0 #Frequency (MHz)\n", + "f3 = 10.0 #Frequency (MHz)\n", + "\n", + "#Calculations\n", + "d1 = 50/(f1**(1.0/3)) #Distance for f1 (miles)\n", + "d2 = 50/(f2**(1.0/3)) #Distance for f2 (miles)\n", + "d3 = 50/(f3**(1.0/3)) #Distance for f3 (miles)\n", + "\n", + "#Result\n", + "print \"The distance for 100kHz is\", round(d1,2), \"miles\"\n", + "print \"The distance for 1MHz is\", d2, \"miles\"\n", + "print \"The distance for 10MHz is\", round(d3,2), \"miles\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The distance for 100kHz is 107.72 miles\n", + "The distance for 1MHz is 50.0 miles\n", + "The distance for 10MHz is 23.21 miles\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 23-2.1, Page number: 786<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi,sin\n", + "\n", + "#Variable declaration\n", + "f = 3e6 #Frequency (Hz)\n", + "sigma = 0.5 #Standard deviation of surface irregularities (unitless)\n", + "theta = 30 #Angle of incidence as measured from normal angle (degrees)\n", + "c = 3e8 #Speed of light (m/s)\n", + "\n", + "#Calculations\n", + "wave_lt = c/f #Wavelength (m)\n", + "R = 4*pi*sigma*sin(theta*pi/180)/wave_lt\n", + " #Roughness factor (unitless)\n", + "\n", + "#Result\n", + "print \"The roughness factor is\", round(R,9)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The roughness factor is 0.031415927\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 23-2.2, Page number: 786<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi,sin\n", + "\n", + "#Variable declaration\n", + "f = 10e6 #Frequency (Hz)\n", + "sigma = 5 #Standard deviation of surface irregularities (unitless)\n", + "theta1 = 30 #Angle of incidence as measured from normal angle (degrees)\n", + "theta2 = 45 #Angle of incidence as measured from normal angle (degrees)\n", + "theta3 = 60 #Angle of incidence as measured from normal angle (degrees)\n", + "c = 3e8 #Speed of light (m/s)\n", + "\n", + "#Calculations\n", + "wave_lt = c/f #Wavelength (m)\n", + "R1 = 4*pi*sigma*sin(theta1*pi/180)/wave_lt \n", + " #Roughness factor for theta1 (unitless)\n", + "R2 = 4*pi*sigma*sin(theta2*pi/180)/wave_lt\n", + " #Roughness factor for theta2 (unitless)\n", + "R3 = 4*pi*sigma*sin(theta3*pi/180)/wave_lt\n", + " #Roughness factor for theta3 (unitless)\n", + "\n", + "#Result\n", + "print \"The roughness factor for 30 degrees is\", round(R1,4)\n", + "print \"The roughness factor for 45 degrees is\", round(R2,3)\n", + "print \"The roughness factor for 60 degrees is\", round(R3,4)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The roughness factor for 30 degrees is 1.0472\n", + "The roughness factor for 45 degrees is 1.481\n", + "The roughness factor for 60 degrees is 1.8138\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 23-2.3, Page number: 787<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "f1 = 0.3 #Frequency (MHz)\n", + "f2 = 1 #Frequency (MHz)\n", + "f3 = 3 #Frequency (MHz)\n", + "sigma = 4e-5 #Standard deviation of surface irregularities (unitless)\n", + "\n", + "#Calculations\n", + "x1 = (18e3)*sigma/f1 #Parameter x for f1 (unitless)\n", + "x2 = (18e3)*sigma/f2 #Parameter x for f2 (unitless)\n", + "x3 = (18e3)*sigma/f3 #Parameter x for f3 (unitless)\n", + "\n", + "#Result\n", + "print \"The parameter x for 0.3MHz is\", x1\n", + "print \"The parameter x for 1MHz is\", x2\n", + "print \"The parameter x for 3MHz is\", x3" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The parameter x for 0.3MHz is 2.4\n", + "The parameter x for 1MHz is 0.72\n", + "The parameter x for 3MHz is 0.24\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 23-5.1, Page number: 790<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi, sqrt\n", + "\n", + "#Variable declaration\n", + "f1 = 5e3 #Frequency (Hz)\n", + "f2 = 50e3 #Frequency (Hz)\n", + "f3 = 500e3 #Frequency (Hz)\n", + "sigma = 5e-5 #Standard deviation of surface irregularities (unitless)\n", + "eps_r = 15.0 #Relative permittivity (unitless)\n", + "mu = pi*4e-7 #Absolute Permeability (H/m)\n", + "\n", + "#Calculations\n", + "w1 = 2*pi*f1 #Angular frequency (rad/s)\n", + "w2 = 2*pi*f2 #Angular frequency (rad/s)\n", + "w3 = 2*pi*f3 #Angular frequency (rad/s)\n", + "\n", + "\n", + "Zs1 = sqrt((w1*mu)/sqrt(sigma**2 + (w1**2)*eps_r))\n", + " #Surface impedence for f1 (ohm)\n", + "Zs2 = sqrt((w2*mu)/sqrt(sigma**2 + (w2**2)*eps_r))\n", + " #Surface impedence for f2 (ohm)\n", + "Zs3 = sqrt((w3*mu)/sqrt(sigma**2 + (w3**2)*eps_r))\n", + " #Surface impedence for f3 (ohm)\n", + "\n", + "#Result\n", + "print \"The surface impedence for 5kHz is\", round(Zs1,5), \"ohms\"\n", + "print \"The surface impedence for 50kHz is\", round(Zs2,5), \"ohms\"\n", + "print \"The surface impedence for 500kHz is\", round(Zs3,5), \"ohms\"\n", + "\n", + "#There has been a numerical mistake in the calculation/substitution of square root of\n", + "#(sigma**2 + (w1**2)*eps_r) and in the second case, the mistake in the calculation of\n", + "#(w2*mu)/sqrt(sigma**2 + (w2**2)*eps_r)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The surface impedence for 5kHz is 0.00057 ohms\n", + "The surface impedence for 50kHz is 0.00057 ohms\n", + "The surface impedence for 500kHz is 0.00057 ohms\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 23-7.1, Page number: 793<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi, atan, cos\n", + "\n", + "#Variable declaration\n", + "f = 2.0 #Frequency (MHz)\n", + "sigma = 5e-5 #Standard deviation of surface irregularities (unitless)\n", + "eps_r = 15.0 #Relative permittivity (unitless)\n", + "d = 20e3 #Distance (m)\n", + "eff = 0.5 #Antenna efficiency (unitless)\n", + "c = 3e8 #Speed of light (m/s)\n", + "E1 = 0.5e-3 #Ground wave electric field strength (V/m)\n", + "\n", + "#Calculations\n", + "wave_lt = c/(f*10**6) #Wavelength (m)\n", + "x = (18e3)*sigma/f #Parameter x (unitless)\n", + "\n", + "b = atan((eps_r + 1)/x) #Phase constant (unitless)\n", + "\n", + "p = (pi/x)*(d/wave_lt)*cos(b) #Numerical distance (unitless)\n", + "\n", + "A = (2 + 0.3*p)/(2 + p + 0.6*(p**2)) #Reduction factor (unitless)\n", + "\n", + "E_t = E1 * d/A\n", + "\n", + "#Result\n", + "print \"The Electric field strength at the transmitted end is\", round(E_t,2),\"V/m\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Electric field strength at the transmitted end is 445.72 V/m\n" + ] + } + ], + "prompt_number": 25 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter24.ipynb b/Antennas_and_Wave_Propagation/chapter24.ipynb new file mode 100644 index 00000000..a97a053a --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter24.ipynb @@ -0,0 +1,332 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 24: Space Wave Propagation<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 24-9.1, Page number: 808<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import sqrt\n", + "\n", + "#Variable declaration\n", + "tx_h = 49.0 #Transmitting antenna height (m)\n", + "rx_h = 25.0 #Receiving antenna height (m)\n", + "f = 100e6 #Frequency (Hz)\n", + "tx_p = 100.0 #Transmitted power (W)\n", + "c = 3e8 #Speed of light (m/s)\n", + "a = 6370 #Earth's radius (km)\n", + "\n", + "#Calculations\n", + "wave_lt = c/f #Wavelength (m)\n", + "d0 = sqrt(2*(4.0/3.0)*(a/1000.0))*(sqrt(tx_h)+sqrt(rx_h))\n", + " #Line of Sight (LOS) distance (km)\n", + "d = d0*1000 #LOS (m)\n", + "Er = (88*sqrt(tx_p)/(wave_lt*(d**2)))*tx_h*rx_h\n", + " #Received signal strength (W)\n", + "\n", + "#Result\n", + "print \"The Line of Sight distance is\", round(d0,2), \"km\"\n", + "print \"The received signal strength is\", round(Er,6), \"W\"\n", + "\n", + "#The mistake is in the calculation of (88*sqrt(tx_p)/(wave_lt*(d**2))) where four orders of\n", + "#magnitude are ignored in the resulting calculation." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Line of Sight distance is 49.46 km\n", + "The received signal strength is 0.000147 W\n" + ] + }, + { + "metadata": {}, + "output_type": "pyout", + "prompt_number": 1, + "text": [ + "'The mistake is in the calculation of (88*sqrt(tx_p)/(wave_lt*(d**2))) where four orders of\\nmagnitude are ignored in the resulting calculation.'" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 24-9.2, Page number: 809<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import sqrt\n", + "\n", + "#Variable declaration\n", + "tx_h = 144 #Transmitting antenna height (m)\n", + "rx_h = 25 #Receiving antenna height (m)\n", + "k = 4.0/3.0 #Equivalent earth radius/Actual earth radius (unitless)\n", + "a = 6370 #Radius of earth (km)\n", + "\n", + "#Calculations\n", + "los = 4.12*(sqrt(tx_h) + sqrt(rx_h)) #Line of sight distance (km)\n", + "\n", + "horz = sqrt(2*k*a*(tx_h/1000.0)) #Surface range to radio horizon from radar (km)\n", + "\n", + "#Result\n", + "print \"The Radio horizon distance from radar is\", round(horz,2),\"km\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Radio horizon distance from radar is 49.46 km\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 24-9.3, Page number: 809<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import sqrt\n", + "\n", + "#Variable declaration\n", + "tx_h = 100 #Transmitting antenna height (m)\n", + "rx_h = 16 #Receiving antenna height (m)\n", + "tx_p = 40e3 #Transmitting antenna power radiation (W)\n", + "f = 100e6 #Frequency (Hz)\n", + "d = 10e3 #Distance (m)\n", + "c = 3e8 #Speed of light (m/s)\n", + "E = 1e-3 #Signal strength (V/m)\n", + "\n", + "#Calculations\n", + "los = 4.12*(sqrt(tx_h) + sqrt(rx_h)) #LOS distance (km)\n", + "wave_lt = c/f #Wavelength (m)\n", + "\n", + "Es = (88*sqrt(tx_p)/(wave_lt*(d**2)))*tx_h*rx_h\n", + " #Field strength at distance d (V/m)\n", + "\n", + "dsig = sqrt(88*sqrt(tx_p)*tx_h*rx_h/(wave_lt*E))\n", + " #Distance at which field strength reduces to 1mV/m\n", + "\n", + "#Result\n", + "print \"The LOS distance is\", los, \"km\"\n", + "print \"The field strength at 10km is\", round(Es,5),\"V/m\"\n", + "print \"The distance at which field strength is 1mV/m is\", round(dsig,-1), \"m\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The LOS distance is 57.68 km\n", + "The field strength at 10km is 0.09387 V/m\n", + "The distance at which field strength is 1mV/m is 96880.0 m\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 24-9.4, Page number: 809<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi\n", + "\n", + "#Variable declaration\n", + "gain = 10 #Antenna gain (dB)\n", + "Wt = 500 #Power radiation (W)\n", + "d = 15e3 #Distance (m)\n", + "Wr = 2e-6 #Received power (W)\n", + "\n", + "#Calculations\n", + "Ae = Wr*(4*pi*(d**2))/(Wt*gain) #Effective area (m^2)\n", + "\n", + "#Result\n", + "print \"The effective area of the receiving antenna is\", round(Ae,2), \"m^2\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The effective area of the receiving antenna is 1.13 m^2\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 24-9.5, Page number: 809<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import sqrt\n", + "\n", + "#Variable declaration\n", + "h = 1000 #Height of duct (m)\n", + "delM = 0.036 #Change in refractive modulus (unitless)\n", + "c = 3e8 #Speed of light (m/s)\n", + "\n", + "#Calculations\n", + "wl_max = 2.5*h*sqrt(delM*1e-6) #Maximum wavelength (m)\n", + "fmax = c/wl_max #Maximum frequency (Hz)\n", + "\n", + "#Result\n", + "print \"The maximum frequency that can be transmitted is\", round(fmax/1e6,1),\"MHz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The maximum frequency that can be transmitted is 632.5 MHz\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 24-12.1, Page number: 812<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi,sqrt\n", + "\n", + "#Variable declaration\n", + "gain = 10 #Gain of transmitting antenna (dB)\n", + "P = 100 #Radiating power (W)\n", + "f = 1e6 #Frequency (Hz)\n", + "rx_gain = 15 #Gain of receiving antenna (dB)\n", + "d = 20e3 #Distance (m)\n", + "c = 3e8 #Speed of light (m/s)\n", + "v = 1000 #scattering volume (m^3)\n", + "sigma = 0.1 #Effective scattering cross-section (m^2)\n", + "\n", + "#Calculations\n", + "wl = c/f #Wavelength (m)\n", + "Pr_a = P*gain*rx_gain*(wl**2)/(4*pi*(4*pi*(d**2)))\n", + " #Received power in case (a) (W)\n", + "F = (2*sqrt(sigma*v))/(d*sqrt(pi)) #Attenuation Factor (unitless)\n", + "Pr_b = Pr_a*F #Received power in case (b) (W)\n", + "\n", + "\n", + "#Result\n", + "print \"The received power in case (a) is\", round(Pr_a,5), \"W\"\n", + "print \"The received power in case (b) is\", round(Pr_b,10), \"W\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The received power in case (a) is 0.02137 W\n", + "The received power in case (b) is 1.20581e-05 W\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 24-14.1, Page number: 813<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import log10\n", + "\n", + "#Variable declaration\n", + "d = 3000 #Distance (km)\n", + "f = 3e3 #Frequency (MHz)\n", + "\n", + "#Calculations\n", + "path_l = 32.45 + 20*log10(f) + 20*log10(d)\n", + "\n", + "#Result\n", + "print \"The path loss between the two points is\", round(path_l,3), \"dB\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The path loss between the two points is 171.535 dB\n" + ] + } + ], + "prompt_number": 19 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter25.ipynb b/Antennas_and_Wave_Propagation/chapter25.ipynb new file mode 100644 index 00000000..b013f142 --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter25.ipynb @@ -0,0 +1,242 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 25: Sky Wave Propagation<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 25-5.1, Page number: 823<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import sqrt\n", + "\n", + "#Variable declaration\n", + "muf = 10e6 #Maximum usable frequency (Hz)\n", + "h = 300 #Height of reflection (km)\n", + "n = 0.9 #Maximum value of refractive index (unitless)\n", + "\n", + "#Calculations\n", + "Nmax = (1 - n**2)*(muf**2)/81 #Max. Number of electrons per cubic cm\n", + "fc = 9*sqrt(Nmax) #Critical frequency (Hz)\n", + "dskip = 2*h*sqrt((muf/fc)**2 - 1) #Skip distance (km)\n", + "\n", + "\n", + "#Result\n", + "print \"The skip distance is\", round(dskip,1), \"km\"\n", + "\n", + "#Numerical error in the calculation of sqrt((muf/fc)**2 - 1) " + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "2.34567901235e+11 4358898.94354\n", + "The skip distance is 1238.8 km\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 25-5.2, Page number: 823<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "fE = 3e6 #Critical frequency for E layer (Hz)\n", + "fF1 = 5e6 #Critical frequency for F1 layer (Hz)\n", + "fF2 = 9e6 #Critical frequency for F2 layer (Hz)\n", + "\n", + "#Calculations\n", + "N_E = (fE**2)/81 #Concentration of electrons in E layer (per cubic cm)\n", + "N_F1 = (fF1**2)/81 #Concentration of electrons in F1 layer (per cubic cm)\n", + "N_F2 = (fF2**2)/81 #Concentration of electrons in F2 layer (per cubic cm)\n", + "\n", + "#Result\n", + "print \"The concentration of electrons in E layer is\", round(N_E,-8), \"per cubic cm\"\n", + "print \"The concentration of electrons in F1 layer is\", round(N_F1,-8), \"per cubic cm\"\n", + "print \"The concentration of electrons in F2 layer is\", N_F2, \"per cubic cm\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The concentration of electrons in E layer is 1.111e+11 per cubic cm\n", + "The concentration of electrons in F1 layer is 3.086e+11 per cubic cm\n", + "The concentration of electrons in F2 layer is 1e+12 per cubic cm\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 25-5.3, Page number: 823<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import sqrt\n", + "\n", + "#Variable declaration\n", + "N_E = 0.8*0.111e12 #Concentration of electrons in E layer (per cubic cm)\n", + "N_F1 = 0.8*0.3086e12 #Concentration of electrons in E layer (per cubic cm)\n", + "N_F2 = 0.8*1e12 #Concentration of electrons in E layer (per cubic cm)\n", + "\n", + "#Calculations\n", + "fE = 9*sqrt(N_E) #Critical frequency in E layer (Hz)\n", + "fF1 = 9*sqrt(N_F1) #Cricital frequency in F1 layer (Hz)\n", + "fF2 = 9*sqrt(N_F2) #Critical frequency in F2 layer (Hz)\n", + "\n", + "#Result\n", + "print \"The Critical frequency in E layer is\", round(fE,-4),\"Hz\"\n", + "print \"The Critical frequency in F1 layer is\", round(fF1,-4),\"Hz\"\n", + "print \"The Critical frequency in F2 layer is\", round(fF2,-3),\"Hz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Critical frequency in E layer is 2680000.0 Hz\n", + "The Critical frequency in F1 layer is 4470000.0 Hz\n", + "The Critical frequency in F2 layer is 8050000.0 Hz\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 25-6.1, Page number: 829<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import cos, sqrt, pi\n", + "\n", + "#Variable declaration\n", + "hD = 70 #Height of D layer (km)\n", + "hE = 130 #Height of E layer (km)\n", + "hF1 = 230 #Height of F1 layer (km)\n", + "hF2 = 350 #Height of F2 layer (km)\n", + "theta = 10*pi/180 #Angle of incidence (radians)\n", + "\n", + "#Calculations\n", + "temp = sqrt((cos(theta))**-2 - 1)\n", + "d1 = 2*hD*temp #Maximum single hop distance for D layer (km)\n", + "d2 = 2*hE*temp #Maximum single hop distance for E layer (km)\n", + "d3 = 2*hF1*temp #Maximum single hop distance for F1 layer (km)\n", + "d4 = 2*hF2*temp #Maximum single hop distance for F2 layer (km)\n", + "\n", + "#Result\n", + "print \"The Maximum single hop distance for D layer is\", round(d1,1), \"km\"\n", + "print \"The Maximum single hop distance for E layer is\", round(d2,2), \"km\"\n", + "print \"The Maximum single hop distance for F1 layer is\", round(d3,2), \"km\"\n", + "print \"The Maximum single hop distance for F2 layer is\", round(d4,1), \"km\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Maximum single hop distance for D layer is 24.7 km\n", + "The Maximum single hop distance for E layer is 45.85 km\n", + "The Maximum single hop distance for F1 layer is 81.11 km\n", + "The Maximum single hop distance for F2 layer is 123.4 km\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 25-9.1, Page number: 832<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi, sqrt, cos\n", + "\n", + "#Variable declaration\n", + "d = 200 #Height of layer (km)\n", + "beta = 20 #Takeoff angle (degrees)\n", + "R = 6370 #Earth's radius (km)\n", + "\n", + "#Calculations\n", + "phi_0 = 90 - beta #Take off angle for flat earth (degrees)\n", + "h = (d/2)/(sqrt((cos(phi_0*pi/180)**-2) - 1)) #Skip distance for case (a) (km)\n", + "\n", + "phi_02 = 90 - beta - 57.2*d/(2*R)\n", + " #Take off angle for spherical earth (degrees)\n", + "h2 = (d/2)/(sqrt((cos(phi_02*pi/180)**-2) - 1))\n", + " #Skip distance for case (b) (km)\n", + "\n", + "#Result\n", + "print \"The skip distance for case (a) is\", round(h,3), \"km\"\n", + "print \"The skip distance for case (b) is\", round(h2,2), \"km\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The skip distance for case (a) is 36.397 km\n", + "The skip distance for case (b) is 38.18 km\n" + ] + } + ], + "prompt_number": 21 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter3.ipynb b/Antennas_and_Wave_Propagation/chapter3.ipynb new file mode 100644 index 00000000..6656b2c8 --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter3.ipynb @@ -0,0 +1,175 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 3: The Antenna Family<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 3-3.2, Page number: 58<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Z_0 = 377 #Intrinsic impedence of free space(ohm)\n", + "Z_d = 710 +0j #Terminal impedence of dipole cylinder (ohm)\n", + "\n", + "#Calculation\n", + "Z_s = (Z_0**2)/(4*Z_d) #Terminal impedence of the slot (ohm)\n", + "\n", + "#Result\n", + "print \"The terminal impedence of the slot is\", round(Z_s.real), \"ohms\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The terminal impedence of the slot is 50.0 ohms\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 3-6.1, Page number: 61<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "L = 10 #Horn length (lambda)\n", + "delta = 0.25 #Path length difference (lambda)\n", + "\n", + "#Calculation\n", + "theta = 2*math.acos(L/(L+delta)) #Horn flare angle (radians)\n", + "theta = theta*180/math.pi #Horn flare angle (degrees)\n", + "\n", + "\n", + "#Result\n", + "print \"The largest flare angle for given delta is\",round(theta,1), \"degrees\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The largest flare angle for given delta is 25.4 degrees\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 3-7.1, Page number: 62<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "f = 599e6 #Frequency of TV Station (Hz)\n", + "E = 1e-6 #Field strength (V/m)\n", + "D = 20 #Diameter of antenna (m)\n", + "c = 3e8 #Speed of light (m/s)\n", + "Z_0 = 377 #Intrinsic impedence of free space (ohm) \n", + "\n", + "#Calculation\n", + "wave_lt = c/f #Wavelength (m)\n", + "A_e = (D*(wave_lt**2))/(4*math.pi) #Effective aperture (m^2)\n", + "P_r = (E**2)*A_e/Z_0 #Received power (W)\n", + "\n", + "#Result\n", + "print \"The received power is\", round(P_r,17), \"W\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The received power is 1.06e-15 W\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 3-11.1, Page number: 66<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "n = 4 #Number of patch antennas (lambda)\n", + "diameter = 0.5 #diameter of patch antennas (lambda)\n", + "\n", + "#Calculation\n", + "A_e = n*diameter #Effective aperture (lambda^2)\n", + "D = (4*math.pi*A_e) #Directivity (unitless)\n", + "D_dbi = 10*math.log10(D) #Directivity (dBi)\n", + "ohm_a = (4*math.pi)/D #Beam area (steradians)\n", + "\n", + "#Result\n", + "print \"The directivity is\", round(D), \"or\", round(D_dbi), \"dBi\"\n", + "print \"The beam area is\", ohm_a, \"sr\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The directivity is 25.0 or 14.0 dBi\n", + "The beam area is 0.5 sr\n" + ] + } + ], + "prompt_number": 5 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter4.ipynb b/Antennas_and_Wave_Propagation/chapter4.ipynb new file mode 100644 index 00000000..e1fba10d --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter4.ipynb @@ -0,0 +1,272 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 4: Radiation<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 4-4.1, Page number: 75<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "theta = 30 #Angle of radiation (degrees)\n", + "epsilon_0 = 8.854e-12 #Permittivity of free space (F/m)\n", + "I_dl = 10 #Current in length dl (A-m)\n", + "r = 100e3 #Distance of point from origin (m)\n", + "\n", + "#Calculation\n", + "E_mag = (I_dl*math.sin(theta*math.pi/180))/(4*math.pi*epsilon_0)\n", + " #Magnitude of Electric field vector (V/m)\n", + "H_mag = (I_dl*math.sin(theta*math.pi/180))/(4)\n", + " #Magnitude of Magnetic field vector (T)\n", + "\n", + "#Result\n", + "print \"The magnitude of E vector is \", round(E_mag,-9), \"V/m\"\n", + "print \"The magnitude of H vector is\", round(H_mag, 3), \"/pi T\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The magnitude of E vector is 45000000000.0 V/m\n", + "The magnitude of H vector is 1.25 /pi T\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 4-4.2, Page number: 76<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "v = 3e8 #Speed of light(m/s)\n", + "f = 10e6 #Frequency (Hz)\n", + "\n", + "#Calculation\n", + "w = 2*math.pi*f #Angular frequency(rad/s)\n", + "r = v/w #Distance (m)\n", + "\n", + "#Result\n", + "print \"The distance for the specified condition is\", round(r, 2), \"m\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The distance for the specified condition is 4.77 m\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 4-4.3, Page number: 76<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "c = 3e8 #Speed of light (m/s)\n", + "f = 3e9 #Frequency (Hz)\n", + "\n", + "#Calculation\n", + "v = 0.6*c #60% of velocity of light (m/s)\n", + "w = 2*math.pi*f #Angular frequency (rad/s)\n", + "r = v/w #Distance (m)\n", + "\n", + "#Result\n", + "print \"The distance for the specified condition is\", round(r,6), \"m\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The distance for the specified condition is 0.009549 m\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 4-5.1, Page number: 80<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "dl = 1e-2 #Length of radiating element (m)\n", + "I_eff = 0.5 #Effective current (A)\n", + "f = 3e9 #Frequency (Hz)\n", + "c = 3e8 #Velocity of light (m/s)\n", + "\n", + "#Calculation\n", + "w = 2*math.pi*f #Angular Frequency (rad/s)\n", + "P = 20*(w**2)*(I_eff**2)*(dl**2)/(c**2) #Radiated power (W)\n", + "\n", + "#Result\n", + "print \"The radiated power is\", round(P, 2), \"W\"\n", + "\n", + "#The final result is incorrect in the book because of the calculation mistake" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The radiated power is 1.97 W\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 4-5.2, Page number: 80<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "L = 5 #Length of radiating element (m)\n", + "f1 = 30e3 #Frequency (Hz) \n", + "f2 = 30e6 #Frequency (Hz) \n", + "f3 = 15e6 #Frequency (Hz)\n", + "c = 3e8 #Velocity of light (m/s) \n", + "\n", + "#Calculation\n", + "wave_lt1 = c/f1 #Wavelength (m)\n", + "wave_lt1 /= 10\n", + "R_r1 = 800*(L/wave_lt1)**2 #Radiation resistance (ohm)\n", + "\n", + "wave_lt2 = c/f2 #Wavelength (m)\n", + "L = wave_lt2/2 #Effective length (m)\n", + "R_r2 = 200*(L/wave_lt2)**2 #Radiation resistance (ohm)\n", + "\n", + "wave_lt3 = c/f3 #Wavelength (m)\n", + "L = wave_lt3/4 #Effective length (m)\n", + "R_r3 = 400*(L/wave_lt3)**2 #Radiation resistance (ohm)\n", + "\n", + "#Result\n", + "print \"The radiation resistance for f1 is\", R_r1, \"ohms\"\n", + "print \"The radiation resistance for f2 is\", round(R_r2), \"ohms\"\n", + "print \"The radiation resistance for f3 is\", round(R_r3), \"ohms\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The radiation resistance for f1 is 0.02 ohms\n", + "The radiation resistance for f2 is 50.0 ohms\n", + "The radiation resistance for f3 is 25.0 ohms\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 4-6.1, Page number: 82<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "Im = 5 #Maximum current (A)\n", + "r = 1e3 #Distance (km)\n", + "eta = 120*math.pi #Intrinsic impedence (ohm)\n", + "theta = 60*math.pi/180 #Angle of radiation (radians)\n", + "\n", + "#Calculation\n", + "sin2 = math.sin(theta)**2 #Sine squared theta (unitless)\n", + "P_av = (eta*(Im**2))/(8*(math.pi**2)*(r**2))\n", + "P_av = P_av*(math.cos(math.pi/2*math.cos(theta))**2)/(sin2)\n", + " #Average power (W)\n", + " \n", + "#Result\n", + "print \"The average power available at 1km distance is\", round(P_av,9), \"W\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The average power available at 1km distance is 7.9577e-05 W\n" + ] + } + ], + "prompt_number": 8 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter5.ipynb b/Antennas_and_Wave_Propagation/chapter5.ipynb new file mode 100644 index 00000000..a658e618 --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter5.ipynb @@ -0,0 +1,312 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 5: Point Source and Their Arrays<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 5-6.1, Page number: 90<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import scipy.integrate\n", + "\n", + "#Variable declaration\n", + "def integrand(theta, phi):\n", + " return (math.cos(theta)*math.sin(theta))\n", + " #Integrand (unitless)\n", + "Um = 1 #Maximum radiation intensity (unitless)\n", + "\n", + "#Calculation\n", + "P = scipy.integrate.dblquad(integrand, 0, 2*math.pi,\n", + " lambda x: 0, lambda x: math.pi/2)\n", + " #Total power radiated (relative to Um)\n", + "D = (4*math.pi)/P[0] #Directivity (unitless)\n", + "\n", + "#Result\n", + "print \"The directivity is \", round(D)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The directivity is 4.0\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 5-6.2, Page number: 91<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import scipy.integrate\n", + "\n", + "#Variable declaration\n", + "def integrand(theta, phi):\n", + " return (math.cos(theta)*math.sin(theta))\n", + " #Integrand (unitless)\n", + "Um = 1 #Maximum radiation intensity (unitless)\n", + "\n", + "#Calculation\n", + "P = scipy.integrate.dblquad(integrand, 0, 2*math.pi,\n", + " lambda x: 0, lambda x: math.pi/2)\n", + " #Total power radiated (relative to Um)\n", + "D = (4*math.pi)/(2*P[0]) #Directivity (unitless)\n", + "\n", + "#Result\n", + "print \"The directivity is \", round(D)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The directivity is 2.0\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 5-6.3, Page number: 91<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math, scipy.integrate\n", + "\n", + "#Variable declaration\n", + "def integrand(theta, phi):\n", + " return (math.sin(theta)**2)\n", + " #Integrand (unitless)\n", + "Um = 1 #Maximum radiation intensity (unitless)\n", + "\n", + "#Calculation\n", + "P = scipy.integrate.dblquad(integrand, 0, 2*math.pi,\n", + " lambda x: 0, lambda x: math.pi)\n", + " #Total radiated power (relative to Um)\n", + "D = 4*math.pi/P[0] #Directivity (unitless)\n", + "\n", + "#Result \n", + "print \"The directivity is\", round(D,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The directivity is 1.27\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 5-6.4, Page number: 91<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math, scipy.integrate\n", + "\n", + "#Variable declaration\n", + "def integrand(theta, phi):\n", + " return (math.sin(theta)**3)\n", + " #Integrand (unitless)\n", + "Um = 1 #Maximum radiation intensity (unitless)\n", + "\n", + "#Calculation\n", + "P = scipy.integrate.dblquad(integrand, 0, 2*math.pi,\n", + " lambda x: 0, lambda x: math.pi)\n", + " #Total radiated power (relative to Um)\n", + "D = 4*math.pi/P[0] #Directivity (unitless)\n", + "\n", + "#Result \n", + "print \"The directivity is\", round(D,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The directivity is 1.5\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 5-6.5, Page number: 92<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math, scipy.integrate\n", + "\n", + "#Variable declaration\n", + "def integrand(theta, phi):\n", + " return (math.sin(theta)*math.cos(theta)**2)\n", + " #Integrand (unitless)\n", + "Um = 1 #Maximum radiation intensity (unitless)\n", + "\n", + "#Calculation\n", + "P = scipy.integrate.dblquad(integrand, 0, 2*math.pi,\n", + " lambda x: 0, lambda x: math.pi/2)\n", + " #Total radiated power (relative to Um)\n", + "D = 4*math.pi/P[0] #Directivity (unitless)\n", + "\n", + "#Result \n", + "print \"The directivity is\", round(D,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The directivity is 6.0\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 5-6.6, Page number:93<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "lobes = [0.25,0.37,0.46,0.12,0.07] #Normalized power of lobes (unitless)\n", + "\n", + "#Calculation\n", + "ohm_a = 0 #Beam area (sr)\n", + "sum_lobes = 0 #Sum of all lobes (unitless)\n", + "for i in lobes:\n", + " ohm_a += 2*math.pi*(math.pi/36)*(i)\n", + " sum_lobes += i\n", + "\n", + "D = 4*math.pi/ohm_a #Directivity (unitless)\n", + "D_db = 10*math.log10(D) #Directivity (in dBi)\n", + "e_m = lobes[0]/sum_lobes #Beam efficiency (unitless)\n", + "\n", + "#Result\n", + "print \"The directivity is\", round(D), \"or\", round(D_db,1), \"dBi\"\n", + "print \"The beam efficiency is\", round(e_m, 2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The directivity is 18.0 or 12.6 dBi\n", + "The beam efficiency is 0.2\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 5-21.1, Page number: 146<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "a = 25 #Height of vertical conducting wall (m)\n", + "r = 100 #Distance to the receiver (m)\n", + "wave_lt = 10e-2 #Transmitter dimension (m)\n", + "\n", + "#Calculation\n", + "k = math.sqrt(2/(r*wave_lt)) #contant (unitless)\n", + "S_av = (r*wave_lt)/(4*(math.pi**2)*(a**2)) #Relative signal level (unitless)\n", + "S_av_db = 10*math.log10(S_av) #Signal level (in db)\n", + "\n", + "#Result\n", + "print \"The signal level at the receiver is\", round(S_av,5), \"or\", round(S_av_db), \"dB\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The signal level at the receiver is 0.00041 or -34.0 dB\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter6.ipynb b/Antennas_and_Wave_Propagation/chapter6.ipynb new file mode 100644 index 00000000..040ba097 --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter6.ipynb @@ -0,0 +1,182 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 6: Electric Dipoles, Thin Linear Antennas \n", + " and Arrays of Dipoles and Apertures<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 6-8.1, Page number: 174" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "z = 333.0 #Driving point impedence (ohm)\n", + "r = 300.0 #twin-line impedence (ohm)\n", + "z1 = 73.0 #Self impedence of lambda/2 dipole (ohm)\n", + "z2 = 13.0 #Mutual impedence with lambda/2 spacing (ohm)\n", + "\n", + "#Calculation\n", + "pv = (z-r)/(z+r) #Reflection coefficient (unitless)\n", + "vswr = (1+pv)/(1-pv) #Voltage Standing Wave Ratio (unitless)\n", + "gain_l2 =math.sqrt((2*z1)/(z1-z2)) #Field gain over lambda/2 dipole (unitless)\n", + "gain_l2_db = 20*math.log10(gain_l2) #Field gain (in dB)\n", + "gain_iso = (gain_l2**2)*1.64 #Gain over isotropic source (unitless)\n", + "gain_iso_db = 10*math.log10(gain_iso) #Gain over isotropic source (in dB)\n", + "\n", + "#Result\n", + "print \"The VSWR is\", vswr\n", + "print \"The field gain over lambda/2 dipole is\", round(gain_l2,2), \"or\", round(gain_l2_db,1), \"dB\"\n", + "print \"\"\"The gain over isotropic source is %.1f or %.1f dB\n", + " \"\"\" % (round(gain_iso),gain_iso_db)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The VSWR is 1.11\n", + "The field gain over lambda/2 dipole is 1.56 or 3.9 dB\n", + "The gain over isotropic source is 4.0 or 6.0 dB\n", + " \n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 6-8.2, Page number:175<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "z = 73.0 #Self impedence of lambda/2 dipole (ohm)\n", + "zm = 64.4 #Mutual impedence with lambda/8 spacing (ohm)\n", + "\n", + "#Calculation\n", + "D = math.sqrt((2*z)/(z-zm))*math.sin(math.pi/8) #Field gain over lambda/2 dipole (unitless)\n", + "D_db = 20*math.log10(D) #Field gain over lambda/2 dipole (in dB)\n", + "\n", + "gain_iso = (D**2)*1.64 #gain over isotropic source (unitless)\n", + "gain_iso_db = 10*math.log10(gain_iso) #gain over isotropic source (in dB)\n", + "\n", + "#Result\n", + "print \"The field gain over lambda/2 dipole is\", round(D,2), \"or\", round(D_db,2), \"dB\"\n", + "print \"The gain over isotropic source is\", round(gain_iso,2), \"or\", round(gain_iso_db,1), \"dB\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The field gain over lambda/2 dipole is 1.58 or 3.96 dB\n", + "The gain over isotropic source is 4.08 or 6.1 dB\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 6-12.1, Page number: 196<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import sqrt, log10\n", + "\n", + "#Variable declaration\n", + "s1 = 0.4 #Spacing 1(lambda)\n", + "s2 = 0.5 #Spacing 2(lambda)\n", + "s3 = 0.6 #Spacing 3(lambda)\n", + "R_21_1 = 6.3 #Mutual resistance for s1 (ohm)\n", + "R_21_2 = -12.691 #Murual resistance for s2 (ohm)\n", + "R_21_3 = -23.381 #Mutual resistance for s3 (ohm) \n", + "Z = 73.13 #Self impedence of lambda/2 dipole (ohm)\n", + "\n", + "#Calculation\n", + "gain_1 = sqrt(2*(Z/(Z+R_21_1))) #Gain in fieldfor s1 (unitless)\n", + "gain_iso1 = 1.64*(gain_1**2) #Power gain over isotropic (unitless)\n", + "gain_iso_db1 = 10*log10(gain_iso1) #Power gain (in dBi)\n", + "\n", + "gain_2 = sqrt(2*(Z/(Z+R_21_2))) #Gain in fieldfor s2 (unitless)\n", + "gain_iso2 = 1.64*(gain_2**2) #Power gain over isotropic (unitless)\n", + "gain_iso_db2 = 10*log10(gain_iso2) #Power gain (in dBi)\n", + "\n", + "gain_3 = sqrt(2*(Z/(Z+R_21_3))) #Gain in fieldfor s3 (unitless)\n", + "gain_iso3 = 1.64*(gain_3**2) #Power gain over isotropic (unitless)\n", + "gain_iso_db3 = 10*log10(gain_iso3) #Power gain (in dBi)\n", + "\n", + "#Result\n", + "print \"The gain in field over half wave antenna for s1 is\", round(gain_1,2)\n", + "print \"\"\"The power gain over isotropic for s1 is %.2f or %.1f dBi\n", + " \"\"\" % (gain_iso1,gain_iso_db1)\n", + " \n", + "print \"The gain in field over half wave antenna for s2 is\", round(gain_2,2)\n", + "print \"\"\"The power gain over isotropic for s2 is %.2f or %.2f dBi\n", + " \"\"\" % (gain_iso2,gain_iso_db2)\n", + " \n", + "print \"The gain in field over half wave antenna for s3 is\", round(gain_3,2)\n", + "print \"\"\"The power gain over isotropic for s3 is %.2f or %.2f dBi\n", + " \"\"\" % (gain_iso3,gain_iso_db3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The gain in field over half wave antenna for s1 is 1.36\n", + "The power gain over isotropic for s1 is 3.02 or 4.8 dBi\n", + " \n", + "The gain in field over half wave antenna for s2 is 1.56\n", + "The power gain over isotropic for s2 is 3.97 or 5.99 dBi\n", + " \n", + "The gain in field over half wave antenna for s3 is 1.71\n", + "The power gain over isotropic for s3 is 4.82 or 6.83 dBi\n", + " \n" + ] + } + ], + "prompt_number": 7 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter7.ipynb b/Antennas_and_Wave_Propagation/chapter7.ipynb new file mode 100644 index 00000000..6481c2bd --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter7.ipynb @@ -0,0 +1,386 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 7: Loop, Slot and Horn Antennas<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 7-8.1, Page number: 256<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import sqrt,pi,sin,log10\n", + "\n", + "#Variable declaration\n", + "C_lambda = 0.1*pi #Circumference (lambda)\n", + "R_m = 1.6 #Mutual resistance of two loops (ohm)\n", + "theta1 = 90*pi/180 #Angle of radiation (radians)\n", + "theta2 = 2*pi/10 #Angle of radiation (radians)\n", + "\n", + "#Calculation\n", + "Rr = 197*(C_lambda)**4 #Self resistance of loop (ohm)\n", + "D1 = (1.5)*(sin(theta1))**2 #Direcivity of loop alone (unitless)\n", + "D1_db = 10*log10(D1) #Directivity of loop alone (dBi)\n", + "D2 = 1.5*(2*sqrt(Rr/(Rr-R_m))*sin(theta2))**2\n", + " #Directivity of loop with ground plane (unitless)\n", + "D2_db = 10*log10(D2) #Direcitivy of loop with ground plane (dBi)\n", + "\n", + "#Result\n", + "print \"The directivity of loop alone is %.2f or %.2f dBi\" % (D1,D1_db)\n", + "print \"\"\"The direcitivy of loop with ground plane is %.2f or %.0f dBi\n", + " \"\"\" %(D2,D2_db)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The directivity of loop alone is 1.50 or 1.76 dBi\n", + "The direcitivy of loop with ground plane is 12.47 or 11 dBi\n", + " \n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 7-8.2, Page number:257<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import sqrt, sin, pi, log10\n", + "\n", + "#Variable declaration\n", + "Rr = 197.0 #self resistance of loop (ohm)\n", + "Rm = 157.0 #mutual resistance of two loops (ohm)\n", + "theta = 2*pi/10 #Angle of radiation (radians)\n", + "\n", + "#Calculation\n", + "D = 1.5*(2*sqrt(Rr/(Rr-Rm))*sin(theta))**2 #Directivity (unitless)\n", + "D_db = 10*log10(D) #Directivity (dBi)\n", + "\n", + "#Result\n", + "print \"The direcitivy is %.1f or %.1f dBi\" % (D,D_db)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The direcitivy is 10.2 or 10.1 dBi\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 7-11.1, Page number: 261<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi, log10\n", + "\n", + "#Variable declaration\n", + "c = pi #Circumference (m)\n", + "f1 = 1 #Frequency (MHz)\n", + "f2 = 10 #Frequency (MHz)\n", + "d = 10e-3 #Diameter of copper wire (m)\n", + "\n", + "#Calcalation\n", + "RL_Rr1 = 3430/((c**3)*(f1**3.5)*d) \n", + "RL_Rr2 = 3430/((c**3)*(f2**3.5)*d)\n", + " #Ratio of Loss resistance and radiation resistance (unitless\n", + " \n", + "k1 = 1/(1+RL_Rr1) #Radiation efficiency (unitless)\n", + "k_db1 = 10*log10(k1) #Radiation efficiency (in dB)\n", + "k2 = 1/(1+RL_Rr2) #Radiation efficiency (unitless)\n", + "k_db2 = 10*log10(k2) #Radiation efficiency (in dB)\n", + "\n", + "#Result\n", + "print \"The radiation effiency for 1 MHz is %.1ef or %.1f dB\" % (k1, k_db1)\n", + "print \"The radiation effiency for 10 MHz is %.2f or %.1f dB\" % (k2, k_db2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The radiation effiency for 1 MHz is 9.0e-05f or -40.4 dB\n", + "The radiation effiency for 10 MHz is 0.22 or -6.5 dB\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 7-11.2, Page number: 264</h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi,sqrt\n", + "\n", + "#Variable declaration\n", + "n = 10 #Number of turns (unitless)\n", + "dia = 1e-3 #Diameter of copper wire (m)\n", + "dia_rod = 1e-2 #Diameter of ferrite rod (m)\n", + "len_rod = 10e-2 #Length of ferrite rod (m)\n", + "mu_r = 250 - 2.5j #Relative permeability (unitless)\n", + "mu_er = 50 #Efeective relative permeability (unitless)\n", + "f = 1e6 #Frequency (Hz)\n", + "c = 3e8 #Speed of light (m/s)\n", + "mu_0 = pi*4e-7 #Absolute permeability (H/m)\n", + "\n", + "#Calculations\n", + "wave_lt = c/f #Wavelength (m)\n", + "radius = dia_rod/2\n", + "C_l = (2*pi*radius)/(wave_lt) #Circumference of loop (m)\n", + "Rr = 197*(mu_er**2)*(n**2)*(C_l**4) #Radiation resistance (ohm)\n", + "Rf = 2*pi*f*mu_er*(mu_r.imag/mu_r.real)*mu_0*(n**2)*(pi*radius**2)/len_rod #Loss resistance(ohm)\n", + "cond = 1/((7e-5**2)*f*pi*mu_er) #Conductivity (S/m)\n", + "delta = 1/(sqrt(f*pi*mu_er*cond)) #Depth of penetration(m)\n", + "\n", + "RL = n*(C_l/dia)*sqrt((f*mu_0)/(pi*cond)) #Ohmic resistance (ohm)\n", + "k = Rr/(RL+abs(Rf)) #Radiation efficiency (unitless)\n", + "\n", + "L = mu_er*(n**2)*(radius**2)*mu_0/len_rod #Inductance (H)\n", + "Q = 2*pi*f*L/(abs(Rf) + Rr + RL) #Ratio of energy stored to energy lost per cycle (unitless)\n", + "\n", + "fHP = f/Q #Bandwidth at half power (Hz)\n", + "\n", + "\n", + "#Results\n", + "print \"The radiation efficiency is \", round(k,11)\n", + "print \"The value of Q is \", round(Q,3)\n", + "print \"The half-power bandwidth is\", round(fHP), \"Hz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The radiation efficiency is 6.65e-09\n", + "The value of Q is 11.076\n", + "The half-power bandwidth is 90289.0 Hz\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 7-17.1, Page number: 280<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import numpy as np\n", + "\n", + "#Variable declaration\n", + "Z0 = 376.7 #Intrinsic impdence of free space (ohm)\n", + "Zd = 73 + 42.5j #Impedence of infinitesimally thin lambda/2 antenna (ohm)\n", + "\n", + "#Calculation\n", + "Z1 = (Z0**2)/(4*Zd) #Terminal impedence of the lambda/2 slot antenna (ohm)\n", + "\n", + "#Result\n", + "print \"The terminal impedence of the thin lambda/2 slot antenna is\", np.around(Z1), \"ohm\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The terminal impedence of the thin lambda/2 slot antenna is " + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(363-211j) ohm\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 7-17.2, Page number: 280<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Zd = 67 #Terminal impedence of cylindrical antenna (ohm)\n", + "Z0 = 376.7 #Intrinsic impedence of free space (ohm)\n", + "L = 0.475 #Length of complementary slot (lambda)\n", + "\n", + "#Calculation\n", + "Z1 = Z0**2/(4*Zd) #Terminal resistance of complementary slot (ohm)\n", + "w = 2*L/100 #Width of complementary slot (lambda)\n", + "\n", + "#Result\n", + "print \"The terminal resistance of the complementary slot is\", round(Z1), \"ohm\"\n", + "print \"The width of the complementary slot is\", w, \"lambda\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The terminal resistance of the complementary slot is 529.0 ohm\n", + "The width of the complementary slot is 0.0095 lambda\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 7-17.3, Page number: 281<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Zd = 710 #Terminal impdence of cylindrical dipole\n", + "Z0 = 376.7 #Intrinsic impedence of free space (ohm)\n", + "\n", + "#Calculation\n", + "Z1 = Z0**2/(4*Zd) #Terminal resistance of complementary slot (ohm)\n", + "\n", + "#Result\n", + "print \"The terminal resistance of the complementary slot is\", round(Z1),\"ohm\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The terminal resistance of the complementary slot is 50.0 ohm\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 7-20.1, Page number 288<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "delta_e = 0.2 #path length difference in E-plane (lambda)\n", + "delta_h = 0.375 #path length difference in H-plane (lambda)\n", + "a_e = 10 #E-plane aperture (lambda)\n", + "\n", + "\n", + "#Calculation\n", + "L = a_e**2/(8*delta_e) #Horn length(lambda)\n", + "theta_e = 2*math.atan2(a_e,2*L)*180/math.pi #Flare angle in E-plane (degrees)\n", + "theta_h = 2*math.acos(L/(L+delta_h))*180/math.pi\n", + " #Flare angle in the H-plane (degrees)\n", + "a_h = 2*L*math.tan(theta_h/2*math.pi/180) #H-plane aperture (lambda)\n", + "\n", + "hpbw_e = 56/a_e #Half power beamwidth in E-plane (degrees)\n", + "hpbw_h = 67/a_h #Half power beamwidth in H-plane (degrees)\n", + "\n", + "D = 10*math.log10(7.5*a_e*a_h) #Directivity (dB)\n", + "\n", + "#Result\n", + "print \"The length of the pyramidal horn is\", L,\"lambda\"\n", + "print \"The flare angles in E-plane and H-plane are\", round(theta_e,1),\"and\", round(theta_h,2), \"degrees\"\n", + "print \"The H-plane aperture is\", round(a_h,1), \"lambda\"\n", + "print \"The Half power beamwidths in E-plane and H-plane are\", hpbw_e,\"&\",round(hpbw_h,1),\\\n", + "\"degrees\"\n", + "print \"The direcivity is\", round(D,1),\"dBi\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The length of the pyramidal horn is 62.5 lambda\n", + "The flare angles in E-plane and H-plane are 9.1 and 12.52 degrees\n", + "The H-plane aperture is 13.7 lambda\n", + "The Half power beamwidths in E-plane and H-plane are 5 & 4.9 degrees\n", + "The direcivity is 30.1 dBi\n" + ] + } + ], + "prompt_number": 10 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter8.ipynb b/Antennas_and_Wave_Propagation/chapter8.ipynb new file mode 100644 index 00000000..3c5e8930 --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter8.ipynb @@ -0,0 +1,192 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 8: Helical Antennas<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 8-5.1, Page number: 309<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import sqrt\n", + "\n", + "#Variable declaration\n", + "w = 5 #Width of flattened tubing at termination (mm)\n", + "Er = 2.7 #Relative permittivity of the sheet\n", + "Z0 = 50 #Characteristic impdence of the sheet\n", + "\n", + "#Calculation\n", + "h = w/((377/(sqrt(Er)*Z0))-2)\n", + "\n", + "#Result\n", + "print \"The required thickness of the polystyrene sheet is\", round(h,1),\"mm\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The required thickness of the polystyrene sheet is 1.9 mm\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 8-5.2, Page number:315<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import sqrt, log10\n", + "\n", + "#Variable declaration\n", + "n = 16.0 #Number of turns (unitless)\n", + "C = 1 #Circumference (lambda)\n", + "S = 0.25 #Turn Spacing (lambda)\n", + "\n", + "#Calculation\n", + "hpbw = 52/(C*sqrt(n*S)) #Half power beamwidth (degrees)\n", + "ax_rat = (2*n + 1)/(2*n) #Axial ratio (unitless)\n", + "gain = 12*(C**2)*n*S #Gain of antenna (unitless)\n", + "gain_db = 10*log10(gain) #Gain of antenna (in dBi)\n", + "\n", + "print \"The half power beam width is\", hpbw, \"degrees\"\n", + "print \"The axial ratio is\", round(ax_rat,2)\n", + "print \"The gain is\", gain,\"or\",round(gain_db,1),\"dBi\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The half power beam width is 26.0 degrees\n", + "The axial ratio is 1.03\n", + "The gain is 48.0 or 16.8 dBi\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 8-5.3, Page number:316<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi, sqrt, log10\n", + "\n", + "#Variable declaration\n", + "n = 10.0 #Number of turns (unitless)\n", + "S = 0.236 #Spacing between turns (lambda)\n", + "n_a = 4.0 #Number of helical antennas in the array (unitless)\n", + "\n", + "#Calculation\n", + "D = 12*n*S #Directivity of a single antenna(unitless)\n", + "Ae = D/(4*pi) #Effective aperture (lambda^2)\n", + "\n", + "A = sqrt(Ae) #Area of square/spacing between helixes (lambda)\n", + "Ae_total = Ae*n_a #Total effective aperture (lambda^2)\n", + "D_array = (4*pi*Ae_total) #Directivity of the array (unitless)\n", + "D_array_db = 10*log10(D_array) #Direcitivity of the array (dBi)\n", + "\n", + "#Result\n", + "print \"The best spacing between the helixes is\", round(A,1), \"lambda\"\n", + "print \"The directivity of the array is\", round(D_array),\"or\",round(D_array_db,1),\"dBi\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The best spacing between the helixes is 1.5 lambda\n", + "The directivity of the array is 113.0 or 20.5 dBi\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 8-16.1, Page number:347<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi\n", + "\n", + "#Variable declaration\n", + "gain = 24.0 #Gain (dB)\n", + "alpha = 12.7 #Pitch angle (degrees)\n", + "c_lambda = 1.05 #Circumference (lambda)\n", + "s_lambda = 0.236 #Spacing between turns (lambda)\n", + "\n", + "#Calculation\n", + "D = 10**(gain/10) #Directivity (unitless)\n", + "L = D/(12*(c_lambda**2)) #Helix length (lambda)\n", + "n = L/s_lambda #Number of turns (unitless)\n", + "D = D/4 #Directivity for four 20-turn helixes(unitless)\n", + "Ae = D/(4*pi) #Effective aperture of each helix (lambda^2)\n", + "\n", + "#Result\n", + "print \"The Axial length is\", round(L),\"lambda\"\n", + "print \"The number of turns for the axial length is\",round(n)\n", + "print \"The effective aperture for 20 turns is\",round(Ae),\"lambda^2\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Axial length is 19.0 lambda\n", + "The number of turns for the axial length is 80.0\n", + "The effective aperture for 20 turns is 5.0 lambda^2\n" + ] + } + ], + "prompt_number": 4 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/chapter9.ipynb b/Antennas_and_Wave_Propagation/chapter9.ipynb new file mode 100644 index 00000000..72d11c5d --- /dev/null +++ b/Antennas_and_Wave_Propagation/chapter9.ipynb @@ -0,0 +1,65 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h1>Chapter 9: Reflector Antennas<h1>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<h3>Example 9-2.1, Page number: 372<h3>" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from math import pi,sqrt\n", + "\n", + "#Variable declaration\n", + "P_transmit = 25000.0 #Power transmitted by station transmitter (W)\n", + "gain_dbi = 29.0 #Gain of array (dBi)\n", + "r = 7500e3 #Distance (m)\n", + "h = 250e3 #Height (m)\n", + "z = 377.0 #Intrinsic impedence of free space (ohm)\n", + "\n", + "#Calculation\n", + "gain = 10**(gain_dbi/10) #Gain of array (unitless)\n", + "erp = gain*P_transmit #Effective radiated power (W)\n", + "p_area = erp/(2*pi*r*h) #power per unit area at distance r (W/m^2)\n", + "field_str = sqrt(p_area*z) #Field strength (mV/m)\n", + "\n", + "#Result\n", + "print \"The effective radiated power is\", round(erp,-5),\"W\"\n", + "print \"The field strength at the distance r is \",round(field_str,3), \"V/m^2\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The effective radiated power is 19900000.0 W\n", + "The field strength at the distance r is 0.025 V/m^2\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Antennas_and_Wave_Propagation/screenshots/snapshot1.png b/Antennas_and_Wave_Propagation/screenshots/snapshot1.png Binary files differnew file mode 100644 index 00000000..b06c2235 --- /dev/null +++ b/Antennas_and_Wave_Propagation/screenshots/snapshot1.png diff --git a/Antennas_and_Wave_Propagation/screenshots/snapshot2.png b/Antennas_and_Wave_Propagation/screenshots/snapshot2.png Binary files differnew file mode 100644 index 00000000..79b38b7b --- /dev/null +++ b/Antennas_and_Wave_Propagation/screenshots/snapshot2.png diff --git a/Antennas_and_Wave_Propagation/screenshots/snapshot3.png b/Antennas_and_Wave_Propagation/screenshots/snapshot3.png Binary files differnew file mode 100644 index 00000000..f88bcebb --- /dev/null +++ b/Antennas_and_Wave_Propagation/screenshots/snapshot3.png |
