diff options
| author | Trupti Kini | 2016-04-05 23:30:25 +0600 |
|---|---|---|
| committer | Trupti Kini | 2016-04-05 23:30:25 +0600 |
| commit | c7691a36c0c99334ef3feb4e8729bdf17cf32e4a (patch) | |
| tree | c58e97e4ba283e4276fde73ec68a78153cf0ad6f | |
| parent | b1e702cc6f746c84633093d2a5a11374c485dd31 (diff) | |
| download | Python-Textbook-Companions-c7691a36c0c99334ef3feb4e8729bdf17cf32e4a.tar.gz Python-Textbook-Companions-c7691a36c0c99334ef3feb4e8729bdf17cf32e4a.tar.bz2 Python-Textbook-Companions-c7691a36c0c99334ef3feb4e8729bdf17cf32e4a.zip | |
Added(A)/Deleted(D) following books
A Electronic_Communication_by_D._Roddy/Chapter10_Angle_Modulation.ipynb
A Electronic_Communication_by_D._Roddy/Chapter11_Pulse_Modulation.ipynb
A Electronic_Communication_by_D._Roddy/Chapter12_Digital_Communications.ipynb
A Electronic_Communication_by_D._Roddy/Chapter13_Transmission_Lines_And_Cables.ipynb
A Electronic_Communication_by_D._Roddy/Chapter14_WaveGuides.ipynb
A Electronic_Communication_by_D._Roddy/Chapter15_Radio_Wave_Propogation.ipynb
A Electronic_Communication_by_D._Roddy/Chapter16_Antennas.ipynb
A Electronic_Communication_by_D._Roddy/Chapter17_Telephone_Systems.ipynb
A Electronic_Communication_by_D._Roddy/Chapter18_Fascimile_and_Television.ipynb
A Electronic_Communication_by_D._Roddy/Chapter19_Satellite_Communications.ipynb
A Electronic_Communication_by_D._Roddy/Chapter1_Passive_Circuits.ipynb
A Electronic_Communication_by_D._Roddy/Chapter20_Fibre_Optic_Communication.ipynb
A Electronic_Communication_by_D._Roddy/Chapter2_Waveform_Spectra.ipynb
A Electronic_Communication_by_D._Roddy/Chapter4_Noise.ipynb
A Electronic_Communication_by_D._Roddy/Chapter5_Tuned_Small_Signal_Amplifiers,_Mixers_and_Active_Filters.ipynb
A Electronic_Communication_by_D._Roddy/Chapter6_Oscillators.ipynb
A Electronic_Communication_by_D._Roddy/Chapter7_Receivers.ipynb
A Electronic_Communication_by_D._Roddy/Chapter8_Amplitude_Modulation.ipynb
A Electronic_Communication_by_D._Roddy/Chapter9_Single_Sideband_Modulation.ipynb
A Electronic_Communication_by_D._Roddy/screenshots/1.png
A Electronic_Communication_by_D._Roddy/screenshots/12.png
A Electronic_Communication_by_D._Roddy/screenshots/9.png
A Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter11_Control_of_DC_Motors_1.ipynb
A Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter12_Controllers_and_Their_Optimisation_1.ipynb
A Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter13_Choppers_and_Transportation_system_Application_1.ipynb
A Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter15_The_AC_motor_control_1.ipynb
A Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter16_Faults_and_Protection_1.ipynb
A Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter3_Fabrication_and_Thermal_characteristics_1.ipynb
A Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter4_Series_and_Parallel_Connection_of_Thyristors_1.ipynb
A Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter5_Line_Commutated_converters_1.ipynb
A Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter7_Inverter_Circuits_1.ipynb
A Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter8_Harmonic_and_PowerFactor_with_the_converter_system_1.ipynb
A Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter_2_The_Device__1.ipynb
A Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/screenshots/11.JPG
A Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/screenshots/15.JPG
A Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/screenshots/8.JPG
36 files changed, 7854 insertions, 0 deletions
diff --git a/Electronic_Communication_by_D._Roddy/Chapter10_Angle_Modulation.ipynb b/Electronic_Communication_by_D._Roddy/Chapter10_Angle_Modulation.ipynb new file mode 100644 index 00000000..5311facc --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter10_Angle_Modulation.ipynb @@ -0,0 +1,109 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter10 Angle Modulation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.12.1,Pg.no.343" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The equivaent tuning capacitance is 6e-10 F\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "p=10.0\n", + "t=0.3*10**-6\n", + "gm=0.002\n", + "q=1/p\n", + "f_max=q/(2*pi*t)\n", + "Z2=p/gm\n", + "R2=Z2 #Z2 is resistance\n", + "#Determination of equivalent tuning capacitance\n", + "C1=t/R2\n", + "Ceq=gm*t\n", + "print 'The equivaent tuning capacitance is',Ceq,'F'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.13.1,Pg.no.349" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fo is best obtained by using two tripler 79.1 Mhz\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "del_phi_d=12.0\n", + "f_min=100.0\n", + "del_f_max_allow =15000.0\n", + "del_phi_rad=(12*pi)/180\n", + "del_f_max=del_phi_rad*f_min\n", + "#Determination of freq deviation\n", + "N=del_f_max_allow/del_f_max\n", + "l=del_f_max*729 #using six tripler\n", + "f=0.1*729\n", + "#Determination of signal oscillator signal\n", + "fo=152-f\n", + "print 'fo is best obtained by using two tripler',fo,'Mhz'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter11_Pulse_Modulation.ipynb b/Electronic_Communication_by_D._Roddy/Chapter11_Pulse_Modulation.ipynb new file mode 100644 index 00000000..f9a35e7b --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter11_Pulse_Modulation.ipynb @@ -0,0 +1,101 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter11 Pulse Modulation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 11.3.1,Pg.no.392" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The no . of bits per code word is 7.512\n", + "Rounded off to 8\n" + ] + } + ], + "source": [ + "import math\n", + "SNR=40.0\n", + "#a) Determination of no . of bits /code\n", + "n=(SNR -(10*math.log10(3))-(-10))/(20*math.log10(2))\n", + "n=round(n,3)\n", + "print 'The no . of bits per code word is',n\n", + "print 'Rounded off to 8'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 11.3.2,Pg.no.393" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a)The transmission BW is 64000.0 Hz\n", + "b)The quantization S/N ration is 48.0\n" + ] + } + ], + "source": [ + "import math\n", + "q=1.0\n", + "W=4*10**3\n", + "n=8.0\n", + "#a) Determination of Tx Bandwidth\n", + "B=(1+q)*W*n\n", + "print 'a)The transmission BW is',B,'Hz'\n", + "#b) Determination of quantization S/N ratio\n", + "SN_dB=6*n\n", + "print 'b)The quantization S/N ration is',SN_dB" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter12_Digital_Communications.ipynb b/Electronic_Communication_by_D._Roddy/Chapter12_Digital_Communications.ipynb new file mode 100644 index 00000000..6ee4bd31 --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter12_Digital_Communications.ipynb @@ -0,0 +1,334 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter12 Digital Communications" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.4.1,Pg.no.419" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a= 1.0\n", + "b= 6.33 *10**-5\n", + "The bit error probability 3.17 *10**-5\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt,erf,erfc\n", + "Vs_Vn=4 #SNVR \n", + "a=erf(4/sqrt(2))\n", + "b=erfc(4/sqrt(2))*10**5\n", + "Pbe=(0.5)*(b) #bit error probability\n", + "a=round(a,2)\n", + "b=round(b,2)\n", + "print 'a=',a\n", + "print 'b=',b,'*10**-5'\n", + "Pbe=round(Pbe,2)\n", + "print 'The bit error probability',Pbe,'*10**-5'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.4.2,Pg.no.420" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The bit error probability 0.309\n" + ] + } + ], + "source": [ + "import math\n", + "A=4 #max value of received signal voltage\n", + "Vn=0.5 #rms noise voltage\n", + "Vth=2 #Threshold voltage for the comparator\n", + "b=erfc(Vn/sqrt(2))\n", + "Pbe=(0.5) * b #bit error probability\n", + "Pbe=round(Pbe,3)\n", + "print 'The bit error probability',Pbe " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.4.3,Pg.no.421" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bit Probabilty,Pbe1= 0.0024\n", + "Bit Probability,Pbe2= 0.0232\n" + ] + } + ], + "source": [ + "import math\n", + "from math import erfc\n", + "SNR=9.0 #SNR in dB\n", + "#conversion of dB to power ratio\n", + "p=10**(9/10) #for Polar\n", + "Pbe1=0.5*erfc(sqrt(7.94/2))\n", + "Pbe1=round(Pbe1,4)\n", + "print 'Bit Probabilty,Pbe1=',Pbe1\n", + "#for Unipolar\n", + "Pbe2=0.5* erfc(sqrt(7.94)/2)\n", + "Pbe2=round(Pbe2,4)\n", + "print 'Bit Probability,Pbe2=',Pbe2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.5.1,Pg.no.423" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The bit error probability 3.5 *10**-5\n" + ] + } + ], + "source": [ + "import math\n", + "Pavg=6.0*10**-12 #in W\n", + "d=0.02*10**-6 #pulse duration in sec\n", + "T=550.0 #equivalent noise temp in K\n", + "Eb=Pavg*d #avg energy per pulse\n", + "No=1.38*10**-23*T\n", + "r=Eb/No #Bit error probability is\n", + "Pbe=0.5*erfc(sqrt(r/2))*10**5\n", + "Pbe=round(Pbe,1)\n", + "print 'The bit error probability',Pbe,'*10**-5' " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.9.1,Pg.no.435" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a)The bit error probability 0.00078\n", + "b)The bit error probability 0.00337\n" + ] + } + ], + "source": [ + "import math\n", + "from math import exp\n", + "ENR=10.0 #energy to noise density ratio\n", + "Pbe1=0.5* erfc(sqrt(ENR/2))\n", + "Pbe1=round(Pbe1,5)\n", + "print 'a)The bit error probability',Pbe1\n", + "Pbe2=(0.5)*exp(-(ENR/2))\n", + "Pbe2=round(Pbe2,5)\n", + "print 'b)The bit error probability',Pbe2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.13.1,Pg.no.451" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The probability of a received codeword 5.33 *10**5\n", + "P_in= 5.6 *10**5\n" + ] + } + ], + "source": [ + "import math\n", + "Pbec=0.01\n", + "n=8.0\n", + "i=3.0\n", + "Pi=(Pbec**i)*((1-(Pbec))**(n-i))\n", + "Cin=(math.factorial(n))/(math.factorial(i)*math.factorial(n-i))\n", + "Pin=Cin*Pi*10**5\n", + "P_in=Cin*Pbec**i*10**5\n", + "Pin=round(Pin,2)\n", + "P_in=round(P_in,2)\n", + "print 'The probability of a received codeword',Pin,'*10**5'\n", + "print 'P_in=',P_in,'*10**5'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.13.3,Pg.no.454" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a)The bit error probability 0.079\n", + "b)The bit error probability 2.25\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt,erf\n", + "SN_dB=9\n", + "SNR=10**(SN_dB/10)\n", + "PbeU=0.5 * (1-erf(sqrt(SNR)))\n", + "BERu=PbeU\n", + "BERu=round(BERu,3)\n", + "print 'a)The bit error probability',BERu\n", + "n=10\n", + "k=n-1\n", + "r=k/n\n", + "SNR1=r*SNR\n", + "PbeC=0.5 *(1-erf(sqrt(SNR1)))\n", + "BERc=(n-1)*PbeC**2\n", + "print 'b)The bit error probability',BERc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.13.4,Pg.no.457" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a)The bit−error rate is 0.079\n", + "b)The new bit error rate is 3.5\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt\n", + "SN_dB=8\n", + "SNR=10**(SN_dB/10) #a) Determination of bit error rate\n", + "PbeU=0.5*(1-erf(sqrt(SNR)))\n", + "BER_U=PbeU\n", + "BER_U=round(BER_U,3)\n", + "print 'a)The bit−error rate is',BER_U\n", + "#b)new bit error rate\n", + "n=15\n", + "k=11\n", + "t=1\n", + "r=k/n\n", + "SNR_n=r*SNR\n", + "PbeC=0.5*(1-erf(sqrt(SNR_n)))\n", + "BER_C=((math.factorial(n-1))*PbeC**(t+1))/((math.factorial(t)) *(math.factorial(n-t-1)))\n", + "print 'b)The new bit error rate is',BER_C " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter13_Transmission_Lines_And_Cables.ipynb b/Electronic_Communication_by_D._Roddy/Chapter13_Transmission_Lines_And_Cables.ipynb new file mode 100644 index 00000000..38e1d0d6 --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter13_Transmission_Lines_And_Cables.ipynb @@ -0,0 +1,290 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter13 Transmission Lines And Cables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 13.5.2,Pg.no.475" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The attenuation coeff is 0.005 dB/m\n", + "The attenuation coeff is 8.04 dB/mile\n" + ] + } + ], + "source": [ + "import math\n", + "a=0.0006 #The attenuation coeff in N/m\n", + "#a) Determinaion of the attenuation coeff in dB/m\n", + "a_dB=8.686*a\n", + "a_dB=round(a_dB,3)\n", + "print 'The attenuation coeff is',a_dB,'dB/m'\n", + "#b) Determination of attenuation coeff in dB/mile\n", + "k=1609 #conversion coeff for meter to mile\n", + "a_dB_mile=k*a_dB\n", + "a_dB_mile=round(a_dB_mile,2)\n", + "print 'The attenuation coeff is',a_dB_mile,'dB/mile'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 13.10.1,Pg.no.485" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a)The equivalent series resistance is 37.15 ohm\n", + " The equivalent series reactance is 27.63 ohm\n", + "b)The equivalent parallel resistance is 57.7 ohm\n", + " The equivalent parallel reactance is -77.57 ohm\n" + ] + } + ], + "source": [ + "import math\n", + "Z0=50.0 #measured in ohm\n", + "VSWR=2.0\n", + "d=0.2 #distance from load to firstt minimum\n", + "T=(VSWR -1)/(VSWR+1)\n", + "pi=180.0\n", + "Ql=pi*(4*0.2-1) #using Euler’s identity\n", + "e=complex(math.cos(Ql),math.sin(Ql)) #expansion for e ˆ( jQl )\n", + "a=T*e \n", + "#Load impedance is given as\n", + "ZL=Z0*(1+a)/(1-a)\n", + "Zlr=round(ZL.real,2)\n", + "Zli=round(ZL.imag,2)\n", + "print 'a)The equivalent series resistance is',Zlr,'ohm'\n", + "print ' The equivalent series reactance is',Zli,'ohm'\n", + "Yl=1/ZL\n", + "Yl1=round(1/Yl.real,2)\n", + "Yli=round(1/Yl.imag,2)\n", + "print 'b)The equivalent parallel resistance is',Yl1,'ohm'\n", + "print ' The equivalent parallel reactance is',Yli,'ohm'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 13.11.1,Pg.no.488" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The equivalent inductive reactance is 36.33 j ohm\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "d=0.1 #length of 50ohm short−circuited line\n", + "Z0=50 #in ohm\n", + "f=500*10**6 #freq in Hz\n", + "Bl=2*pi*d \n", + "#a) Determination of equivalent inductive reactance\n", + "Z=complex(0,Z0*math.tan(Bl))\n", + "Z=round(Z.imag,2)\n", + "print 'The equivalent inductive reactance is',Z,'j','ohm'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 13.17.1,Pg.no.513" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a) The equivalent series resistance is 46.93 ohm\n", + " The equivalent series reactance is 17.24 ohm\n", + "b) The equivalent parallel resistance is 53.27 ohm\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "VSWR=2.0\n", + "l_min=0.2\n", + "Z0=50.0\n", + "Ql=((4*l_min )-1)*pi\n", + "tl=(VSWR -1)/(VSWR+1)\n", + "Tl=complex(0,tl*math.e**(Ql))\n", + "Zl=Z0*(1+Tl)/(1-Tl)\n", + "Zr=round(Zl.real,2)\n", + "Zm=round(Zl.imag,2)\n", + "print 'a) The equivalent series resistance is',Zr,'ohm' \n", + "print ' The equivalent series reactance is',Zm,'ohm'\n", + "Yl=1/Zl\n", + "Yl=1/Yl.real\n", + "Yl=round(Yl,2)\n", + "print 'b) The equivalent parallel resistance is',Yl,'ohm'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 13.17.2,Pg.no.514" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The input impedance is 50.0 + -2.87e-05 j ohm\n" + ] + } + ], + "source": [ + "import math\n", + "ZL=complex(30,0)-complex(0,23)\n", + "l=0.5 #length of line in m\n", + "Z0=50.0 #characteristic impedance in ohm\n", + "wl=0.45 #wavelength on the line in m\n", + "B=2*pi/wl\n", + "Tl=(ZL-Z0)/(ZL+Z0)\n", + "VI=1.0 #reference voltage in volt\n", + "VR=VI*Tl\n", + "z=complex(B*l)\n", + "Vi=VI*math.e**(z)\n", + "Vr=VR*math.e**(-z)\n", + "V=Vi+Vr\n", + "I=(Vi-Vr)/Z0\n", + "Z=V/I\n", + "Z1=round(Z.real,2)\n", + "Zi=Z.imag*10**5\n", + "Zi=round(Zi,2)*10**-5\n", + "print 'The input impedance is',Z1,'+',Zi,'j','ohm'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 13.17.3,Pg.no.515" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The input impedance is (73+0j) ohm\n", + "The VSWR is 0.12 + 0.0 j\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi,sqrt\n", + "Z0=600.0\n", + "Zl=73.0 #in ohm\n", + "F=0.9\n", + "QF=(2*pi*F)/4 \n", + "#For matching , the effective load impedance on the main line must equal the characteristic impedance of the mail line\n", + "Zl1=Zl\n", + "Z01=sqrt(Zl1*Zl)\n", + "Tl=(Zl-Z01)/(Zl+Z01)\n", + "VI=1 #reference voltage\n", + "Vi=VI*math.e**(complex(0,QF));\n", + "Vr=Tl*VI*math.e**-(complex(0,QF))\n", + "V_in=Vi+Vr\n", + "I_in=(Vi-Vr)/Z01\n", + "Z_in=V_in/I_in\n", + "print'The input impedance is',Z_in,'ohm'\n", + "#the voltage reflection coeff is\n", + "TL_F=(Z_in -Z0)/(Z_in+Z0)\n", + "#the VSWr is given as\n", + "VSWR_F=(1+TL_F)/(1-TL_F)\n", + "VSWR_Fr=round(VSWR_F.real,2)\n", + "VSWR_Fi=VSWR_F.imag\n", + "print 'The VSWR is',VSWR_Fr,'+',VSWR_Fi,'j'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter14_WaveGuides.ipynb b/Electronic_Communication_by_D._Roddy/Chapter14_WaveGuides.ipynb new file mode 100644 index 00000000..2010222d --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter14_WaveGuides.ipynb @@ -0,0 +1,78 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter14 WaveGuides" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 14.2.1,Pg.no.524" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "i)TE10 wave will propogate because (wl_c >wl)\n", + "Guide wavelength is 3.98 cm\n", + "Phase velocity is 39800.0 *10**6 m/s\n", + "Group velocity is 2261306.53 m/s\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt\n", + "a=2.286 #in cm\n", + "wl_c=2.0*a*10**-2 #in m\n", + "c=3.0*10**8\n", + "wl=c/10**10 #in m\n", + "print 'i)TE10 wave will propogate because (wl_c >wl)'\n", + "#determination of gide wl\n", + "wl_g=10**2*(wl/(sqrt(1-(wl/wl_c)**2.0)))\n", + "wl_g=round(wl_g,2)\n", + "print 'Guide wavelength is',wl_g,'cm'\n", + "#determination of phase velocity\n", + "vp=c*wl_g/wl*10**-6\n", + "print 'Phase velocity is',vp,'*10**6 m/s' \n", + "#determination of group velocity\n", + "vg=c*wl/wl_g\n", + "vg=round(vg,2)\n", + "print 'Group velocity is',vg,'m/s'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter15_Radio_Wave_Propogation.ipynb b/Electronic_Communication_by_D._Roddy/Chapter15_Radio_Wave_Propogation.ipynb new file mode 100644 index 00000000..3cb6638e --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter15_Radio_Wave_Propogation.ipynb @@ -0,0 +1,277 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter15 Radio Wave Propogation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.2.1,Pg.no.538" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The free−space transmission loss is 195.67\n", + "The received power 5.42e-12 watts\n" + ] + } + ], + "source": [ + "import math\n", + "ht=36000 #height of satellite in km\n", + "f=4000 #freq used in MHz\n", + "Gt=15.0 #transmitting antenna gain\n", + "Gr=45.0 #receiving antenna gain\n", + "#A) Determination of free−space transmission loss\n", + "L=32.5+20*math.log10(ht)+20*math.log10(f)\n", + "L=round(L,2)\n", + "print 'The free−space transmission loss is',L\n", + "#B) Determination of received power Pr\n", + "Pt=200.0 #transmitted power in watt\n", + "Pr_Pt=Gt+Gr-L #power ration in dB\n", + "Pr_Pt_watt=10**(Pr_Pt/10) #power ratio in watts\n", + "#Therefore \n", + "Pr=Pt*Pr_Pt_watt*10**12\n", + "Pr=round(Pr,2)*10**-12\n", + "print 'The received power',Pr,'watts'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.2.2,Pg.no.539" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The open−ckt voltage induced is 282.42 uV\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi,sqrt\n", + "Pr=10.0 #radiated power in watt\n", + "f=150.0 #freq used in MHz\n", + "d2=50.0 #distance of dipole in km\n", + "#Therefore open−ckt voltage induced is given as\n", + "Vs=sqrt(30*Pr*1.64)/(d2*10**3)*2/pi\n", + "Vs=Vs*10**6\n", + "Vs=round(Vs,2)\n", + "print 'The open−ckt voltage induced is',Vs,'uV'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.3.1,Pg.no.545" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Field strength at a receiving antenna is 11.02 uV/m\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "Pt=100 #transmitted power\n", + "f=150 #freq used in MHz\n", + "d1=20 #height of transmitting antenna in m\n", + "Gt=1.64 #transmitting antenna gain\n", + "ht=2 #height of receiving antenna in m\n", + "d2=40 #distance in km\n", + "c=3*10**8\n", + "wl=c/(f*10**6)\n", + "E0=sqrt(30*Pt*Gt) #Field strength at a receiving antenna is\n", + "ER=(E0*4*pi*d1*ht)/(wl*(d2*10**3)**2)\n", + "ER=ER*10**6\n", + "ER=round(ER,2)\n", + "print 'Field strength at a receiving antenna is',ER,'uV/m'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.3.2,Pg.no.548" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The maximum range is 25.1 miles\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt\n", + "ht1=100\n", + "ht2=60 #antenna heights in ft\n", + "dmax_miles=sqrt(2*ht1)+sqrt(2*ht2)\n", + "dmax_miles=round(dmax_miles,2)\n", + "print 'The maximum range is',dmax_miles,'miles' " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.4.1,Pg.no.560" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "d= 178.8 km\n", + "d= 10382.4 km\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "ht=200 #virtual height in km\n", + "a=6370 #in km\n", + "B_degree=20\n", + "B_rad=20*pi/180 #angle of elevation in degree\n", + "#The flat−earth approximation gives\n", + "d=2*ht/math.tan(B_degree)\n", + "d=round(d,1)\n", + "print 'd=',d,'km'\n", + "#By using radian measures for all angles\n", + "d=2*a*(((pi/2)-B_rad)-(math.asin(a*math.cos(B_degree)/(a+ht) )))\n", + "d=round(d,1)\n", + "print 'd=',d,'km'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.7.1,Pg.no.574" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The attenuation coeff is 0.04 N/m\n", + "The attenuation coeff in dB/m is 0.347 dB/m\n", + "The attenuation coeff is 4.0 N/m\n", + "The attenuation coeff in dB/m is 34.7 dB/m\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi,sqrt\n", + "conductivity = 4 #measured in S/m\n", + "rel_permittivity =80\n", + "u=4*pi*10**-7\n", + "f1=100 #measured in Hz\n", + "f2=10**6 #measured in Hz\n", + "#A)first it is necessary to evaluate the ratio of conductivity /w*rel permittivity\n", + "w1=2*pi*f1\n", + "r=conductivity/w1*rel_permittivity\n", + "#Therefore we have to use following eq to calculate the attenuation coeff as\n", + "a=sqrt(w1*conductivity*u/2)\n", + "a=round(a,3)\n", + "print 'The attenuation coeff is',a,'N/m'\n", + "#By using the conversion factor N=8.686 dB\n", + "a_dB=a*8.686\n", + "a_dB=round(a_dB,3)\n", + "print 'The attenuation coeff in dB/m is',a_dB,'dB/m'\n", + "w2=2*pi*f2\n", + "r=conductivity/w2*rel_permittivity\n", + "a=sqrt(w2*conductivity*u/2)\n", + "a=round(a,1)\n", + "print 'The attenuation coeff is',a,'N/m'\n", + "#By using the conversion factor 1N=8.686 dB\n", + "a_dB=a*8.686\n", + "a_dB=round(a_dB,1)\n", + "print 'The attenuation coeff in dB/m is',a_dB,'dB/m'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter16_Antennas.ipynb b/Electronic_Communication_by_D._Roddy/Chapter16_Antennas.ipynb new file mode 100644 index 00000000..9718189b --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter16_Antennas.ipynb @@ -0,0 +1,150 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter16 Antennas" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 16.7.2,Pg.no.590" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The −3dB beamwidth is 90.0 degree\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt\n", + "g_x=0.5\n", + "x=math.asin(sqrt(g_x))\n", + "g_y=0.5\n", + "y1=math.asin(sqrt(g_y))\n", + "y=y1+90\n", + "#Therefore\n", + "z=y-x\n", + "print 'The −3dB beamwidth is',z,'degree'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 16.9.1,Pg.no.597" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "l_effective= 0.32\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "Io=1\n", + "wl=1\n", + "phy_length=wl/2\n", + "I_av=2*Io/pi\n", + "#Thus area is given as\n", + "Area=I_av*phy_length\n", + "l_eff=wl/pi\n", + "l_eff=round(l_eff,2)\n", + "#From the above eq l_effective is given as\n", + "print 'l_effective=',l_eff" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 16.19.1,Pg.no.621" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Effective area is 18.38 m**2\n", + "The directivity is 256633.2\n", + "The −3dB beamwidth is 0.35 degree\n", + "The null beamwidth is 0.7 degree\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "D=6.0 #reflector diameter in m\n", + "n=0.65 #illumination effeciency\n", + "f=10**10 #frequency of operation in Hz\n", + "c=3*10**8 #velo of light in m/s\n", + "wl=0.03 #c/f\n", + "A=(pi*D**2)/4\n", + "A_eff=n*A\n", + "A_eff=round(A_eff,2)\n", + "print 'Effective area is',A_eff,'m**2'\n", + "D0=(4*pi*A_eff)/wl**2\n", + "D0=round(D0,1)\n", + "print 'The directivity is',D0\n", + "BW_dB=70*wl/D\n", + "print 'The −3dB beamwidth is',BW_dB,'degree'\n", + "BW_null=2*BW_dB\n", + "print 'The null beamwidth is',BW_null,'degree' " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter17_Telephone_Systems.ipynb b/Electronic_Communication_by_D._Roddy/Chapter17_Telephone_Systems.ipynb new file mode 100644 index 00000000..b2ca6c1b --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter17_Telephone_Systems.ipynb @@ -0,0 +1,82 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter17 Telephone Systems" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 17.1.1,Pg.no.641" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a)The max gain is 44.0 dB\n", + "b)The max gain is 30 dB\n", + "c)The amplr gain is 27.0 dB\n" + ] + } + ], + "source": [ + "import math\n", + "FTL=50\n", + "M=12\n", + "NFL=2*FTL\n", + "NFLG=(NFL-M)\n", + "G_max1=NFLG/2\n", + "G_max1=round(G_max1,1)\n", + "print 'a)The max gain is',G_max1,'dB' \n", + "#b) Determination of max gain2 \n", + "IL=3\n", + "RLW=20\n", + "RLE=40\n", + "NL=(4*IL)+RLW+RLE\n", + "NLG=(NL-M)\n", + "G_max2=NLG/2\n", + "print 'b)The max gain is',G_max2,'dB' \n", + "#c ) Determination of amplr gain\n", + "LT=15.0\n", + "OM=6.0\n", + "OLW=(RLW-LT)/2\n", + "OLE=(RLE-LT)/2\n", + "A=OM+OLW+OLE+(2*IL)\n", + "print 'c)The amplr gain is',A,'dB'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter18_Fascimile_and_Television.ipynb b/Electronic_Communication_by_D._Roddy/Chapter18_Fascimile_and_Television.ipynb new file mode 100644 index 00000000..ed4c9ac9 --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter18_Fascimile_and_Television.ipynb @@ -0,0 +1,307 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter18 Fascimile and Television" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 18.2.1,Pg.no.671" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The index of co−operation is 1105.84\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "#given\n", + "D=70.4\n", + "P=0.2 \n", + "#Determination of index of co−operation\n", + "IOC_CCITT=D/P\n", + "IOC_IEEE=IOC_CCITT*(pi)\n", + "IOC_IEEE=round(IOC_IEEE,2)\n", + "print 'The index of co−operation is',IOC_IEEE" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 18.2.2,Pg.no.676" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The no . of pixels in scan line is 826.0 pixels/line \n", + "The scan rate is 2 lines/sec \n", + "The pixel rate is 1652.0 pixels/sec\n", + "The document Transmission time is 8 sec\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "D=68.4\n", + "P=0.26\n", + "rpm=120\n", + "n=1075\n", + "#Determination of no . of pixels scan\n", + "Npx=(pi)*(D/P)\n", + "Npx=round(Npx,0)\n", + "print 'The no . of pixels in scan line is',Npx,'pixels/line ' \n", + "#Determination of scan rate\n", + "Rs=rpm/60\n", + "print 'The scan rate is',Rs,'lines/sec '\n", + "#Determination of pixel rate is\n", + "Rpx=Npx*Rs\n", + "Rpx=round(Rpx,0)\n", + "print 'The pixel rate is',Rpx,'pixels/sec'\n", + "f_max=Rpx/2\n", + "#Determination of document Tx time\n", + "td=n/(60*Rs)\n", + "print 'The document Transmission time is',td,'sec'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 18.3.1,Pg.no.693" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The no . of pixel periods in line period is 485 lines\n", + "The picture height is 485 pixels\n", + "The picture length is 580.8 pixels\n" + ] + } + ], + "source": [ + "import math\n", + "a=(4/3) #aspect ratio\n", + "N=525 #no . of line periods per frame\n", + "Ns=40 #no . of suppressed lines\n", + "#Determination of no . of pixel periods in line period\n", + "Nv=N-Ns\n", + "print 'The no . of pixel periods in line period is',Nv,'lines'\n", + "#Determination of picture height and width\n", + "Nh=a*Nv\n", + "print 'The picture height is',Nh,'pixels'\n", + "Nl=(Nh/0.835)\n", + "Nl=round(Nl,1)\n", + "print 'The picture length is',Nl,'pixels'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 18.3.2,Pg.no.694" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The horizontal frequency is 15750.0 Hz\n", + "The vertical frequency is 60.0 Hz\n", + "The time required to scan one line is 6.35e-05 sec\n" + ] + } + ], + "source": [ + "import math\n", + "N=525.0\n", + "P=30.0\n", + "#Determination of horizontal and vertical synchhronization freq .\n", + "fh=N*P\n", + "print 'The horizontal frequency is',fh,'Hz'\n", + "fv=2*P\n", + "print 'The vertical frequency is',fv,'Hz'\n", + "#Determination of time reqd to scan one line\n", + "Th=((fh)**-1)*10**5\n", + "Th=round(Th,2)*10**-5\n", + "print 'The time required to scan one line is',Th,'sec'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 18.3.3,Pg.no.695" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the band width is 4272187.5 Hz\n" + ] + } + ], + "source": [ + "import math\n", + "fh=15750\n", + "Nl=775\n", + "#Determination of video bandwidth\n", + "Bv=0.35*fh*Nl\n", + "Bv=round(Bv,1)\n", + "print 'the band width is',Bv,'Hz'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 18.7.1,Pg.no.706" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The viewing angle is 10.78 degrees\n", + "The min.viewing dist is -0.14 m\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt\n", + "a=4/3 #aspect ratio\n", + "D=48.26*10**-2 #CRT tube diagonal\n", + "Nh=647.0\n", + "H=sqrt((a**2)*(D**2)/(1+a**2))\n", + "#Determination of viewing angle & minimum distance\n", + "w=H/Nh\n", + "theta=Nh*(1/60.0) #As each pixel subtend 1 minute of arc\n", + "theta=round(theta,2)\n", + "print 'The viewing angle is',theta,'degrees' \n", + "X=H/(2*math.tan(theta/2))\n", + "X=round(X,2)\n", + "print 'The min.viewing dist is',X,'m'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 18.7.2,Pg.no.707" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The viewing angle is 30.67 degrees\n", + "The viewing dist is -1.27 m\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt\n", + "a=16/9\n", + "D=1.40\n", + "Nh=1840.0 #Assuming square pixel\n", + "H=sqrt((a**2)*(D**2)/(1+a**2))\n", + "#Determination of viewing angle\n", + "theta=Nh*(1/60.0)\n", + "theta=round(theta,2)\n", + "print 'The viewing angle is',theta,'degrees'\n", + "#Determination of viewing dist\n", + "X=H/(2*math.tan(theta/2));\n", + "X=round(X,2)\n", + "print 'The viewing dist is',X,'m'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter19_Satellite_Communications.ipynb b/Electronic_Communication_by_D._Roddy/Chapter19_Satellite_Communications.ipynb new file mode 100644 index 00000000..178a9c6c --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter19_Satellite_Communications.ipynb @@ -0,0 +1,184 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter19 Satellite Communications" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 19.14.1,Pg.no.737" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The carrier to noise ratio in dB is 93.88\n" + ] + } + ], + "source": [ + "import math\n", + "#given\n", + "P_HPA=600.0\n", + "TFL_dB=1.5\n", + "G_dB_ES=50.0\n", + "RFL_dB=1\n", + "GTR_dB_SAT =-8\n", + "FSL_dB=200\n", + "AML_dB=0.5\n", + "PL_dB=0.5\n", + "AA_dB=1\n", + "#Determination of carrier to noise ratio\n", + "P_dB_HPA=10*math.log10(P_HPA/1)\n", + "EIRP_dB=P_dB_HPA -TFL_dB+G_dB_ES\n", + "TPL_dB=FSL_dB+AML_dB+PL_dB+AA_dB\n", + "CNoR_dB=EIRP_dB -TPL_dB -RFL_dB+GTR_dB_SAT+228.6\n", + "CNoR_dB=round(CNoR_dB,2)\n", + "print 'The carrier to noise ratio in dB is',CNoR_dB" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 19.14.2,Pg.no.739" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The carrier to noise ratio is 78.23\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "f=14*10**9\n", + "BO_dB=10\n", + "GTR_dB_SAT=3\n", + "RFL_dB=1\n", + "phi_dB=-98\n", + "c=3*10**8\n", + "#Determination of carrier to noise ratio\n", + "wav=c/f\n", + "x=0.00003654067 #x=((wav**2)/(4*pi))\n", + "Ao_dB=10*math.log10(x)\n", + "CNo_dB=phi_dB -BO_dB+GTR_dB_SAT -RFL_dB+Ao_dB+228.6\n", + "CNo_dB=round(CNo_dB,2)\n", + "print 'The carrier to noise ratio is',CNo_dB" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 19.16.1,Pg.no.741" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The overall carrier to noise ratio is 79.59\n" + ] + } + ], + "source": [ + "import math\n", + "CNo_dB_U=88\n", + "CNo_dB_D=78\n", + "NoC_U=10**(-CNo_dB_U/10)\n", + "NoC_D=10**(-CNo_dB_D/10)\n", + "NoC=NoC_U+NoC_D\n", + "CNo_dB=10*math.log10(1/NoC)\n", + "CNo_dB=round(CNo_dB,2)\n", + "print 'The overall carrier to noise ratio is',CNo_dB" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 19.17.1,Pg.no.742" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The ratio C/No is 71.49\n" + ] + } + ], + "source": [ + "import math\n", + "#given\n", + "Eb_N0=9.6 #ratio expessed in dB\n", + "Rb=1.544*10**6 #bit rate expessed in bps\n", + "#The bit rate in dB relative to 1bps is\n", + "R_dB_b=10*math.log10(Rb)\n", + "#The required CN0 ratio is\n", + "CNo_db=Eb_N0+R_dB_b\n", + "CNo_db=round(CNo_db,2)\n", + "print 'The ratio C/No is',CNo_db " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter1_Passive_Circuits.ipynb b/Electronic_Communication_by_D._Roddy/Chapter1_Passive_Circuits.ipynb new file mode 100644 index 00000000..7e165345 --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter1_Passive_Circuits.ipynb @@ -0,0 +1,372 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 1 Passive Circuits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1.2.2, Pg.no.5" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of resistance R is 16.61 ohm\n", + "The value of resistance R3 is 66.8 ohm\n" + ] + } + ], + "source": [ + "import math\n", + "#given\n", + "Ro=50.0\n", + "ILdB=6.0 #T−type attenuator provide 6−dB insertion loss \n", + "#calculation\n", + "IL=10**-(ILdB/20) #Determination of R\n", + "R=Ro*(1-IL)/(1+IL)\n", + "R=round(R,2)\n", + "print 'The value of resistance R is',R,'ohm' \n", + "#Determination of R3\n", + "R3=(2*Ro*IL)/(1-(0.5)**2)\n", + "R3=round(R3,1)\n", + "print 'The value of resistance R3 is',R3,'ohm'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1.2.3,Pg.no.6" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of resistance RA and RB is 150.5 ohm\n", + "The value of resistance RC is 37.4 ohm\n" + ] + } + ], + "source": [ + "import math\n", + "#given\n", + "Ro=50.0\n", + "ILdB=6.0\n", + "IL=10**-(ILdB/20) #Determination of RA and RB\n", + "RA=Ro*(1+IL)/(1-IL)\n", + "RA=round(RA,1)\n", + "print 'The value of resistance RA and RB is',RA,'ohm'\n", + "#Determination of RC\n", + "RC=Ro*(1-(IL)**2)/(2*IL)\n", + "RC=round(RC,1)\n", + "print 'The value of resistance RC is',RC,'ohm'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1.2.4,Pg.no.8" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of resistance R1 is 43.3 ohm\n", + "The value of resistance R3 is 86.61 ohm\n", + "The value of insertion loss is 5.42 dB\n" + ] + } + ], + "source": [ + "import math\n", + "from math import log10,sqrt\n", + "#given\n", + "Rs=75.0 #resistance\n", + "Rl=50.0 \n", + "#Determination of R1\n", + "R1=sqrt(Rs*(Rs-Rl))\n", + "R1=round(R1,2)\n", + "print 'The value of resistance R1 is',R1,'ohm'\n", + "#Determination of R3\n", + "R3=((Rs**2)-(R1**2))/R1\n", + "R3=round(R3,2)\n", + "print 'The value of resistance R3 is',R3,'ohm'\n", + "#Determination of insertion loss\n", + "IL=(R3*(Rs+R1))/((Rs+R1+R3)*(R3+R1)-(R3)**2)\n", + "ILdB=-20*log10(IL) #convertion of power in decibels\n", + "ILdB=round(ILdB,2)\n", + "print 'The value of insertion loss is',ILdB,'dB'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1.2.5,Pg.no.9" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of resistance R2 is 44.721 ohm\n", + "The value of resistance R3 is 11.18 ohm\n", + "The value of insertion loss is 9.99 dB\n" + ] + } + ], + "source": [ + "from math import log10,sqrt\n", + "Rs=10.0\n", + "Rl=50.0 #Determination of R2\n", + "R2=sqrt(Rl*(Rl-Rs))\n", + "R2=round(R2,3)\n", + "print 'The value of resistance R2 is',R2,'ohm'\n", + "#Determination of R3\n", + "R3=((Rl**2)-(R2**2))/R2\n", + "R3=round(R3,2)\n", + "print 'The value of resistance R3 is',R3,'ohm'\n", + "#Determination of insertion loss\n", + "IL=(R3*(Rs+Rl))/((Rs+R3)*(R3+R2+Rl)-(R3)**2)\n", + "ILdB=-20*log10(IL) #convertion of power in decibels\n", + "ILdB=round(ILdB,2)\n", + "print 'The value of insertion loss is',ILdB,'dB'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1.5.1,Pg.no.19" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of self resonant freq is 60.2 MHz\n", + "The value of Q−factor is 31.4\n", + "The value of effective inductance is 1.0 uH\n", + "The value of effective Q−factor is 26.0\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt\n", + "C=7*10**-12\n", + "R=5.0\n", + "L=10**-6\n", + "f=25*10**6 \n", + "#Determination of self resonant freq of coil denoted as Fsr\n", + "Fsr=1/(2*3.14*(L*C)**0.5)\n", + "Fsr=Fsr/(10**6)\n", + "Fsr=round(Fsr,1)\n", + "print 'The value of self resonant freq is',Fsr,'MHz'\n", + "#Determination of Q−factor of coil , excluding self − capacitive effects\n", + "Q=(2*3.14*f*L)/R\n", + "print 'The value of Q−factor is',Q\n", + "#Determination of effective inductance\n", + "Leff=(1-(25/60)**2)**-1\n", + "Leff=round(Leff,0)\n", + "print 'The value of effective inductance is',Leff,'uH'\n", + "#Determination of effective Q−factor\n", + "Qeff=(1-0.173)*Q\n", + "Qeff=round(Qeff,0)\n", + "print 'The value of effective Q−factor is',Qeff" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1.8.1,Pg.no.23" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of common resonant freq is 3.77 Mrad/sec\n", + "Zm= 5.655j\n", + "The transfer impedance is (43.8+2250j) ohm\n" + ] + } + ], + "source": [ + "import cmath\n", + "from math import sqrt\n", + "#given\n", + "Lp=150*10**-6 #inductance\n", + "Ls=150*10**-6\n", + "Cp=470*10**-12 #capacitance\n", + "Cs=470*10**-12 #Lp=Ls=150 uH,Cp=Cs=470 pF\n", + "Q=85.0 #Q−factor for each ckt is 85\n", + "c=0.01 #Coeff of coupling is 0.01\n", + "Rl=5000.0 #Load resistance Rl=5000 ohm\n", + "r=75000.0 #Constant current source with internal resistance r=75 kohm\n", + "#calculations\n", + "#Determination of common resonant frequency\n", + "wo=1/(sqrt(Lp*Cp))\n", + "wo=wo/(10**6)\n", + "wo=round(wo,2)\n", + "print 'The value of common resonant freq is',wo,'Mrad/sec'\n", + "p=3.77*10**6\n", + "Z2=complex(62.9004,558) #Formula=Rl/(1+(p*j*Cs*Rl))\n", + "Z1=complex(4.3,565) #Formula=r/(1+(p*j*Cp*r)) ;At resonance Zs=Zp=Z\n", + "z=complex(0,1)\n", + "Z=wo*Ls*(1/Q +z)\n", + "Zm=complex(0,p*c*Lp) #Determination of denominator\n", + "print 'Zm=',Zm\n", + "Dr=((Z+Z1)*(Z+Z2))-(Zm**2) \n", + "Dr=complex(791,80)\n", + "#Hence transfer impedance is given as\n", + "Zr=complex(43.8,2.25*10**3) #formula=(Z1*Z2*Zm)/Dr\n", + "print 'The transfer impedance is',Zr,'ohm'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1.10.1,Pg.no.31" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of common resonant freq is 169.56 Mrad/ sec\n", + "The value of Gl is 5.0 mSec\n", + "The value of alpha is 3.14\n", + "The value of effective load is 1.97 kohm\n", + "The value of tuning capacitance is 47.73 pF\n", + "The value of Rd is 18.534 kohm\n", + "The value of −3dB BW is 1.69 MHz\n" + ] + } + ], + "source": [ + "import math\n", + "C1=70*10**-12\n", + "C2=150*10**-12\n", + "Rl=200.0\n", + "Q=150.0\n", + "f=27*10**6\n", + "r=40000.0\n", + "#Determination of common resonant freq\n", + "wo=2*3.14*f\n", + "wo=wo/(10**6)\n", + "print 'The value of common resonant freq is',wo,'Mrad/ sec'\n", + "#Determination of Gl\n", + "Gl=1/Rl\n", + "G1=Gl*(10**3) \n", + "print'The value of Gl is',G1,'mSec'\n", + "#Checking the approxiamtion in denominator\n", + "ap=((wo*(C1+C2))/(Gl))**2\n", + "alpha=(C1+C2)/C1\n", + "alpha=round(alpha,2)\n", + "print 'The value of alpha is',alpha\n", + "#Determination of effective load\n", + "Reff=((alpha)**2)*Rl\n", + "Reff=Reff/(10**3)\n", + "Reff=round(Reff,2)\n", + "print 'The value of effective load is',Reff,'kohm' \n", + "#If effective load is much less than internal resistance hence tuning capacitance then\n", + "Cs=C1*C2/(C1+C2)\n", + "Cs=Cs*(10**12)\n", + "Cs=round(Cs,2)\n", + "print 'The value of tuning capacitance is',Cs,'pF'\n", + "#Determination of Rd\n", + "Rd=Q/(wo*Cs)*(10**3)\n", + "Rd=round(Rd,3)\n", + "print 'The value of Rd is',Rd,'kohm'\n", + "#If Rd is much greater than Reff then −3dB bandwidth is given by\n", + "B=1/(2*3.14*C2*alpha*Rl)\n", + "B=B/(10**6)\n", + "B=round(B,2)\n", + "print 'The value of −3dB BW is',B,'MHz'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter20_Fibre_Optic_Communication.ipynb b/Electronic_Communication_by_D._Roddy/Chapter20_Fibre_Optic_Communication.ipynb new file mode 100644 index 00000000..254e70df --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter20_Fibre_Optic_Communication.ipynb @@ -0,0 +1,587 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter20 Fibre Optic Communication" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 20.2.1,Pg.no.753" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The numerical aperture is 0.35\n", + "The acceptance angle is 0.36\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt\n", + "n1=1.55 #RI of glass\n", + "n2=1.51 #RI of clad\n", + "#NA of the fibe is given as\n", + "NA=n1*sqrt(2*(n1-n2)/n1)\n", + "NA=round(NA,2)\n", + "print 'The numerical aperture is',NA\n", + "#Acceptance angle is given as\n", + "acc_angle=math.asin(NA)\n", + "acc_angle=round(acc_angle,2)\n", + "print 'The acceptance angle is',acc_angle" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 20.2.2,Pg.no.761" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The V number is 69.12\n", + "the approximate no . of modes are 2388.8\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "d=50*10**-6\n", + "wav=0.8*10**-6\n", + "NA=0.352 \n", + "#Determination of V number\n", + "V=(pi)*d*NA/wav\n", + "V=round(V,2)\n", + "print 'The V number is',V\n", + "#Determination of approximate number of modes\n", + "N=(V**2)/2\n", + "N=round(N,1)\n", + "print 'the approximate no . of modes are',N" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 20.2.3,Pg.no.762" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The v number is 4.2291\n", + "From the table it is seen that 6 modes have cut off v less than 4.23\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "d=5*10**-6\n", + "wave=1.3*10**-6\n", + "NA=0.35\n", + "#Determination of V number\n", + "V=(pi)*d*NA/wave\n", + "V=round(V,4)\n", + "print 'The v number is',V\n", + "print 'From the table it is seen that 6 modes have cut off v less than 4.23'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 20.2.4,Pg.no.763" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No . of modes supported by graded index fiber= 1195\n" + ] + } + ], + "source": [ + "import math\n", + "a=2 #gradding profile index\n", + "V=69.1 #normalized cutoff frequency\n", + "N=2390 #number of modes supported as a step index fiber\n", + "#Determination of no . of modes supported by graded index fiber\n", + "N_a=(N*a)/(a+2)\n", + "print 'No . of modes supported by graded index fiber=',N_a" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 20.2.5,Pg.no.763" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a) the normilized index difference is 0.002\n", + "b) cladding index required is 1.55\n", + "The max acceptance angle is 0.1\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "d=10*10**-6\n", + "wav=1.3*10**-6\n", + "n1=1.55\n", + "V_max=2.405\n", + "NA=(V_max*wav)/(pi*d)\n", + "#a) Determination of maximum normailized index difference\n", + "del1=(0.5)*((NA/n1)**2)\n", + "del1=round(del1,3)\n", + "print 'a) the normilized index difference is',del1\n", + "#b) Determination of r effective index of claddin glass\n", + "n2=n1*(1-del1)\n", + "n2=round(n2,2)\n", + "print 'b) cladding index required is',n2\n", + "#Determination of the fiber acceptance angle\n", + "theta_max=math.asin(NA)\n", + "theta_max=round(theta_max,3)\n", + "print'The max acceptance angle is',theta_max" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 20.3.1,Pg.no.766" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a)The repeater dist for 0.9um wavelength is 12 km\n", + "b)The repeater dist for 1.5um wavelength is 83.33 km\n" + ] + } + ], + "source": [ + "import math\n", + "A_max=25\n", + "A1=2\n", + "A2=0.3\n", + "#a) Determination of repeater dist at 0.9um wavelength\n", + "z1=A_max/A1\n", + "print 'a)The repeater dist for 0.9um wavelength is',z1,'km'\n", + "#b) Determination of repeater dist at 1.5um wavelength\n", + "z2=A_max/A2\n", + "z2=round(z2,2)\n", + "print 'b)The repeater dist for 1.5um wavelength is',z2,'km'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 20.4.1,Pg.no.772" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The intermodal dispersion is 1.37e-07 s/km\n", + "The intermodal dispertion for l=12.5 is 1.71e-09 s\n" + ] + } + ], + "source": [ + "import math\n", + "#given\n", + "n1=1.55\n", + "del1=0.0258\n", + "l=12.5\n", + "z=1000\n", + "c=3*10**8 #velocity of light\n", + "#a) Determination of intermodal dispersion\n", + "del_per_km=(n1*z*del1)/((1-del1)*c)*10**7\n", + "del_per_km=round(del_per_km,2)*10**-7\n", + "print 'The intermodal dispersion is',del_per_km ,'s/km'\n", + "#b) Determination of intermodal dispersion for l =12.5\n", + "del_l=del_per_km*l/1000*10**9\n", + "del_l=round(del_l,2)*10**-9\n", + "print 'The intermodal dispertion for l=12.5 is',del_l,'s'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 20.4.2,Pg.no.773" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The intermodal dispersion is 5.37e-05 sec\n" + ] + } + ], + "source": [ + "import math\n", + "n1=1.55\n", + "del1=(258.0)*(10**-2)\n", + "z=1000\n", + "c=3*10**8\n", + "z_disp=12.5\n", + "del_graded=(n1*z*del1**2)/(8*c)\n", + "#Determination of intermodal dispersion\n", + "del_total=del_graded*z_disp*10**5\n", + "del_total=round(del_total,2)*10**-5\n", + "print 'The intermodal dispersion is',del_total,'sec'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 20.4.3,Pg.no.774" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The total material dispersion is -2.8125 ns\n" + ] + } + ], + "source": [ + "import math\n", + "#given\n", + "wav_0=0.8*10**-6\n", + "Dm=-0.15\n", + "wav_3=1.5\n", + "z=12.5\n", + "del_t=Dm*wav_3\n", + "#Determination of total material dispersion\n", + "del_md=del_t*z\n", + "print 'The total material dispersion is',del_md,'ns' " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 20.4.4,Pg.no.775" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Expected waveguide dispersion is 495.0 ps\n" + ] + } + ], + "source": [ + "import math\n", + "#given\n", + "Dm=6.6\n", + "z=12.5\n", + "del_3=6\n", + "del_wg=Dm*z*del_3\n", + "print'Expected waveguide dispersion is',del_wg,'ps'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 20.4.5,Pg.no.776" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The total dispersion is 1.0 ns\n", + "The max allowed bit rate is 500.0 Mbps\n" + ] + } + ], + "source": [ + "import math\n", + "#given\n", + "del_imd=0\n", + "del_md=2.81\n", + "del_wgd=0.495\n", + "t_w=2.5\n", + "del_tot=((del_imd**2)+(del_md**2)+(del_wgd**2))**(1/2)\n", + "print 'The total dispersion is',del_tot,'ns'\n", + "t_r=((t_w**2)+(del_tot**2))**(1/2) \n", + "#Determination of max allowed bit rate\n", + "B=(1000/(2*t_r))\n", + "print 'The max allowed bit rate is',B,'Mbps'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 20.4.6,Pg.no.778" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a)The BW distance product for fiber is 0.125 Mbps−km\n", + "b)The disp limited length for a fiber is 12.5 km\n" + ] + } + ], + "source": [ + "import math\n", + "#given\n", + "del_t=4.0\n", + "B=10.0\n", + "#a) Determination of BW distance product\n", + "BDP=1/(2*del_t)\n", + "print'a)The BW distance product for fiber is',BDP,'Mbps−km'\n", + "#b) Determiation of dispersion limited length\n", + "z_max_disp=BDP/(B*10**-3)\n", + "print'b)The disp limited length for a fiber is',z_max_disp,'km'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 20.5.1,Pg.no.780" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a) i) the wavelength is 0.7 um\n", + "a) ii) the freq is 459307010.5 MHz\n", + "b) i) the wavelength is 0.85 um\n", + "b) ii) the freq is 352941176.471 MHz\n", + "c)i) the wavelength is 1.3 um\n", + "c)ii) the freq is 230620467.4 MHz\n" + ] + } + ], + "source": [ + "import math\n", + "E1=1.9\n", + "E2=1.46\n", + "E3=0.954\n", + "eV=1.9 #All in eV\n", + "c=3*10**8 #speed of light\n", + "#a) Determination of wavelength and freq for E1=1.9\n", + "wav1=1.241/E1\n", + "f1=c/(wav1)\n", + "wav1=round(wav1,1)\n", + "f1=round(f1,1)\n", + "print 'a) i) the wavelength is',wav1,'um'\n", + "print 'a) ii) the freq is',f1,'MHz'\n", + "#b) Determination of wavelength and freq for E2=1.46\n", + "wav2=1.241/E2\n", + "f2=c/(wav2)\n", + "print 'b) i) the wavelength is',wav2,'um'\n", + "print 'b) ii) the freq is',f2,'MHz'\n", + "#c ) Determination of wavelength and freq for E3=0.945\n", + "wav3=1.241/E3\n", + "f3=c/(wav3)\n", + "wav3=round(wav3,1)\n", + "f3=round(f3,1)\n", + "print'c)i) the wavelength is',wav3,'um'\n", + "print'c)ii) the freq is',f3,'MHz'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 20.8.1,Pg.no.799" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a) the loss−limited fiber is 17.75 km\n", + "b) the max BW for loss−limited length is 0.022 Gbps\n", + "the dispertion limited length is 11.32 km\n" + ] + } + ], + "source": [ + "import math\n", + "#given\n", + "pt=0\n", + "pr=-57\n", + "Nc=2\n", + "BER=10**-9\n", + "N=5\n", + "Lpt=6\n", + "Lpr=6\n", + "Lc=1\n", + "Ls =0.5\n", + "Lf=2\n", + "M=5\n", + "del_t=0.505\n", + "B=35\n", + "Ns=5\n", + "#a) Determination of loss−limited fiber length\n", + "z=(pt-pr-M-(Nc*Lc)-(Ns*Ls)-Lpt-Lpr)/Lf\n", + "print 'a) the loss−limited fiber is',z,'km'\n", + "#b) Determination of max BW for loss−limited fiber length\n", + "B_max=1/(5*del_t*z)\n", + "B_max=round(B_max,3)\n", + "print 'b) the max BW for loss−limited length is',B_max,'Gbps'\n", + "#c ) Determination of dispersion−limited length\n", + "z_disp=1000/(5*del_t*B)\n", + "z_disp=round(z_disp,2)\n", + "print 'the dispertion limited length is',z_disp,'km'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter2_Waveform_Spectra.ipynb b/Electronic_Communication_by_D._Roddy/Chapter2_Waveform_Spectra.ipynb new file mode 100644 index 00000000..3ceb177d --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter2_Waveform_Spectra.ipynb @@ -0,0 +1,64 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter2 Waveform spectra" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.13.1,Pg no.66" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The average energy is 0.0018 J\n" + ] + } + ], + "source": [ + "import math\n", + "V=3\n", + "t=2*10**-3\n", + "R=10.0 #Determination of average energy\n", + "P=(V**2)/R #Instantaneous power\n", + "U=P*t\n", + "print 'The average energy is',U,'J'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter4_Noise.ipynb b/Electronic_Communication_by_D._Roddy/Chapter4_Noise.ipynb new file mode 100644 index 00000000..748bcbf7 --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter4_Noise.ipynb @@ -0,0 +1,549 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 4 Noise" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.2.1,Pg.no 120" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of thermal noise power is 4.002e-15 W\n", + "The value of RMS noise voltage is 0.89 uV\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "T=290.0\n", + "BW=1*10**6 #Noise bandwidth in hertz\n", + "k=1.38*10**-23 #Boltzman constant in J/K\n", + "R=50.0 #Determination of thermal noise power Pn\n", + "Pn=k*T*BW\n", + "#Pn=round(Pn,1)\n", + "print 'The value of thermal noise power is',Pn,'W'\n", + "#Determination of RMS noise voltage\n", + "En=sqrt(4*R*k*T*BW)\n", + "En=En*(10**6)\n", + "En=round(En,2)\n", + "print 'The value of RMS noise voltage is',En,'uV'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.2.2,Pg.no.122" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a) i )The value of RMS noise voltage is 5.66 uV\n", + " ii)The value of RMS noise voltage is 8949245.77828 uV\n", + "b)The value of RMS noise voltage is 10588890.4 uV\n", + "c)The value of RMS noise voltage is 4783573.08 uV\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "R1=20000.0\n", + "R2=50000.0\n", + "k=1.38*10**-23 #Boltzman constant in J/K\n", + "T=290.0\n", + "BW=100*10**3 #Determination of thermal noise voltage for 20Kohm resistor\n", + "En1=sqrt(4*R1*k*T*BW)\n", + "En1=En1*(10**6)\n", + "En1=round(En1,2)\n", + "print 'a) i )The value of RMS noise voltage is',En1,'uV'\n", + "#Determination of thermal noise voltage for 50 kohm resistor\n", + "En2=En1*sqrt(R2/R1)\n", + "En2=En2*10**6\n", + "print ' ii)The value of RMS noise voltage is',En2,'uV'\n", + "#Determination of thermal noise voltage for 20K & 50k resistor in series\n", + "Rser=R1+R2 #Series combination of R1 & R2\n", + "En3=En1*sqrt(Rser/R1)\n", + "En3=En3*10**6\n", + "En3=round(En3,2)\n", + "print 'b)The value of RMS noise voltage is',En3,'uV'\n", + "#Determination of thermal noise voltage for 20K & 50k resistor in parellel\n", + "Rpar=(R1*R2)/(R1+R2) #parallel combination of R1 & R2\n", + "En4=En1*sqrt(Rpar/R1)\n", + "En4=En4*10**6\n", + "En4=round(En4,2)\n", + "print 'c)The value of RMS noise voltage is',En4,'uV'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.2.3,Pg.no.128" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of Rd is 1.59 kohm\n", + "The value of effective noise voltage is 0.02 uV\n" + ] + } + ], + "source": [ + "from math import sqrt,pi\n", + "f=120*10**6\n", + "c=25*10**-12 #capacitance of 12 pF\n", + "Q=30.0 #Q−factor of the ckt is 30\n", + "BW=10*10**3 #channel BW of the receiver is 10 KHz\n", + "k=1.38*10**-23 #Boltzman constant in J/K\n", + "T=290.0 #Room temp\n", + "#Determination of effective noise voltage Rd appearing at i /p at room temp\n", + "Rd=Q/(2*pi*f*c)\n", + "Rd=Rd/1000\n", + "Rd=round(Rd,2)\n", + "print 'The value of Rd is',Rd,'kohm'\n", + "Vn=sqrt(4*Rd*k*T*BW)\n", + "Vn=Vn*10**6\n", + "Vn=round(Vn,2)\n", + "print 'The value of effective noise voltage is',Vn,'uV'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.3.1,Pg.no.131" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of noise current In is 17.89 nA\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "Idc=10**-3\n", + "Bn=10**6 #Effective noise BW=1 MHz\n", + "q=1.6*10**-19 #Charge on electron in coulombs\n", + "#Determination of noise component current In in DC current of Idc=1 mA\n", + "In=sqrt(2*Idc*q*Bn)\n", + "In=In*10**9\n", + "In=round(In,2)\n", + "print 'The value of noise current In is',In,'nA'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.11.1,Pg.no.135" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of shot noise current Ina is 4.0 nA\n", + "The value of noise voltage across Rs is 600000000.0 uV\n", + "The value of noise voltage across Rn is 6.93 uV\n", + "The value of thermal noise voltage at Rs is 4.9 uV\n", + "The value of total noise voltage Vn is 1000000.0 uV\n", + "The value of signal to noise ratio is -220.0 dB\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi,sqrt\n", + "#An amplifier is given\n", + "Rn=300.0 #Equivalent noise resistance\n", + "Ieq=5*10**-6 #Equivalent noise current is 5 uA\n", + "Rs=150.0 #Amplifier fed from 150 ohm,10 uV rms sinusoidal source\n", + "Vs=10*10**-6\n", + "Bn=10*10**6 #Noise BW is 10 MHz\n", + "#Assume the following\n", + "kT=4*10**-21 #k is Boltzman constant in J/K & T is room temp\n", + "q=1.6*10**-19 #Charge on electron in coloumbs\n", + "#Determination of shot noise current\n", + "Ina=sqrt(2*q*Ieq*Bn)\n", + "Ina=Ina*(10**9)\n", + "print 'The value of shot noise current Ina is',Ina,'nA'\n", + "#Noise voltage developed by this across source resistance is\n", + "V=Ina*Rs\n", + "V=V*(10**6)\n", + "V=round(V,2)\n", + "print 'The value of noise voltage across Rs is',V,'uV'\n", + "#Noise voltage developed across Rn resistance is\n", + "Vna=sqrt(4*Rn*kT*Bn)*10**6\n", + "Vna=round(Vna,2)\n", + "print 'The value of noise voltage across Rn is',Vna,'uV'\n", + "#Determination of thermal noise voltage from source\n", + "Vns=sqrt(4*Rs*kT*Bn)*10**6\n", + "Vns=round(Vns,2)\n", + "print 'The value of thermal noise voltage at Rs is',Vns,'uV'\n", + "#Determination of total noise voltage at input\n", + "Vn=(((V)**2)+((Vna)**2)+((Vns)**2))**(1/2)\n", + "Vn=Vn*(10**6)\n", + "print 'The value of total noise voltage Vn is',Vn,'uV'\n", + "#Determination of signal to noise ratio in dB\n", + "SNR=20*(math.log10(Vs/Vn))\n", + "print 'The value of signal to noise ratio is',SNR,'dB'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.12.1,Pg.no.136" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of output signal to noise ratio is 55.23 dB\n" + ] + } + ], + "source": [ + "import math\n", + "SNR1=60.0\n", + "l=3.0 #Determination of output signal to noise ratio\n", + "SNR=(SNR1) -10*math.log10(l)\n", + "SNR=round(SNR,2)\n", + "print 'The value of output signal to noise ratio is',SNR,'dB'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.12.2,Pg.no.137" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of output signal to noise ratio is 40.0 dB\n" + ] + } + ], + "source": [ + "import math\n", + "SNRdB1=60.0 #SNR is 60 dB for Ist link\n", + "SNRdB2=60.0 #SNR is 60 dB for IInd link\n", + "SNRdB3=40.0 #SNR is 40 dB for IIIrd link\n", + "#Determination of power in watt\n", + "snr1=10**(-SNRdB1/10)\n", + "snr2=10**(-SNRdB2/10)\n", + "snr3=10**(-SNRdB3/10)\n", + "#Determination of overall SNR\n", + "SNR=snr3\n", + "#Determination of total SNR in dB\n", + "SNRdB=10*(-math.log10(SNR))\n", + "print 'The value of output signal to noise ratio is',SNRdB,'dB'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.13.1,Pg.no.139" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of output signal to noise ratio is 28.0 dB\n" + ] + } + ], + "source": [ + "import math\n", + "SNRin=35.0 #SNR at i /p of amplifier\n", + "F=7.0 #Noise figure of an amplifier\n", + "#Determination of output SNR\n", + "SNRout=SNRin-F\n", + "print 'The value of output signal to noise ratio is',SNRout,'dB'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.14.1,Pg.no.140" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of input noise is 0.08 pW\n" + ] + } + ], + "source": [ + "import math\n", + "f=13.0 #Noise figure of an amplifier\n", + "Bn=1*10**6\n", + "kT=4*10**-21 #k is Boltzman constant in J/K & T is room temp\n", + "F=10**(f/10)\n", + "#Determination of equivalent amplifier input noise\n", + "Pna=(F-1)*kT*Bn*10**12\n", + "Pna=round(Pna,2)\n", + "print 'The value of input noise is',Pna,'pW'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.15.1,Pg.no.141" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The overall noise fig is 10.44 dB\n" + ] + } + ], + "source": [ + "import math\n", + "f1=9.0 #Noise fig for amplifier\n", + "f2=20.0 #Noise fig for mixer\n", + "g=15.0 #power gain\n", + "#Converting dB in power ratio\n", + "F1=10**(f1/10)\n", + "F2=10**(f2/10)\n", + "G=10**(g/10)\n", + "#Determination of overall noise fig . reffered at i / p\n", + "F=F1+(F2-1)/G #converting in dB\n", + "FdB=10*math.log10(F)\n", + "FdB=round(FdB,2)\n", + "print 'The overall noise fig is',FdB,'dB'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.17.1,Pg.no.143" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of noise factor is 1\n" + ] + } + ], + "source": [ + "import math\n", + "F=6.0 #Noise fig .=6 dB\n", + "#Determination of noise factor\n", + "Fn=10**(6/10)\n", + "print 'The value of noise factor is',Fn" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.18.1,Pg.no.144" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of equivalent noise at room temp is 4306.19 k\n", + "The value of equivalent noise at noise temp=90 is 90.04 K\n" + ] + } + ], + "source": [ + "import math\n", + "f=12.0 \n", + "Tm=290.0 #Room temp value\n", + "T=90.0\n", + "g=50.0 #calculating power ratio\n", + "F=10**(f/10)\n", + "G=10**(g/10)\n", + "#Determination of equivalent noise at room temp\n", + "Tem=(F-1)*Tm\n", + "Tem=round(Tem,2)\n", + "print 'The value of equivalent noise at room temp is',Tem,'k'\n", + "#Determination of equivalent noise at 90 k temp\n", + "Te=T+(Tem/G)\n", + "Te=round(Te,2)\n", + "print 'The value of equivalent noise at noise temp=90 is',Te,'K'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.19.1,Pg.no.146" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of hot temp Th is 7574.47 k\n", + "The value of equivalent noise temp Te is 759.14 K\n" + ] + } + ], + "source": [ + "import math\n", + "enr=14.0\n", + "To=290.0 #Room temp in K\n", + "y=9.0 #Y−factor is 9 dB\n", + "#converting dB in power ratio\n", + "ENR=10**(enr/10)\n", + "Y=10**(y/10) #From def of ENR the hot temp is\n", + "Th=To*(ENR+1)\n", + "Th=round(Th,2)\n", + "print 'The value of hot temp Th is',Th,'k'\n", + "#Determination of equivalent noise temp\n", + "Te=(Th-(Y*To))/(Y-1)\n", + "Te=round(Te,2)\n", + "print 'The value of equivalent noise temp Te is',Te,'K'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter5_Tuned_Small_Signal_Amplifiers,_Mixers_and_Active_Filters.ipynb b/Electronic_Communication_by_D._Roddy/Chapter5_Tuned_Small_Signal_Amplifiers,_Mixers_and_Active_Filters.ipynb new file mode 100644 index 00000000..a9c1b03b --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter5_Tuned_Small_Signal_Amplifiers,_Mixers_and_Active_Filters.ipynb @@ -0,0 +1,134 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter5 Tuned Small Signal Amplifiers, Mixers and Active Filters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.4.1,Pg.no.162" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The voltage gain is -918.2\n", + "The Millar capacitance is 551.52 pF\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "f=5*10**6\n", + "c=100*10**-12 #tuning capacitance in F\n", + "Q=150.0 #Q−factor of the ckt\n", + "Rl=5*10**3 #load resistance in ohm\n", + "Rc=40*10**3 #o/p reistance of transistor\n", + "Ic=500*10**-6 #transister collector current in A \n", + "C=0.6*10**-12 #collector to base capacitance in F\n", + "Vt=26*10**-3 #thermal voltage in V\n", + "#transe conductance is given as\n", + "gm=Ic/Vt\n", + "RD2=Q/(2*pi*f*c)\n", + "#At resonance the output admittance is purely conductive and is given as\n", + "Yo=(1/Rc)+(1/RD2)+(1/Rl)\n", + "#The voltage gain is given as\n", + "Av=-(gm/Yo)\n", + "Av=round(Av,2)\n", + "print 'The voltage gain is',Av\n", + "#The Millar capacitance is given as\n", + "Cm=(1-Av)*C*10**12\n", + "Cm=round(Cm,2)\n", + "print 'The Millar capacitance is',Cm,'pF'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.4.2,Pg.no.163" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The effective Q−factor is 12.68\n", + "The voltage gain is 62.14\n" + ] + } + ], + "source": [ + "from math import pi\n", + "f=5*10**6 #in Hz\n", + "w0=2*pi*f\n", + "Q=100.0 #Q−factor of the ckt\n", + "L=2*10**-6 #inductance expressed in H\n", + "Rs=1000.0 #source resistance in ohm\n", + "Ic=500*10**-6 #transister collector current in A \n", + "Vt=26*10**-3 #thermal voltage in V\n", + "hfe=200.0\n", + "C_be=10*10**-12 #in pF\n", + "#refer to problem 5.4.1\n", + "Av=78.0\n", + "Cm=47.0\n", + "gm=Ic/Vt\n", + "r_be=hfe/gm\n", + "#The dynamic resistance of the tuned ckt is\n", + "RD1=Q*w0*L #The effective dynamic conductance is\n", + "RD1eff_1=(1/Rs)+(1/RD1)+(1/r_be)\n", + "RD1_eff=1/RD1eff_1 \n", + "#Tha effective Q−factor is\n", + "Qeff=RD1_eff/(w0*L)\n", + "Qeff=round(Qeff,2)\n", + "print 'The effective Q−factor is',Qeff\n", + "#The voltage gain refered to source is\n", + "Avs=RD1_eff*Av/Rs\n", + "Avs=round(Avs,2)\n", + "print 'The voltage gain is',Avs" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter6_Oscillators.ipynb b/Electronic_Communication_by_D._Roddy/Chapter6_Oscillators.ipynb new file mode 100644 index 00000000..d8fc16c8 --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter6_Oscillators.ipynb @@ -0,0 +1,312 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter6 Oscillators" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.3.1,Pg.no.199" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.The minimum value of beta is 44.54\n", + "2.The value of resistor R= 21.6 Kohm\n", + "3.The value of capacitor is 4494.19 pF\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi,sqrt\n", + "f=400.0\n", + "rc= 10.0\n", + "Rc= 40.0 \n", + "#Minimum value of beta is given by Bomin= 23+(4*Ro /R)+(29*R/Ro) \n", + "#For minimum beta Ro/R=2.7, we represent Ro/R=b\n", + "b=2.7\n", + "Bomin=23+(4*b)+(29*1/b)\n", + "Bomin=round(Bomin,2)\n", + "print '1.The minimum value of beta is',Bomin\n", + "#Determination of R and C components\n", + "#R0 is given by ( rc*Rc) /( rc+Rc)\n", + "R0=(rc*Rc)/(rc+Rc)\n", + "R=2.7* R0\n", + "print '2.The value of resistor R=',R,'Kohm'\n", + "c=1/(2*pi*f*R*sqrt(6+(4*b)))*10**9\n", + "c=round(c,2)\n", + "print '3.The value of capacitor is',c,'pF'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.3.2,Pg.no.200" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of capacitor is 767.44 pF\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi,sqrt\n", + "#given\n", + "f=800.0\n", + "R0=18.0\n", + "#calculations\n", + "R=100.0\n", + "c=1/(2*pi*f*R*sqrt(6+(4*R0/R)))*10**9 #Capacitance in pF\n", + "c=round(c,2)\n", + "print 'The value of capacitor is',c,'pF'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.3.3,Pg.no.201" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of capacitor is 614.0 pF\n", + "1.The required open−circuit voltage gain is 30.16\n", + "2.The value of gm is 6.03 mS\n" + ] + } + ], + "source": [ + "import math\n", + "f=1000.0\n", + "Ro=5.0\n", + "R=100.0\n", + "c=1/(2*pi*f*R*sqrt(6+(4*R0/R)))*10**9\n", + "c=round(c,1)\n", + "print 'The value of capacitor is',c,'pF'\n", + "#The required open−circuit voltage gain is\n", + "Ao= 29+23*(Ro/R)+4*(Ro/R)**2\n", + "Ao=round(Ao,2)\n", + "print'1.The required open−circuit voltage gain is',Ao\n", + "gm=Ao/Ro\n", + "gm=round(gm,2)\n", + "print '2.The value of gm is',gm,'mS'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.4.1,Pg.no.205" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.The value of capacitor is 75.0 pF\n", + "2.The frequency of oscillation is 918881.49 Hz\n", + "3.The dynamic impedence of the tuned circuit 461880.22 ohm\n", + "4.The coil series resistance is 11.55 ohm\n", + "5.The value of gm is 1.15470052676e-05\n", + "6.The input resistance is 8660254.12 ohm\n", + "7.The frequency of oscillation is 918881.49 Hz\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi,sqrt\n", + "L=400*10**-6 #inductsnce in H\n", + "c1= 100.0 #capaitance in pF\n", + "c2= 300.0 #in pF\n", + "Q=200.0\n", + "Ro= 5*10**3\n", + "Bo=100.0 #beta value\n", + "#The tuning capacitance is\n", + "Cs=(c1*c2/(c1+c2))\n", + "Cs=round(Cs,2)\n", + "print '1.The value of capacitor is',Cs,'pF'\n", + "#the frequency of oscillation is obtained as\n", + "f=1/(2*pi*sqrt(L*Cs*10**-12))\n", + "f=round(f,2)\n", + "print '2.The frequency of oscillation is',f,'Hz'\n", + "#The dynamic impedence of the tuned circuit\n", + "wo= 2*pi*f\n", + "Rd=Q/(wo*Cs*10**-12)\n", + "Rd=round(Rd,2)\n", + "print '3.The dynamic impedence of the tuned circuit',Rd,'ohm'\n", + "#The coil series resistance is\n", + "r=wo*L/Q\n", + "r=round(r,2)\n", + "print '4.The coil series resistance is',r,'ohm'\n", + "#The capacitor raio c= c1/c2=1/3, and therefore 1− c2/B0∗c1 = 1\n", + "#The starting value of gm is therefore given by\n", + "c= c1/c2\n", + "gm=(1/Ro)*c +(c+3+2)*(1/Rd)\n", + "print '5.The value of gm is',gm\n", + "#Assuming the input resistance is that of the transistor alone\n", + "R1=Bo/gm\n", + "R1=round(R1,2)\n", + "print '6.The input resistance is',R1,'ohm'\n", + "wo2=1/((L*Cs*10**-12)+(1/R1*Ro*c1*c2*10**-12*10**-12))\n", + "wo=sqrt(wo2)\n", + "f=wo/(2*pi)\n", + "f=round(f,2)\n", + "print '7.The frequency of oscillation is',f,'Hz'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.6.1,Pg.no.211" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of capacitor is 5.16 pF\n" + ] + } + ], + "source": [ + "import math\n", + "Co=20.0 #in pF\n", + "Vd=-7 #reverse bias voltage in volt\n", + "#constant pottential of junction is 0.5\n", + "a=0.5 #for abrupt junction\n", + "Cd=Co/(1-(Vd/0.5))**a\n", + "Cd=round(Cd,2)\n", + "print 'The value of capacitor is',Cd,'pF'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.6.2,Pg.no.212" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.The total tuning capacitor is 9.38 pF\n", + "2.The frequency of oscillation is 5196593.1 Hz\n", + "3.The total tuning capacitor is 3.99 pF\n", + "4.The frequency of oscillation is 7967713.03 Hz\n" + ] + } + ], + "source": [ + "from math import pi,sqrt\n", + "#given\n", + "C1=300.0\n", + "C2=300.0\n", + "Cc=20.0\n", + "L=100.0\n", + "#calculations\n", + "# A) With zero applied bias , the total tuning capacitor is \n", + "Vd1=0\n", + "a=0.5\n", + "Co=20.0\n", + "Cd1=Co/(1-(Vd1/0.5))**a\n", + "Cs1=1/((1/C1)+(1/C2)+(1/Cc)+(1/Cd1))\n", + "Cs1=round(Cs1,2)\n", + "print '1.The total tuning capacitor is',Cs1,'pF'\n", + "#The frequency of oscillation is\n", + "f=1/(2*pi*sqrt(L*10**-6*Cs1*10**-12))\n", + "f=round(f,2)\n", + "print '2.The frequency of oscillation is',f,'Hz'\n", + "Vd2=-7\n", + "Cd2=Co/(1-(Vd2/0.5))**a\n", + "Cs2=1/((1/C1)+(1/C2)+(1/Cc)+(1/Cd2))\n", + "Cs2=round(Cs2,2)\n", + "print '3.The total tuning capacitor is',Cs2,'pF'\n", + "f=1/(2*pi*sqrt(L*10**-6*Cs2*10**-12))\n", + "f=round(f,2)\n", + "print '4.The frequency of oscillation is',f,'Hz'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter7_Receivers.ipynb b/Electronic_Communication_by_D._Roddy/Chapter7_Receivers.ipynb new file mode 100644 index 00000000..1cf5b9ae --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter7_Receivers.ipynb @@ -0,0 +1,157 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter7 Receivers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.3.1,Pg.no.227" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The freq tuning range is 1005000 Hz to 2055000 Hz\n", + "The tuning range ratio of oscillator is 2 ohm\n", + "The capacitor tuning range ratio of oscillator is 4\n", + "The tuning range ratio of RF−ckt is 2\n", + "The capacitor tuning range ratio of RF−ckt is 4\n" + ] + } + ], + "source": [ + "import math\n", + "fs_min=550*10**3\n", + "fs_max=1600*10**3\n", + "IF=455*10**3 \n", + "#Determination of freq tuning ranges\n", + "fo_min=fs_min+IF\n", + "fo_max=fs_max+IF\n", + "print 'The freq tuning range is',fo_min,'Hz to',fo_max,'Hz'\n", + "Rf=(fo_max)/(fo_min) #calculation of freq tuning range ratio\n", + "print 'The tuning range ratio of oscillator is',Rf,'ohm'\n", + "Rc=Rf**2 #calculation of capacitance tuning range ratio\n", + "print 'The capacitor tuning range ratio of oscillator is',Rc\n", + "#For RF section\n", + "Rf1=fs_max/fs_min;\n", + "print 'The tuning range ratio of RF−ckt is',Rf1\n", + "Rc1=Rf1**2\n", + "print 'The capacitor tuning range ratio of RF−ckt is',Rc1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.4.1,Pg.no.230" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The Cs min is 84.0 *10^-12 F\n" + ] + } + ], + "source": [ + "import math\n", + "Rco=8.463\n", + "Rfo=2.909\n", + "Rcs=4.182\n", + "Rfo=2.045\n", + "fo_max =2055.0*10**3\n", + "fo_min=1005.0*10**3\n", + "Cs_max=350.0\n", + "#For the RF section\n", + "Cs_min=Cs_max/Rcs\n", + "Cs_min=round(Cs_min,0)\n", + "print 'The Cs min is',Cs_min,'*10^-12','F'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.6.1,Pg.no.234" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image freq is 1930.0 Hz\n", + "Image rejection is -36.98\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt\n", + "IF=465.0 #IF in KHz\n", + "fs=1000 #Tuning freq in KHz\n", + "Q=50.0 #Quality factor\n", + "#Oscillator freq fo is given as\n", + "fo=fs+IF;\n", + "#a) Image freq is given as\n", + "fi=fo+IF\n", + "print 'Image freq is',fi,'Hz'\n", + "y=fi/fs-fs/fi\n", + "#b) image rejection is given as\n", + "Ar=1/sqrt(1+(y*Q)**2)\n", + "Ar_dB=20*math.log10(Ar)\n", + "Ar_dB=round(Ar_dB,2)\n", + "print 'Image rejection is',Ar_dB" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter8_Amplitude_Modulation.ipynb b/Electronic_Communication_by_D._Roddy/Chapter8_Amplitude_Modulation.ipynb new file mode 100644 index 00000000..b9d22f20 --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter8_Amplitude_Modulation.ipynb @@ -0,0 +1,182 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter8 Amplitude Modulation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 8.3.1,Pg.no.257" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The modulation index is 0.55\n", + "The ratio of side lengths L1/L2 is 3.44\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi,sqrt\n", + "vpp=11.0 #peak to peak voltage of modulating signal\n", + "vcp=10.0 #carrier peak voltage\n", + "#Determination of modulation index\n", + "E_max=vcp+(vpp/2)\n", + "E_min=vcp-(vpp/2)\n", + "m=(E_max -E_min)/(E_max+E_min)\n", + "print 'The modulation index is',m\n", + "#determination of k ratio of side lengths\n", + "L1_L2=E_max/E_min\n", + "L1_L2=round(L1_L2,2)\n", + "print 'The ratio of side lengths L1/L2 is',L1_L2" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Example 8.5.1,Pg.no.260" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The modulation index is 0.6\n" + ] + } + ], + "source": [ + "import math\n", + "fc=10*10**6 #Carrier freq\n", + "fm=5*10**3 #Modullating freq\n", + "vp=10.0\n", + "vm=6.0 #Determination of modulation index\n", + "m=vm/vp\n", + "m=round(m,1)\n", + "print 'The modulation index is',m" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 8.7.1,Pg.no.263" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The modulation index is 0.9\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt\n", + "I=12.0\n", + "Ic=10.0 \n", + "#Determination of modulation index\n", + "m=sqrt(2*(((I/Ic)**2) -1))\n", + "m=round(m,1)\n", + "print 'The modulation index is',m" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 8.11.1,Pg.no.274" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Yp= 6.28e-05 j\n", + "Zp= 15915.5\n", + "The max modulation index is 1.59\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt,pi\n", + "fm=10*10**3 #modulation freq\n", + "c=1000*10**-12\n", + "R=10*10**3\n", + "Yp=complex((1/R),(2*(pi)*fm*c)) #admittance of RC load\n", + "Ypi=Yp.imag*10**5\n", + "Ypi=round(Ypi,2)*10**-5\n", + "print 'Yp=',Ypi,'j'\n", + "Zp=1/sqrt(((Yp.real)**2)+((Yp.imag)**2))\n", + "Zp=round(Zp,1)\n", + "print 'Zp=',Zp\n", + "#Determination of max modulation index\n", + "m=Zp/R\n", + "m=round(m,2)\n", + "print 'The max modulation index is',m" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/Chapter9_Single_Sideband_Modulation.ipynb b/Electronic_Communication_by_D._Roddy/Chapter9_Single_Sideband_Modulation.ipynb new file mode 100644 index 00000000..a033a332 --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/Chapter9_Single_Sideband_Modulation.ipynb @@ -0,0 +1,100 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter9 Single SideBand Modulation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.2,Pg.no.349" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The efficiency is 70.0 %\n" + ] + } + ], + "source": [ + "import math\n", + "Nd=7.0\n", + "N_start=1\n", + "N_stop=1\n", + "N_parity=1\n", + "Nt= Nd + N_start+ N_stop + N_parity\n", + "eff=Nd/Nt*100\n", + "print 'The efficiency is',eff,'%'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.6,Pg.no.358" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hammming bits required= 5\n" + ] + } + ], + "source": [ + "import math\n", + "m=21.0\n", + "for n in range (1,10): #we choose range of 1 to 10\n", + " a=m+n+1 \n", + " b=2**n\n", + " if b>=a:\n", + " print 'hammming bits required=',n\n", + " break\n", + " end\n", + " end" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Electronic_Communication_by_D._Roddy/screenshots/1.png b/Electronic_Communication_by_D._Roddy/screenshots/1.png Binary files differnew file mode 100644 index 00000000..3d66b2fd --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/screenshots/1.png diff --git a/Electronic_Communication_by_D._Roddy/screenshots/12.png b/Electronic_Communication_by_D._Roddy/screenshots/12.png Binary files differnew file mode 100644 index 00000000..7618eea0 --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/screenshots/12.png diff --git a/Electronic_Communication_by_D._Roddy/screenshots/9.png b/Electronic_Communication_by_D._Roddy/screenshots/9.png Binary files differnew file mode 100644 index 00000000..52938734 --- /dev/null +++ b/Electronic_Communication_by_D._Roddy/screenshots/9.png diff --git a/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter11_Control_of_DC_Motors_1.ipynb b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter11_Control_of_DC_Motors_1.ipynb new file mode 100644 index 00000000..e8d8bf79 --- /dev/null +++ b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter11_Control_of_DC_Motors_1.ipynb @@ -0,0 +1,402 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter11 Control of DC Motors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example11.1,Pg.no.30" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rated motor current=Idc= 434.8 amps\n", + "Hence AC voltage for six pulse configuration= 408.89 volts\n", + "AC rating of field converter = 170.37 V\n", + "DC power= 2300.0 Watts\n", + "AC power= 2415.0 Watts\n", + "Field converter shall be locked at an angle of A= 35.61 degrees\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi \n", + "Idc=(200.0/460.0)*(1000.0) #Rated motor current in amps\n", + "Idc=round(Idc,1)\n", + "print 'Rated motor current=Idc=',Idc,'amps' #Thus the main armature converter will be having dc side rating of 500Amps and 460 volts \n", + "Ac=552.0/1.35\n", + "Ac=round(Ac,2)\n", + "print 'Hence AC voltage for six pulse configuration=',Ac,'volts' #Hence a 3phase ,415v AC supply will be adequate for armature control\n", + "AC=230.0/1.35\n", + "AC=round(AC,2)\n", + "print 'AC rating of field converter =',AC,'V'\n", + "DCp=230.0*10.0\n", + "print 'DC power=',DCp,'Watts'\n", + "ACp=1.05*2300\n", + "print 'AC power=',ACp,'Watts'\n", + "Edca=(170+170/10)*1.35 #available voltage in volts\n", + "Edc=1.35*230\n", + "A=math.acos(Edca/Edc)*180/pi\n", + "A=round(A,2)\n", + "print 'Field converter shall be locked at an angle of A=',A,'degrees'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example11.2,Pg.no.31" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Required voltage after allowing 10 percent drop=Edca= 484.0 volts\n", + "Cosine of the locked angle=C= 0.86\n", + "Converter shall be locked at an angle of A = 30.68 degrees\n" + ] + } + ], + "source": [ + "from math import pi \n", + "Vdc=440.0 #Rated dc voltage in volts\n", + "Edca=Vdc+Vdc/10.0 #Required voltage after allowing 10 % drop\n", + "print 'Required voltage after allowing 10 percent drop=Edca=',Edca,'volts'\n", + "Edc=1.35*415.0\n", + "C=Edca/Edc\n", + "C=round(C,2)\n", + "print 'Cosine of the locked angle=C=',C\n", + "A=math.acos(C)*180/pi #locked angle in degrees\n", + "A=round(A,2)\n", + "print 'Converter shall be locked at an angle of A =',A,'degrees'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example11.3,Pg.no.32" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Eb1= 210.0 volts\n", + "Eb2= 105.0 volts\n", + "Edca2= 145.0 volts\n", + "Cosine of the firing angle corresponding to 500 rpm load=C2= 0.63\n", + "firing angle corresponding to 500 rpm load A= 50.95 degrees\n" + ] + } + ], + "source": [ + "from math import pi\n", + "Edca1=230.0\n", + "N1=1000.0\n", + "N2=500.0\n", + "Eb1=210.0\n", + "Eb1=Edca1-20.0\n", + "print 'Eb1=',Eb1,'volts'\n", + "Eb2=Eb1*N2/N1\n", + "print 'Eb2=',Eb2,'volts'\n", + "V=40.0 #motor armature drop at rated load in volts\n", + "Edca2=Eb2+V\n", + "print 'Edca2=',Edca2,'volts'\n", + "C1=1.0 #cosine of the firing angle corresponding to 1000 rpm load\n", + "C2=C1*Edca2/Edca1 #cosine of the firing angle corresponding to 500 rpm load\n", + "C2=round(C2,2)\n", + "print 'Cosine of the firing angle corresponding to 500 rpm load=C2=',C2\n", + "A=math.acos(C2)*180/pi #firing angle corresponding to 500 rpm load in degrees\n", + "A=round(A,2)\n", + "print 'firing angle corresponding to 500 rpm load A=',A,'degrees'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example11.4,Pg.np.32" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rated output voltage from the converter= Edca1= 506.0 volts\n", + "Cosine of the triggering angle=C2= 0.6 Triggering angle=A2= 34.38 degrees\n", + "Powerfactor=PF2= 0.59\n", + "Reactive power at 75 percent load=RP2= 71.12 KVAR\n", + "Sixth harmonic ripple current=I6= 16 Amps\n", + "Inductance required in dc circuit=L= 4.06 mH\n", + "Cosine of the triggering angle=C1= 0.9\n", + "Triggering angle=A1= 51.57 degrees\n", + "Powerfactor=PF1= 0.9\n", + "Reactive power at 75 percent load=RP1= 51.2 KVAR\n" + ] + } + ], + "source": [ + "from math import pi,sqrt\n", + "Edca1=1.15*440.0 #Rated output voltage from the converter for rated speed of750rpm\n", + "print 'Rated output voltage from the converter= Edca1=',Edca1,'volts'\n", + "N1=750.0\n", + "N2=500.0\n", + "Edca2=Edca1*N2/N1\n", + "E2=415.0\n", + "C2=Edca2/(1.35*E2)\n", + "C2=round(C2,2)\n", + "print 'Cosine of the triggering angle=C2=',C2,\n", + "A2=C2*180/pi\n", + "A2=round(A2,2)\n", + "print 'Triggering angle=A2=',A2,'degrees'\n", + "PF2=C2*(1+math.cos(15.0*pi/180.0))/2\n", + "PF2=round(PF2,2)\n", + "print 'Powerfactor=PF2=',PF2\n", + "Id=200 #dc current in amps\n", + "I2=0.75*0.817*Id #Current at 75 percent load in amps\n", + "RP2=sqrt(3)*E2*I2*sqrt(1-PF2**2)/1000 #Reactive power drawn at 75% load\n", + "RP2=round(RP2,2)\n", + "print 'Reactive power at 75 percent load=RP2=',RP2,'KVAR'\n", + "h=6\n", + "Wv=24.17 #maximum voltage ripple in percent\n", + "Wi=8 #maximum permissible current ripple in percent\n", + "I6=Wi*Id/100\n", + "print 'Sixth harmonic ripple current=I6=',I6,'Amps'\n", + "W=314\n", + "L=(Wv*Edca1*10)/(I6*h*W)\n", + "L=round(L,2)\n", + "print 'Inductance required in dc circuit=L=',L,'mH'\n", + "C1=Edca1/(1.35*E2)\n", + "C1=round(C1,2)\n", + "print 'Cosine of the triggering angle=C1=',C1\n", + "A1=C1*180/pi\n", + "A1=round(A1,2)\n", + "print 'Triggering angle=A1=',A1,'degrees'\n", + "PF1=C1*(1+math.cos(15*pi/180))/2\n", + "PF1=round(PF1,1)\n", + "print 'Powerfactor=PF1=',PF1\n", + "I1=0.817*Id # Current at 75 percent load in amps\n", + "RP1=sqrt(3)*E2*I1*sqrt(1-PF1**2)/1000.0 #Reactive power drawn at 75% load\n", + "RP1=round(RP1,1)\n", + "print 'Reactive power at 75 percent load=RP1=',RP1,'KVAR'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example11.5,Pg.no.34" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cosine of the triggering angle=C= 0.82\n", + "Triggering angle=A= 47.0 degrees\n", + "Cosine of the triggering angle=C10= 0.1\n", + "Triggering angle=A10= 5.7 degrees\n", + "Active power drawn from the system at rated speed=AP= 104.5 KW\n", + "Reactive power drawn from the system=RP= 72.9 KVAR\n", + "Activepower drawn from thesystem at 10 percentrated speed=AP10= 12.7 KW\n", + "Reactive power drawn from the system=RP10= 126.8 KVAR\n", + "P= 1.7\n", + "Thus reactive power has increased by 74.589 percent due to reduction in motor speed\n" + ] + } + ], + "source": [ + "from math import pi,sqrt\n", + "Edca=460\n", + "E2=415\n", + "C=Edca/(1.35*E2)\n", + "C=round(C,2)\n", + "print 'Cosine of the triggering angle=C=',C\n", + "A=C*180/pi\n", + "A=round(A,1)\n", + "print 'Triggering angle=A=',A,'degrees'\n", + "Edca10=0.1*460\n", + "C10=Edca10/(1.35*E2)\n", + "C10=round(C10,1)\n", + "print 'Cosine of the triggering angle=C10=',C10\n", + "A10=C10*180/pi\n", + "A10=round(A10,1)\n", + "print 'Triggering angle=A10=',A10,'degrees'\n", + "Id=10**5/Edca #dc current in amps\n", + "I2=0.817*Id #Current at rated speed in amps\n", + "AP=sqrt(3)*E2*I2*C/1000\n", + "AP=round(AP,1)\n", + "print 'Active power drawn from the system at rated speed=AP=',AP,'KW'\n", + "RP=sqrt(3)*E2*I2*sqrt(1-C**2)/1000 #Reactive power drawn from the system\n", + "RP=round(RP,1)\n", + "print 'Reactive power drawn from the system=RP=',RP,'KVAR'\n", + "AP10=sqrt(3)*E2*I2*C10/1000\n", + "AP10=round(AP10,1)\n", + "print 'Activepower drawn from thesystem at 10 percentrated speed=AP10=',AP10,'KW'\n", + "RP10=sqrt(3)*E2*I2*sqrt(1-C10**2)/1000 #Reactive power drawn from the system\n", + "RP10=round(RP10,1)\n", + "print 'Reactive power drawn from the system=RP10=',RP10,'KVAR'\n", + "P=RP10/RP\n", + "P=round(P,1)\n", + "print 'P=',P\n", + "print 'Thus reactive power has increased by 74.589 percent due to reduction in motor speed'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example11.6,Pg.no.35" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reactive power at rated speed and rated load =72.79KVAR\n", + "Reactive power at rated speed and 10 percent load= 7.279 KVAR\n", + "reactive power at 10 percent speed and 10 percent load= 12.708 KVAR\n" + ] + } + ], + "source": [ + "import math\n", + "#given\n", + "Rp=72.79\n", + "Rp1=0.1*72.79 #Reactive power at rated speed and 10 percent load \n", + "Rp2=0.1*127.08 #reactive power at 10 percent speed and 10 percent load\n", + "print 'Reactive power at rated speed and rated load =72.79KVAR'\n", + "print 'Reactive power at rated speed and 10 percent load=',Rp1,'KVAR'\n", + "print 'reactive power at 10 percent speed and 10 percent load=',Rp2,'KVAR'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example11.7,Pg.no.35" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Eb2= 328 volts\n", + "Ia= 227.0 Amps\n", + "Ra= 0.1 ohms\n", + "Terminal voltage of dc motor at 500 rpm and 75 percent load=Edca= 345.0 volts\n", + "Cosine of the triggering angle of the converter=C2= 0.6\n", + "triggering angle of the converter A= 53.1 degrees\n" + ] + } + ], + "source": [ + "from math import pi\n", + "N1=500\n", + "N2=400\n", + "Eb1=410\n", + "Eb2=Eb1*N2/N1\n", + "print 'Eb2=',Eb2,'volts'\n", + "V=440 #operating voltage of dc motor in volts\n", + "P=100 #input power of dc motor in KW\n", + "Ia=P*1000/V\n", + "Ia=round(Ia,1)\n", + "print 'Ia=',Ia,'Amps'\n", + "Ra=(V-Eb1)/Ia;\n", + "Ra=round(Ra,1)\n", + "print 'Ra=',Ra,'ohms'\n", + "E2=415\n", + "Edca=Eb2+(0.75*Ia*Ra) #terminal voltage of dc motor at 500 rpm and 75% load\n", + "Edca=round(Edca,1)\n", + "print 'Terminal voltage of dc motor at 500 rpm and 75 percent load=Edca=',Edca,'volts'\n", + "C=Edca/(1.35*E2) #cosine of the triggering angle of the converter\n", + "C=round(C,1)\n", + "print 'Cosine of the triggering angle of the converter=C2=',C\n", + "A=math.acos(C)*180/pi #triggering angle of the converter in degrees\n", + "A=round(A,1)\n", + "print 'triggering angle of the converter A=',A,'degrees'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter12_Controllers_and_Their_Optimisation_1.ipynb b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter12_Controllers_and_Their_Optimisation_1.ipynb new file mode 100644 index 00000000..290111f3 --- /dev/null +++ b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter12_Controllers_and_Their_Optimisation_1.ipynb @@ -0,0 +1,362 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 12 Controllers and Their Optimisation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example12.1,Pg.no.37" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "permanent Error of P controller=P= 2 percent\n" + ] + } + ], + "source": [ + "import math\n", + "V=40 #gain of the controller in volts\n", + "P=100/(1+V) #permanent error of p controller in percent\n", + "print 'permanent Error of P controller=P=',P,'percent'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example12.2,Pg.no.37" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "gain of the controller=V= 54.6 volts\n", + "Motor armature time constant=T1= 873.6 milliseconds\n" + ] + } + ], + "source": [ + "import math\n", + "P=1.8 #permanent error of p controller in percent\n", + "V=100/1.8-1 #gain of the controller in volts\n", + "V=round(V,1)\n", + "print 'gain of the controller=V=',V,'volts'\n", + "G=8 #sum of all time constants in milliseconds \n", + "T1=2*G*V #motor armature time constant\n", + "T1=round(T1,1)\n", + "print 'Motor armature time constant=T1=',T1,'milliseconds'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example12.3,Pg.no.38" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "time constant for the current loop=t1= 1 ms\n", + "Smaller time constant=G= 2.5 ms\n", + "Time constant of the controller in AVO=Tn= 30 ms\n", + "Gain of the control system=V= 6.0\n", + "Gain of the PI controller=Vr= 0.43\n", + "R1= 25.6 Kiloohms\n", + "C1= 1.2 microfarads\n" + ] + } + ], + "source": [ + "import math\n", + "f=50 #frequency in hz\n", + "p=6 #pulse number\n", + "t1=1000/(2*f*p) #time constant for the current loop in ms\n", + "print 'time constant for the current loop=t1=',t1,'ms'\n", + "t2=1.5 #time constant of feedback channel in ms\n", + "G=t1+t2 #smaller time constant in ms\n", + "print 'Smaller time constant=G=',G,'ms'\n", + "T1=30 #bigger time constant in ms\n", + "Tn=T1 #time constant of the controller in ms\n", + "print 'Time constant of the controller in AVO=Tn=',Tn,'ms'\n", + "V=T1/(2*G) #gain of the control system\n", + "print 'Gain of the control system=V=',V\n", + "Vg=14 #gain of the regulating current link\n", + "Vr=V/Vg #gain of the PI controller\n", + "Vr=round(Vr,2)\n", + "print 'Gain of the PI controller=Vr=',Vr\n", + "R2=11 #R2 in KiloOhms\n", + "R1=R2/Vr #R1 in kiloohms\n", + "R1=round(R1,1)\n", + "print 'R1=',R1,'Kiloohms'\n", + "C1=Tn/R1 #C1 in microfarads\n", + "C1=round(C1,1)\n", + "print 'C1=',C1,'microfarads'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example12.4,Pg.no.39" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time constant of the controller in SO=Tn= 80.0 ms\n", + "Gain of the control system=V= 8.75\n", + "Gain of the PI regulator=Vr= 8.75\n", + "R2= 96.25 Kiloohms\n", + "C2= 0.8 microfarads\n" + ] + } + ], + "source": [ + "import math\n", + "G=20.0 #smaller time constant in ms\n", + "T1=350.0 #bigger time constant in ms\n", + "Tn=4*G #time constant of the controller in ms\n", + "print 'Time constant of the controller in SO=Tn=',Tn,'ms'\n", + "V=T1/(2*G) #gain of the control system\n", + "print 'Gain of the control system=V=',V\n", + "Vg=1.0 #gain of the regulating current link\n", + "Vr=V/Vg #gain of the PI regulator\n", + "print 'Gain of the PI regulator=Vr=',Vr\n", + "R1=11.0 #R1 in KiloOhms\n", + "R2=R1*Vr #R2 in kiloohms\n", + "print 'R2=',R2,'Kiloohms'\n", + "C2=Tn/R2 #C1 in microfarads\n", + "C2=round(C2,1)\n", + "print 'C2=',C2,'microfarads'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example12.5,Pg.no.39" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time constant of the controller=Tn= 80 ms\n", + "Gain of the control system=V= 6\n", + "Natural frequency of the system=Wn= 0.118 rad/ ms\n", + "time taken by the system to achieve its desired value=Tf= 28.2 ms\n", + "Maximum overshoot for a symmetrically optimised system is 4.3 percent\n", + "Time at which maximum overload will occur= Tmax= 37.44 ms\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt\n", + "G=6 #smaller time constant in ms\n", + "T1=80 #bigger time constant in ms\n", + "Tn=T1 #time constant of the controller in ms\n", + "print 'Time constant of the controller=Tn=',Tn,'ms'\n", + "V=T1/(2*G) #gain of the control system\n", + "print 'Gain of the control system=V=',V\n", + "Wn=1/(sqrt(2)*G) #Natural frequency of the system in rad/ms\n", + "Wn=round(Wn,3)\n", + "print 'Natural frequency of the system=Wn=',Wn,'rad/ ms'\n", + "Tf=4.7*G #time taken by the system to achiecve i t s desired output for firsttime \n", + "print 'time taken by the system to achieve its desired value=Tf=',Tf,'ms'\n", + "print 'Maximum overshoot for a symmetrically optimised system is 4.3 percent'\n", + "Tmax=6.24*G #time at which maximum overload will occur in ms\n", + "print 'Time at which maximum overload will occur= Tmax=',Tmax,'ms'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example12.6,Pg.no.40" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "time constant of the controller=Tn= 80 ms\n", + "Gain of the control system=V= 4\n", + "time taken by the system to achieve its final value=Tf= 62.0 ms\n", + "Maximum overshoot for a symmetrically optimised system is 43 percent\n" + ] + } + ], + "source": [ + "import math\n", + "G=20 #smaller time constant in ms\n", + "Tn=4*G #time constant of the controller in ms\n", + "print 'time constant of the controller=Tn=',Tn,'ms'\n", + "T1=170 #bigger time constant in ms\n", + "V=T1/(2*G) #gain of the control system\n", + "print 'Gain of the control system=V=',V\n", + "Tf=3.1*G #time taken by the system to achiecve its final value on step input\n", + "print 'time taken by the system to achieve its final value=Tf=',Tf,'ms'\n", + "print 'Maximum overshoot for a symmetrically optimised system is 43 percent'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example12.7,Pg.no.40" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "time taken by the system to achieve its final value=Tf= 47.0 ms\n", + "Maximum overshoot for a symmetrically optimised system is 4.3 percent\n", + "Time at which maximum overshoot will occur =Tmax= 62.4 ms\n", + "Settling time=Ts= 84.0 ms\n" + ] + } + ], + "source": [ + "import math\n", + "G=10 #smaller time constant in ms\n", + "Tf=4.7*G #time taken by the system to achiecve its final output for firsttime\n", + "print 'time taken by the system to achieve its final value=Tf=',Tf,'ms'\n", + "print 'Maximum overshoot for a symmetrically optimised system is 4.3 percent'\n", + "Tmax=6.24*G #time at which maximum overshoot will occur in ms\n", + "print 'Time at which maximum overshoot will occur =Tmax=',Tmax,'ms'\n", + "Ts=8.4*G #settling time in ms\n", + "print 'Settling time=Ts=',Ts,'ms'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example12.8,Pg.no.41" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Response for an AVO system:\n", + "time taken by the system to achieve its final value=Tf= 47.0 ms\n", + "Maximum overshoot for a symmetrically optimised system is 4.3 percent\n", + "Settling time=Ts= 84.0 ms\n", + "Response for an SO system:\n", + "time taken by the system to achieve its final value=Tf= 31.0 ms\n", + "Settling time=Ts= 166.0 ms\n" + ] + } + ], + "source": [ + "import math\n", + "print 'Response for an AVO system:'\n", + "G=10 #smaller time constant in ms\n", + "Tf=4.7*G #time taken by the system to achiecve its f i n a l output for firsttime\n", + "print 'time taken by the system to achieve its final value=Tf=',Tf,'ms'\n", + "print 'Maximum overshoot for a symmetrically optimised system is 4.3 percent'\n", + "Ts=8.4*G #settling time in ms\n", + "print 'Settling time=Ts=',Ts,'ms'\n", + "print 'Response for an SO system:'\n", + "G=10 #smaller time constant in ms\n", + "Tf=3.1*G #time taken by the system to achiecve its f i n a l output for firsttime\n", + "print 'time taken by the system to achieve its final value=Tf=',Tf,'ms'\n", + "Ts=16.6*G #settling time in ms\n", + "print 'Settling time=Ts=',Ts,'ms'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter13_Choppers_and_Transportation_system_Application_1.ipynb b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter13_Choppers_and_Transportation_system_Application_1.ipynb new file mode 100644 index 00000000..798713f1 --- /dev/null +++ b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter13_Choppers_and_Transportation_system_Application_1.ipynb @@ -0,0 +1,304 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter13 Choppers and Transportation system Application" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 13.1,Pg.no.43" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "time constant=t= 4.0 milliseconds\n", + "Discontinuous condition starts from Td= 332.5 microseconds\n", + "Output voltage=Eo= 88.0 volts\n", + "Average current=Iav= 264.0 amp\n", + "Maximum current=Imax= 330.85 amp\n", + "Minimum current=Imin= 199.87 amp\n" + ] + } + ], + "source": [ + "from math import exp\n", + "E=220.0 #dc supply voltage in volts\n", + "El=22.0 #Load voltage in volts\n", + "Ton=1000.0 #conducting period in microseconds\n", + "T=2500.0 #Total timeperiod in microseconds\n", + "L=1.0 #inductance in milliHenry\n", + "R=0.25 #resistance in ohms\n", + "t=L/R #time constant in milliseconds\n", + "print 'time constant=t=',t,'milliseconds'\n", + "A=0.133\n", + "Td=A*T #Discontinuous condition starts at\n", + "print 'Discontinuous condition starts from Td=',Td,'microseconds'\n", + "Eo=0.4*E #output voltage in volts\n", + "print 'Output voltage=Eo=',Eo,'volts'\n", + "Iav=(Eo-El)/R #Average current in amps\n", + "print 'Average current=Iav=',Iav,'amp'\n", + "Imax=((E*(1-exp(-Ton/(t*1000))))/(R*(1-exp(-T/(t*1000)))))-(El/R)\n", + "Imax=round(Imax,2)\n", + "print 'Maximum current=Imax=',Imax,'amp'\n", + "Imin=((E*(exp(Ton/(t*1000))-1))/(R*(exp(T/(t*1000))-1)))-(El/R)\n", + "Imin=round(Imin,2)\n", + "print 'Minimum current=Imin=',Imin,'amp'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 13.2,Pg.no.44" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Conduction period=Ton= 0.75 ms\n", + "Total time period=T= 1.0 ms\n", + "Blocking period=Toff= 0.25 ms\n" + ] + } + ], + "source": [ + "import math\n", + "f=1.0 #operating frequency in KHZ\n", + "E=220.0 #dc supply voltage in volts\n", + "El=165.0 #Load voltage in volts\n", + "Ton=El/(E*f) #conduction period in ms\n", + "print 'Conduction period=Ton=',Ton,'ms'\n", + "T=1/f #total time period in ms\n", + "print 'Total time period=T=',T,'ms'\n", + "Toff=T-Ton #blocking period in ms\n", + "print 'Blocking period=Toff=',Toff,'ms'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 13.3,Pg.no.44" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Load capacitance required for optimum frequency=C= 75.0 microfarad\n", + "Inductance parameters=L1=L2= 0.53 milliHenry\n" + ] + } + ], + "source": [ + "from math import pi\n", + "E=220.0 #dc supply voltage in volts\n", + "Toff=200.0 #blocking period in microseconds\n", + "Il=50.0 #load current in amps\n", + "C=pi*Toff*Il/(2*E) #capacitance for optimum frequency in microfarad\n", + "C=75.0\n", + "print 'Load capacitance required for optimum frequency=C=',C,'microfarad'\n", + "L1=Toff**2*10**-3/C #inductance required in milliHenry\n", + "L2=L1\n", + "L1=round(L1,2)\n", + "print 'Inductance parameters=L1=L2=',L1,'milliHenry'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 13.4,Pg.no.45" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Conduction period=Ton= 200.0 microseconds\n" + ] + } + ], + "source": [ + "import math\n", + "E=220.0 #dc supply voltage in volts\n", + "El=660.0 #Load voltage in volts\n", + "Toff=100.0 #blocking period in microseconds\n", + "Ton=(El/E-1)*Toff #Conduction period in microseconds\n", + "print 'Conduction period=Ton=',Ton,'microseconds'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 13.5,Pg.no.45" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average voltage in the circuit=Eav= 53.0 volts\n", + "Conduction period=Ton= 1.2 ms\n" + ] + } + ], + "source": [ + "import math\n", + "f=200.0 #chopper frequency in HZ\n", + "E=220.0 #dc supply voltage in volts\n", + "Iav=100.0 #Average current in the circuit in amps\n", + "Ra=0.02 #Armature resistance in ohms\n", + "Rf=0.01 #Field resistance in ohms\n", + "Ebav=50 #Average value of the Back emf in volts\n", + "Eav=Iav*(Ra+Rf)+Ebav #Average voltage in the circuit in volts\n", + "print 'Average voltage in the circuit=Eav=',Eav,'volts'\n", + "Ton=Eav*1000/(E*f) #conduction period in ms\n", + "Ton=round(Ton,2)\n", + "print 'Conduction period=Ton=',Ton,'ms'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 13.6,Pg.no.46" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rotor resistance referred to stator=R= 5.2 ohms\n", + "Motor torque=MT= 662.4 Snc . Watts\n" + ] + } + ], + "source": [ + "import math\n", + "f=200.0 #chopper frequency in HZ\n", + "T=1000/f #total time period in ms\n", + "Toff=4.0 #Blocking period in ms\n", + "Ton=T-Toff #conduction period in ms\n", + "R1=2.0 #R1 in ohms\n", + "R2=4.0 #R2 in ohms\n", + "R=((R1*Ton)+(R1+R2)*Toff)/T #rotor resistance referred to stator in ohms\n", + "print 'Rotor resistance referred to stator=R=',R,'ohms'\n", + "V=415.0 #stator voltage in volts\n", + "s=0.02 #slip of the motor\n", + "MT=V**2*s/R #motor torque in Syn . Watts\n", + "MT=round(MT,2)\n", + "print 'Motor torque=MT=',MT,'Snc . Watts'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 13.7,Pg.no.46" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R2=1.5*R1\n", + "the above condition satisfies when Ton= Toff\n", + "Chopper frequency=f= 250.0 hz\n" + ] + } + ], + "source": [ + "import math\n", + "#R1=rotor resistance before introduction of control\n", + "#R2=rotor resistance after introduction of control \n", + "print 'R2=1.5*R1'\n", + "R2=((R1*Ton)+(R1+R1)*Toff)/T #rotor resistance referred to stator in ohms\n", + "print 'the above condition satisfies when Ton= Toff'\n", + "T=4 #total time period in ms\n", + "f=1000/T #chopper frequency in hz\n", + "f=round(f,1)\n", + "print 'Chopper frequency=f=',f,'hz'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter15_The_AC_motor_control_1.ipynb b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter15_The_AC_motor_control_1.ipynb new file mode 100644 index 00000000..7eaa0c91 --- /dev/null +++ b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter15_The_AC_motor_control_1.ipynb @@ -0,0 +1,623 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 15 The AC motor control" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.1,Pg.no.48" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of slip of motor=S2= 50.0 percentage\n", + "value of new stator current=I2= 250.0 Amp\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "S1=2.0 #value of slip in percentage of slip ring induction motor\n", + "Ns=1000.0 #value of stator speed in rpm\n", + "Nr=500.0 #value of rotor speed in rpm\n", + "S2=(Ns-Nr)*100/Ns #valu of slip in percentage of motor\n", + "print 'value of slip of motor=S2=',S2,'percentage'\n", + "I1=50.0 #stator current in amps\n", + "I2=I1*sqrt(S2/S1)\n", + "print 'value of new stator current=I2=',I2,'Amp'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.2,Pg.no.48" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of converter rated current=Icr= 75.0 amp\n", + "value of converter rated ac voltage=Vac= 74.07 volts\n", + "KVA rating of transformer=Pkva= 7.875 KVA\n" + ] + } + ], + "source": [ + "import math\n", + "Imr=50.0 #motor field rating in amp//\n", + "Icr=1.5*Imr #converter rated current in amp\n", + "print 'value of converter rated current=Icr=',Icr,'amp'\n", + "Vdc=100.0 #converter dc rating in volts\n", + "Vac=Vdc/1.35 #converter ac rating voltage required\n", + "Vac=round(Vac,2)\n", + "print 'value of converter rated ac voltage=Vac=',Vac,'volts'\n", + "Pkva=(1.05*100*75)/1000 #KVA rating of the transformer\n", + "print 'KVA rating of transformer=Pkva=',Pkva,'KVA'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.3,Pg.no.49" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of speed N1= 1440.0 rpm\n", + "value of f= 0.3\n", + "value of new torque developed=T2= 6666.7 Watts\n" + ] + } + ], + "source": [ + "import math\n", + "S1=0.04 #value of slip in of induction motor\n", + "Ns=1500.0 #value of initial speed in rpm\n", + "N2=1300.0 #value of speed reduced to in rpm\n", + "N1=Ns*(1-S1) #value of speed N1 in rpm\n", + "print 'value of speed N1=',N1,'rpm'\n", + "f=(Ns-N1)/(Ns-N2)\n", + "print 'value of f=',f\n", + "T1=2000.0 #developing torque in induction motor in watts\n", + "T2=T1/f #new value of torque developed by the motor in watts\n", + "T2=round(T2,1)\n", + "print 'value of new torque developed=T2=',T2,'Watts'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.4,Pg.no.49" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of new torque developed=Tb= 1000.0 Watts\n" + ] + } + ], + "source": [ + "import math\n", + "f1a=50.0 #initial frequency in hertz\n", + "f1b=75.0 #value of frequency increased to in hertz\n", + "Ta=1500.0 #developing torque in induction motor in watts\n", + "Tb=Ta*f1a/f1b #new value of torque developed by the motor in watts\n", + "print 'value of new torque developed=Tb=',Tb,'Watts'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.5,Pg.no.50" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torque developed by motor=T= 6889.0 watts\n", + "value of rotor frequency=f2= 3.0 hertz\n" + ] + } + ], + "source": [ + "import math\n", + "V=415.0 #operating input voltage of induction motor in volts\n", + "S=0.04 #input slip\n", + "r2=1.0 #rotor resistance referred to stator in ohms\n", + "T=(S*V**2)/r2 #torque developed by motor in watts\n", + "print 'torque developed by motor=T=',T,'watts'\n", + "f1=75.0 #input stator frequency in hertz\n", + "f2=S*f1 #rotor frequency in hertz\n", + "print 'value of rotor frequency=f2=',f2,'hertz'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.6,Pg.no.50" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of input voltage to the motor=Vb= 249.0 volts\n", + "value of input power to the motor=Pb= 60.0 KVA\n" + ] + } + ], + "source": [ + "import math\n", + "f1a=50.0 #intial frequency in hertz\n", + "f1b=30.0 #value of frequency reduced to in hertz\n", + "Va=415.0 #operating voltage of induction motor in volts\n", + "Vb=Va*f1b/f1a #input voltage to the motor in volts\n", + "print 'value of input voltage to the motor=Vb=',Vb,'volts'\n", + "Pa=100.0 #operating power of induction motor in KVA\n", + "Pb=Pa*f1b/f1a #input power to the motor in KVA\n", + "print 'value of input power to the motor=Pb=',Pb,'KVA'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.7,Pg.no.51" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of frequency changed to f1b= 30.0 hz\n", + "speed at 4 percent slip=Nb= 864.0 rpm\n", + "value of stator voltage to the motor=Vb= 243.75 volts\n", + "torque if stator drop is negligible=T= 1592.36 watts\n", + "rotor copper loss=P2= 6.0 KVA\n" + ] + } + ], + "source": [ + "import math\n", + "f1a=40.0 #intial frequency in hertz\n", + "Pa=200.0 #input power of squirrel cage motor in KVA\n", + "Pb=150.0 #input power to the motor after change in speed in KVA\n", + "f1b=f1a*Pb/Pa #frequency changed to in hertz\n", + "print 'value of frequency changed to f1b=',f1b,'hz'\n", + "Nsa=1200.0 #motor initial syncronous speed in rpm\n", + "Nsb=Nsa*f1b/f1a\n", + "Sb=0.04\n", + "Nb=Nsb*(1-Sb) #speed in rpm at 4% slip\n", + "print 'speed at 4 percent slip=Nb=',Nb,'rpm'\n", + "Va=325 #operating voltage of induction motor in volts\n", + "Vb=Va*f1b/f1a #stator voltage to the motor in volts\n", + "print 'value of stator voltage to the motor=Vb=',Vb,'volts'\n", + "Pag=150.0 #power transferred from stator to rotor at 30 hz in KVA\n", + "Ws=2*3.14*Nsb/60\n", + "T=Pag*1000/Ws #torque if stator drop is negligible in watts\n", + "T=round(T,2)\n", + "print 'torque if stator drop is negligible=T=',T,'watts'\n", + "P2=Sb*Pag #rotor copper loss in KVA\n", + "print 'rotor copper loss=P2=',P2,'KVA'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.8,Pg.no.52" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of stator frequency increased to f1b= 57.74 hertz\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "f1a=50.0 #i n t i a l input frequency in hertz\n", + "Ta=2000.0 #developing torque in induction motor in watts\n", + "Tb=1500.0 #new value of torque reduced to in watts\n", + "f1b=f1a*sqrt(Ta/Tb) #value of stator frequency increased to in hertz\n", + "f1b=round(f1b,2)\n", + "print 'value of stator frequency increased to f1b=',f1b,'hertz'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.9,Pg.no.52" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "firing angle starts from A1= 84.0 degrees\n", + "firing angle ends at A2= 65.2 degrees\n", + "input power factor=IPF= 0.0591\n", + "distortion factor=Mh= 0.3379\n" + ] + } + ], + "source": [ + "from math import pi,sqrt\n", + "Vom1=sqrt(2)*41.5 #starting rms value of output voltage\n", + "Vom2=sqrt(2)*166 #ending rms value of output voltage\n", + "V=415.0 #operating voltage of cyclo converter\n", + "A1=(math.acos(Vom1/(1.35*V)))*180/pi #firing angle starts from\n", + "A1=round(A1,1)\n", + "print 'firing angle starts from A1=',A1,'degrees'\n", + "A2=(math.acos(Vom2/(1.35*V)))*180/pi #f i r i n g angle ends at \n", + "A2=round(A2,1)\n", + "print 'firing angle ends at A2=',A2,'degrees'\n", + "PFl=0.8 #load power factor\n", + "IPF=math.cos(pi*7/15)*PFl/sqrt(2) #input power factor\n", + "DF=0.7 #input displacement factor\n", + "IPF=round(IPF,4)\n", + "print 'input power factor=IPF=',IPF\n", + "Mh=math.cos(pi*0.3627)*PFl/(sqrt(2)*DF)\n", + "Mh=round(Mh,4)\n", + "print 'distortion factor=Mh=',Mh" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.10,Pg.no.53" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trigger angle ranges fromA5= 83.99 degrees\n", + "trigger angle ranges upto A51= 96.01 degrees\n", + "highest value of input power factor=HIPF= 0.2\n", + "lowest value of input power factor=LIPF= 0.07\n", + "highest value of distortion factor=HDF= 0.27\n", + "lowest value of distortion factor=LDF= 0.09\n" + ] + } + ], + "source": [ + "from math import sqrt,pi\n", + "Vo5m=sqrt(2)*41.5 #rms value of output voltage\n", + "V=415.0 #operating voltage of cyclo converter\n", + "A5=(math.acos(Vo5m/(1.35*V)))*180/pi #trigger angle ranges from\n", + "A5=round(A5,2)\n", + "print 'trigger angle ranges fromA5=',A5,'degrees'\n", + "A51=180.0-A5 #trigger angle ranges upto\n", + "A51=round(A51,2)\n", + "print 'trigger angle ranges upto A51=',A51,'degrees'\n", + "LPF=0.9 #load power factor\n", + "CA15=0.3132 #maximum cosine value corresponding to operating frequency 15hz\n", + "HIPF=CA15*LPF/sqrt(2) #highest value of input power factor\n", + "HIPF=round(HIPF,2)\n", + "print 'highest value of input power factor=HIPF=',HIPF\n", + "LIPF=math.cos(A5*pi/180)*LPF/sqrt(2) #lowest value of input power factor\n", + "LIPF=round(LIPF,2)\n", + "print 'lowest value of input power factor=LIPF=',LIPF\n", + "IDF=0.75 #input displacement factor\n", + "HDF=CA15*LPF/(sqrt(2)*IDF) #highest value of distortion factor\n", + "HDF=round(HDF,2)\n", + "print 'highest value of distortion factor=HDF=',HDF\n", + "LDF=HDF*math.cos(A5*pi/180)/CA15 #lowest value of distortion factor\n", + "LDF=round(LDF,2)\n", + "print 'lowest value of distortion factor=LDF=',LDF" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.11,Pg.no.54" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "highest value of cosAm= 0.866\n", + "laod power factor of cyclo converter= 0.817\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt\n", + "PFm=0.5 #highest value of input factor\n", + "Am=3.14/6 #highest value of input powerfactor occurs at 30 degrees\n", + "A=math.cos(Am) #highest value of cosAm if firingangle ranging from 30 to 150\n", + "A=round(A,3)\n", + "print 'highest value of cosAm=',A\n", + "PFl=(sqrt(2)*PFm)/A\n", + "PFl=round(PFl,3)\n", + "print 'laod power factor of cyclo converter=',PFl" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.12,Pg.no.54" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input displacement factor= 0.857\n" + ] + } + ], + "source": [ + "import math\n", + "PFi=0.6 #input powerfactor\n", + "DF=0.7 #distortion factor\n", + "IDF=PFi/DF #input displacement factor\n", + "IDF=round(IDF,3)\n", + "print 'input displacement factor=',IDF" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.13,Pg.no.54" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "firing angle of cyclo converter drive=A= 81.0 degrees\n", + "distortion factor=DF= 0.143\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "PFi=0.1 #input powerfactor\n", + "PFl=0.9 #load powerfactor\n", + "A=(math.acos(sqrt(2)*PFi/PFl))*180/3.14 #firing angle indegrees\n", + "A=round(A,2)\n", + "print 'firing angle of cyclo converter drive=A=',A,'degrees'\n", + "IDF=0.7 #leading input displacement factor\n", + "DF=PFi/IDF #distortion factor\n", + "DF=round(DF,3)\n", + "print 'distortion factor=DF=',DF" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.14,Pg.no.55" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "triggering angle of negative group=An= 150.0 degrees\n" + ] + } + ], + "source": [ + "import math\n", + "Ap=30.0 #triggering angle of positive group in degrees\n", + "An=180-Ap #triggering angle of negative group in degrees\n", + "print 'triggering angle of negative group=An=',An,'degrees'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.15,Pg.no.55" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input current to the converter=I= 100.362 amp\n" + ] + } + ], + "source": [ + "from math import pi,sqrt\n", + "V=415.0 #input operating voltage of cycloconverter in volts\n", + "Pi=50.0 #input power of the cycloconverter in KVA\n", + "PF=0.8 #input power factor\n", + "A=0.785 #firing angle in radians \n", + "I=(Pi*1000*sqrt(2))/(3*V*PF*math.cos(A)) #input current to the converter in amp\n", + "I=round(I,3)\n", + "print 'input current to the converter=I=',I,'amp'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 15.16,Pg.no.56" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "load power factor of motor=PF= 0.83\n" + ] + } + ], + "source": [ + "import math\n", + "Vo=200.0 #input operating voltage of cycloconverter in volts\n", + "Po=50*10**3 #input power of the cycloconverter in VA\n", + "Io=100.0 #drawing current from motor in amp\n", + "PF=Po/(3*Vo*Io) #load power factor\n", + "PF=round(PF,2)\n", + "print 'load power factor of motor=PF=',PF" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter16_Faults_and_Protection_1.ipynb b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter16_Faults_and_Protection_1.ipynb new file mode 100644 index 00000000..07232131 --- /dev/null +++ b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter16_Faults_and_Protection_1.ipynb @@ -0,0 +1,281 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter16 Faults and Protection" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example16.1,Pg.no.57" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "peak inverse voltage of the device=PIV= 2969.71 Volts\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "V=415.0 #AC input voltage\n", + "Vf=2.53 #voltage safety factor\n", + "PIV=2*sqrt(2)*V*Vf #peak inverse voltage of the device\n", + "PIV=round(PIV,2)\n", + "print 'peak inverse voltage of the device=PIV=',PIV,'Volts'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example16.2,Pg.no.57" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "voltage safety factor of the device=Vf= 2.3\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "V=415.0 #AC input voltage in volts\n", + "PIV=1350.0 #peak inverse voltage of the device in volts\n", + "Vf=PIV/(sqrt(2)*V) #voltage safety factor of the device\n", + "Vf=round(Vf,2)\n", + "print 'voltage safety factor of the device=Vf=',Vf" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example16.3,Pg.no.58" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "choke power of the converter=Pc= 8.0 KVA\n" + ] + } + ], + "source": [ + "import math\n", + "P=100.0 #input power in KVA\n", + "Xt=0.04 #limiting ac reactance value\n", + "Fov=2.0 #current ovarload factor\n", + "Pc=Xt*P*Fov #choke power of the converter in KVA\n", + "print 'choke power of the converter=Pc=',Pc,'KVA'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example16.4,Pg.no.58" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "capacitance in snubber circuit=C= 625.0 nanofarads\n", + "Resistance in snubber circuit=R= 3.58 Kilo Ohms\n", + "Permissible dv/dt of the circuit= 30.0 MV/s\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "Ls=0.1 #stray inductance in the circui t in milli Henry\n", + "L=2*Ls #inductance required for the snubber ckt for protection in mH\n", + "Im=250.0 #mean value of current in amp\n", + "C=2.5*Im #capacitance required for the snubber ckt in nano Farads\n", + "print 'capacitance in snubber circuit=C=',C,'nanofarads'\n", + "R=2*100*sqrt(L/C) #resistance in snubber circ uit in Kilo Ohms\n", + "R=round(R,2)\n", + "print 'Resistance in snubber circuit=R=',R,'Kilo Ohms'\n", + "Pdif=1*30.0 #permissible dv/dt of the circuit\n", + "print 'Permissible dv/dt of the circuit=',Pdif,'MV/s'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example16.5,Pg.no.59" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of plates in series in the circuit=N= 9.6\n", + "So,we will use 10 plates in the circuit\n" + ] + } + ], + "source": [ + "import math\n", + "V=240.0 #dc input voltage in volts\n", + "Vh=25.0 #each selenium plate handling voltage in volts\n", + "N=V/Vh #number of plates in series in the circuit\n", + "print 'number of plates in series in the circuit=N=',N\n", + "print 'So,we will use 10 plates in the circuit'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example16.6,Pg.no.59" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of plates in series in each direction =N= 9.0\n", + "total number of plates in series in both directions=Nt= 18.0\n" + ] + } + ], + "source": [ + "import math\n", + "V=230.0 #ac input voltage in volts\n", + "Vh=30.0 #each selenium plate handling voltage in volts\n", + "N=(V/Vh)+1 #number of plates in series in each direction in the ckt\n", + "N=round(N,0)\n", + "print 'number of plates in series in each direction =N=',N\n", + "Nt=2*N #total number of plates in series in the circuit\n", + "Nt=round(Nt,0)\n", + "print 'total number of plates in series in both directions=Nt=',Nt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example16.7,Pg.no.59" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of plates in each branch=N= 15.0\n", + "total number of plates=Nt= 45.0\n", + "Armature circuit inductance=L= 5.25 mH\n", + "Energy stored in armature circuit=Es= 48.55 wattsec\n", + "Energy dissipated per plate=Ed= 3.24 wattsec\n" + ] + } + ], + "source": [ + "import math\n", + "V=415.0 #ac input voltage in volts\n", + "Vdc=440.0 #supplied voltage to dc motor in volts\n", + "Vh=30.0 #each selenium plate handling voltage in volts\n", + "N=Vdc/Vh #number of plates in series in each direction in the ckt\n", + "N=15.0\n", + "print 'number of plates in each branch=N=',N\n", + "Nt=3*N #total number of plates in series in the circuit\n", + "Nt=round(Nt,0)\n", + "print 'total number of plates=Nt=',Nt\n", + "Ipa=136.0 #peak armature current in amperes\n", + "T=30.0 #time constant in milliseconds\n", + "R=0.175 #Armature resistance in Ohms\n", + "L=T*R #Armature circuit Inductance in milliHenry\n", + "L=round(L,2)\n", + "print 'Armature circuit inductance=L=',L,'mH'\n", + "Es=0.5*L*Ipa**2*10**-3 #Energy stored in armature circuit in wattsec\n", + "Es=round(Es,2)\n", + "print 'Energy stored in armature circuit=Es=',Es,'wattsec'\n", + "Ed=Es/N #Energy dissipated per plate in wattsec\n", + "Ed=round(Ed,2)\n", + "print 'Energy dissipated per plate=Ed=',Ed,'wattsec'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter3_Fabrication_and_Thermal_characteristics_1.ipynb b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter3_Fabrication_and_Thermal_characteristics_1.ipynb new file mode 100644 index 00000000..c3ba0c41 --- /dev/null +++ b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter3_Fabrication_and_Thermal_characteristics_1.ipynb @@ -0,0 +1,213 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter3 Fabrication and Thermal characteristics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.1, Pg.no 10" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of junction temperature= 72.5 c\n" + ] + } + ], + "source": [ + "import math \n", + "Xa=50 #Ambient temperature\n", + "P=150 #on state power loss in Watts\n", + "Rjc=0.02 #junction case thermal resistance\n", + "Rcs=0.05 #case sink thermal resistance\n", + "Rsa=0.08 #sink atmosphere thermal resistance\n", + "Xj=Xa+P*(Rjc+Rcs+Rsa) #junction temperature \n", + "Xj=round(Xj,1)\n", + "print 'value of junction temperature=',Xj,'c'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.2,Pg.no 10" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of time period of one cycle= 248 s\n", + "value of junction temperature= 54.75 c\n", + "power required to cool down= 325 watts\n", + "value of maximum junction temperature= 106.01 c\n" + ] + } + ], + "source": [ + "from math import exp\n", + "import math\n", + "Xa=50 #Ambient temperature\n", + "P20=25 #on state power loss at 20%load in Watts\n", + "P200=350 #on state power loss at 200%load in Watts\n", + "Rjc=0.02 #junction case thermal resistance\n", + "Rcs=0.05 #case sink thermal resistance\n", + "Rsa=0.12 #sink atmosphere thermal resistance at 20% load cycle\n", + "T1=60 #time period for the supply of 200% load\n", + "T=((200**2-202)*T1)/(100**2-20**2) #time period of one cycle\n", + "print 'value of time period of one cycle=',T,'s'\n", + "Ts=140 #thermal time constant for heat sink\n", + "Xj20=Xa+P20*(Rjc+Rcs+Rsa) #junction temperature\n", + "print 'value of junction temperature=',Xj20,'c'\n", + "P=P200 -P20 #power required to cool down from 200 %load cycle to 20% load cycle\n", + "print 'power required to cool down=',P,'watts'\n", + "Rsa200=((Rsa)*(1-exp(-T1/Ts)))/(1-exp(-T/Ts)) #sink atmosphere thermal resistance at 200% load cycle\n", + "Xj200=Xj20+(P*(Rjc+Rcs+Rsa200)) #maximum junction temperature\n", + "Xj200=round(Xj200,2)\n", + "print 'value of maximum junction temperature=',Xj200,'c'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.3 ,Pg.no11" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of junction temperature= 62.0 c\n" + ] + } + ], + "source": [ + "import math \n", + "Xa=35 #Ambient temperature\n", + "P=150 #on state power loss in Watts\n", + "Rjc=0.01 #junction case thermal resistance\n", + "Rcs=0.08 #case sink thermal resistance\n", + "Rsa=0.09 #sink atmosphere thermal resistance\n", + "Xj=Xa+P*(Rjc+Rcs+Rsa) #junction temperature\n", + "print 'value of junction temperature=',Xj,'c'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.4,Pg.no 12" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of on state power loss= 416.67 watts\n" + ] + } + ], + "source": [ + "import math\n", + "Xa=45 #Ambient temperature \n", + "Rjs=0.1 #junction sink thermal resistance \n", + "Rsa=0.08 #sink atmosphere thermal resistance \n", + "Xj=120 #junction temperature\n", + "P=(Xj-Xa)/(Rjs+Rsa) #on state power loss\n", + "P=round(P,2)\n", + "print 'value of on state power loss=',P,'watts'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.5,Pg.no 12" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of case sink thermal resistance= -0.115 c/w\n" + ] + } + ], + "source": [ + "import math\n", + "Xa=40 #Ambient temperature\n", + "P=300 #on state power loss in Watts\n", + "Rjc=0.015 #junction case thermal resistance\n", + "Rsa=0.1 #sink atmosphere thermal resistance\n", + "Xj=105 #junction temperature\n", + "Rcs=((Xj-Xa)/(P))-(Rjc+Rsa) #case sink thermal resistance\n", + "print 'value of case sink thermal resistance=',Rcs,'c/w'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter4_Series_and_Parallel_Connection_of_Thyristors_1.ipynb b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter4_Series_and_Parallel_Connection_of_Thyristors_1.ipynb new file mode 100644 index 00000000..075b01fe --- /dev/null +++ b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter4_Series_and_Parallel_Connection_of_Thyristors_1.ipynb @@ -0,0 +1,106 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter4 Series and Parallel Connection of Thyristors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.1,Pg.no 13" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of Devices in Series= 5.0\n", + "Number of Devices in Parallel= 3.0\n" + ] + } + ], + "source": [ + "import math\n", + "Vc=3500 #voltage rating of circuit\n", + "Vt=750 #voltage rating of each thyristor\n", + "Ic=1500 #current rating of circuit\n", + "It=500 #current rating of each thyristor\n", + "DF=0.1 #Derating factor of circuit\n", + "Ns=Vc/(Vt*(1-DF)) #number of devices in series\n", + "Ns=round(Ns,0)\n", + "print 'Number of Devices in Series=',Ns\n", + "Np=Ic/(It*(1-DF)) #number of devices in parallel\n", + "Np=round(Np,0)\n", + "print 'Number of Devices in Parallel=',Np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.2,Pg.no 13" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of equivalent resistance=R= 20000.0 ohms\n", + "value of equivalent capacitance=C1= 0.5 microfarads\n" + ] + } + ], + "source": [ + "import math\n", + "Ed=20.0 #permissible difference in voltage across devices in Volts\n", + "Id=1*10**-3 #maximum difference in latching current across devices in Amperes\n", + "Qd=10.0 #difference in recovery charge in Micro coloumbs\n", + "Vd=20.0 #permissible difference in blocking voltage in Volts\n", + "R=Ed/Id #equivalent resistance in Ohms\n", + "R1=R\n", + "print 'value of equivalent resistance=R=',R1,'ohms'\n", + "C1=Qd/Vd #equivalent capacitance in Micro farads\n", + "print 'value of equivalent capacitance=C1=',C1,'microfarads'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter5_Line_Commutated_converters_1.ipynb b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter5_Line_Commutated_converters_1.ipynb new file mode 100644 index 00000000..00a99c8b --- /dev/null +++ b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter5_Line_Commutated_converters_1.ipynb @@ -0,0 +1,349 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter5 Line Commutated converters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.1,Pg.no15" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cosine of the firing angle=C= 0.79\n", + "firing angle of the converter=A= 37.81 degrees\n", + "AC terminal power=Pac= 58.83 KW\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi\n", + "Edc=440 #dc terminal voltage of the thyristor in volts\n", + "E2=415 #input voltage of the thyristor in volts\n", + "Id=100 #dc motor current in amps\n", + "C=Edc/(1.35*E2)\n", + "C=round(C,2)\n", + "print 'cosine of the firing angle=C=',C\n", + "A=math.acos(C)*180/pi\n", + "A=round(A,2)\n", + "print 'firing angle of the converter=A=',A,'degrees'\n", + "Pac=1.05*1.35*E2*Id/1000 #Ac terminal power in Kilo watts\n", + "Pac=round(Pac,2)\n", + "print 'AC terminal power=Pac=',Pac,'KW'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.2,Pg.no15" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AC line current of the thyristor=I2= 163.4 amperes\n", + "effective reactance of the thyristor=Xt= 0.15 ohms\n", + "cosine value of the commutational angle=C= 0.96\n", + "commutation angle=CA= 16.2602047083 degrees\n", + "Inductive voltage regulation=IVR= 0.02\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt\n", + "Id=200 #rated dc current in amperes\n", + "I2=0.817*Id #AC line current in amperes\n", + "print 'AC line current of the thyristor=I2=',I2,'amperes'\n", + "E2=415 #AC line voltage in volts\n", + "Xt=0.06*E2/I2 #effective reactance of the thyristor in ohms\n", + "Xt=round(Xt,2)\n", + "print 'effective reactance of the thyristor=Xt=',Xt,'ohms'\n", + "C=1-((Id*Xt)/(E2*sqrt(3))) #cosine value of the commutational angle\n", + "C=round(C,2)\n", + "print 'cosine value of the commutational angle=C=',C\n", + "CA=math.acos(C)*180/pi\n", + "print 'commutation angle=CA=',CA,'degrees'\n", + "IVR=(1-C)/2 #inductive voltage regulation\n", + "IVR=round(IVR,3)\n", + "print 'Inductive voltage regulation=IVR=',IVR" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.3,Pg.no16" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "maximum value of dc voltage=Emax2= 586.9 volts\n", + "rms current through the device=Irms= 56.82 amps\n" + ] + } + ], + "source": [ + "from math import sqrt,pi\n", + "E2=415 #input voltage in volts\n", + "Edc=1.17*E2 #dc terminal voltage in volts \n", + "Emax2=sqrt(2)*E2 #maximum value of dc voltage\n", + "Z=2 #total impedance in ohms\n", + "Emax2=round(Emax2,2)\n", + "print 'maximum value of dc voltage=Emax2=',Emax2,'volts'\n", + "Irms=Emax2*sqrt(pi/3+sqrt(3)/4)/(2*pi*Z)\n", + "Irms=round(Irms,2)\n", + "print 'rms current through the device=Irms=',Irms,'amps'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.4,Pg.no 17" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cosine of the firing angle=C= 0.82\n", + "firing angle of the converter=A= 34.92 degrees\n", + "dc power delivered by the converter=Pdc= 92 KW\n", + "AC terminal power=Pac= 96.6 KVA\n", + "AC line current=Iac= 134.39 amps\n", + "Branch current through the device=Ib= 116.0 amps\n" + ] + } + ], + "source": [ + "from math import sqrt,pi\n", + "Edc=460 #dc terminal voltage of the thyristor in volts\n", + "E2=415 #input voltage of the thyristor in volts\n", + "Id=200 #dc motor current in amps\n", + "C=Edc/(1.35*E2)\n", + "C=round(C,2)\n", + "print 'cosine of the firing angle=C=',C\n", + "A=math.acos(C)*180/pi\n", + "A=round(A,2)\n", + "print 'firing angle of the converter=A=',A,'degrees'\n", + "Pdc=Edc*Id/1000 #dc power delivered by the converter in kilo Watts\n", + "print 'dc power delivered by the converter=Pdc=',Pdc,'KW'\n", + "Pac=1.05*Pdc #Ac terminal power in KVA\n", + "print 'AC terminal power=Pac=',Pac,'KVA'\n", + "Iac=Pac*1000/(sqrt(3)*E2)\n", + "Iac=round(Iac,2)\n", + "print 'AC line current=Iac=',Iac,'amps'\n", + "Ib=0.58*Id #Branch current through the device in amps\n", + "print 'Branch current through the device=Ib=',Ib,'amps'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.5,Pg.no 17" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cosine value of the commutational angle=C= 0.96\n", + "effective reactance of the thyristor=Xt= 0.19 ohms\n" + ] + } + ], + "source": [ + "import math\n", + "from math import pi,sqrt\n", + "Id=150 #rated dc current in amperes\n", + "E2=415 #AC line voltage in volts\n", + "Emax=sqrt(2)*E2\n", + "C=math.cos(16*pi/180) #cosine value of the commutational angle\n", + "C=round(C,2)\n", + "print 'cosine value of the commutational angle=C=',C\n", + "Xt=(1-C)*E2*sqrt(3)/Id #effective reactance of the thyristor in ohms\n", + "Xt=round(Xt,2)\n", + "print 'effective reactance of the thyristor=Xt=',Xt,'ohms'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.6,Pg.no 18" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AC load current=Id= 63.81 amps\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt,pi\n", + "E2=230 #AC line voltage in volts\n", + "Emax=sqrt(2)*E2 \n", + "C=math.cos(13*pi/180) #cosine value of the commutational angle\n", + "Xt=0.16 #effective reactance of the thyristor in ohms\n", + "Id=(1-C)*E2*sqrt(3)/Xt #AC load current in amperes\n", + "Id=round(Id,2)\n", + "print 'AC load current=Id=',Id,'amps'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.7,Pg.no 18" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average value of dc voltage=Edc= 96.6 volts\n", + "Effective value of voltage=Eeff= 160.27 volts\n", + "Load current=Id= 9.66 amps\n" + ] + } + ], + "source": [ + "import math\n", + "from math import sqrt,pi\n", + "E2=230 #input voltage in volts\n", + "Emax=sqrt(2)*E2 #maximum value of dc voltage\n", + "A=pi/6\n", + "Edc=Emax*(1+math.cos(A))/(2*pi)\n", + "Edc=round(Edc,2)\n", + "print 'Average value of dc voltage=Edc=',Edc,'volts'\n", + "Eeff=Emax*sqrt((pi-A)/(4*pi)+(math.sin(2*A)/(8*pi)))\n", + "Eeff=round(Eeff,2)\n", + "print 'Effective value of voltage=Eeff=',Eeff,'volts'\n", + "R=10 #total impedance in ohms\n", + "Id=Edc/R\n", + "Id=round(Id,2)\n", + "print 'Load current=Id=',Id,'amps'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.8,Pg.no 19" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dc output voltage=Edc= 161.79 volts\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "E2=415 #input voltage in volts\n", + "Emax=sqrt(2)*E2 #maximum value of dc voltage\n", + "A=pi/6 #triggering angle in degrees\n", + "Edc=Emax*math.cos(A)/pi #dc output voltage in volts\n", + "Edc=round(Edc,2)\n", + "print 'dc output voltage=Edc=',Edc,'volts'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter7_Inverter_Circuits_1.ipynb b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter7_Inverter_Circuits_1.ipynb new file mode 100644 index 00000000..8ed5fba6 --- /dev/null +++ b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter7_Inverter_Circuits_1.ipynb @@ -0,0 +1,138 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter7 Inverter Circuits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.1,Pg.no.20" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of w= 24494.9 rad/sec\n", + "value of the Output Frequency=F= 3047.0 Hertz\n", + "value of the Attenuation Factor=AF= 0.0014\n" + ] + } + ], + "source": [ + "from math import pi,sqrt,exp\n", + "L=10*10**-3 #Inductance of s e r i e s inverter cir cui t in Henry\n", + "C=0.1*10**-6 #Capacitance of s e r i e s inverter ci rcu it in Farads\n", + "R=400 #Load Resistance in Ohms\n", + "Toff=0.2*10**-3 #Off time of Duty cycle in sec\n", + "w=sqrt((1/(L*C))-(R**2/(4*L**2))) #Angular Frequency in rad/ sec\n", + "w=round(w,1)\n", + "print 'value of w=',w,'rad/sec'\n", + "F=w/(3.14+(w*Toff)) #Output Frequency in Hertz\n", + "F=round(F,1)\n", + "print 'value of the Output Frequency=F=',F,'Hertz'\n", + "T=1/F #Time period of Output in sec\n", + "AF=exp((-R/(2*L))*T) #Attenuation Factor\n", + "AF=round(AF,4)\n", + "print 'value of the Attenuation Factor=AF=',AF" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.2,Pg.no.21" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of Inductance at resonance=L= 0.04 Henry\n" + ] + } + ], + "source": [ + "import math\n", + "C=1*10**-6 #Capacitance of series inverter circuit in Farads\n", + "f=5*10**3 #operating Frequency of series Inverter in Hertz\n", + "L=1/(C*(f**2)) #value of Inductance under Resonance condition in Henry\n", + "print 'value of Inductance at resonance=L=',L,'Henry'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.3,Pg.no.21" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of resistance=R1= -12401.01 Ohms\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "L=5*10**-3 #Inductance of series inverter circuit in Henry\n", + "C=1*10**-6 #Capacitance of series inverter circuit in Farads\n", + "Rl=400 #Load Resistance in Ohms\n", + "R2=10**4 #value of the second resistance in Ohms\n", + "DF=0.7 #Damping Factor value of LC filter\n", + "R1=(2*(DF)*(sqrt(L/C)))-R2 -(1/(Rl*C)) #value of the first resistance in Ohms\n", + "R1=round(R1,2)\n", + "print 'value of resistance=R1=',R1,'Ohms'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter8_Harmonic_and_PowerFactor_with_the_converter_system_1.ipynb b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter8_Harmonic_and_PowerFactor_with_the_converter_system_1.ipynb new file mode 100644 index 00000000..de9d3e6c --- /dev/null +++ b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter8_Harmonic_and_PowerFactor_with_the_converter_system_1.ipynb @@ -0,0 +1,457 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter8 Harmonic and PowerFactor with the converter system" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example8.1,Pg.no.22" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of AC converter power=Pc= 5.06 MVAR\n", + "value of the capacitance of shunt filter=C = 0.4 millifarads\n", + "Inductance of filter=L= 1.08 milliHenry\n", + "Resistance of filter=R= 33.91 milliOhms\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "I5=0.2 #amplitude of 5th harmonic current in Kilo Amperes\n", + "Vp= 11/(sqrt(3)) #Input supply phase voltage in Kilo Volts\n", + "P=5 #supply power per phase of filter in MVAR\n", + "Pc=P+((Vp**2*I5**2)/(5*P)) #AC Converter power per phase in MVAR\n", + "Pc=round(Pc,2)\n", + "print 'value of AC converter power=Pc=',Pc,'MVAR'\n", + "C=(Pc*10**3*3) /(11**2*314) #capacitance of the ShuntFilter in milliFarad\n", + "C=round(C,2)\n", + "print 'value of the capacitance of shunt filter=C =',C,'millifarads'\n", + "L=(106*10**6)/(400*4*25*250*3.14**2) #inductance of filter in mHenry\n", + "L=round(L,2)\n", + "print 'Inductance of filter=L=',L,'milliHenry'\n", + "Q=50 #value of Q\n", + "W5=2*3.14*5*50 #angular frequency of 5th harmonic\n", + "R=(W5*L)/Q #Resistance of filter in milliOhms\n", + "R=round(R,2)\n", + "print 'Resistance of filter=R=',R,'milliOhms'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example8.2,Pg.no.23" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For six pulse converter most effective harmonic is 6th and for worst case a=90 degree\n", + "voltage ripple=Wv= 24.1 percent\n", + "Harmonic current for 6th harmonic=I6= 10.0 amp\n", + "additional inductance required=L= 4.93 milliHenry\n" + ] + } + ], + "source": [ + "import math\n", + "print 'For six pulse converter most effective harmonic is 6th and for worst case a=90 degree'\n", + "Wv=24.1 #voltage ripple in percentage\n", + "print 'voltage ripple=Wv=',Wv,'percent'\n", + "Id=200.0\n", + "I6=(5*Id)/100 #Harmonic current for 6th harmonic in amp\n", + "I6=round(I6,1)\n", + "print 'Harmonic current for 6th harmonic=I6=',I6,'amp'\n", + "Edc=460.0 #dc voltage in volts\n", + "W=2*3.14*50\n", + "La=1.0 #inductance already present in the circuit in milliHenry\n", + "L=((Wv*Edc*10)/(I6*6*W))-La #additional inductance required in milliHenry\n", + "L=5.93-1.0\n", + "L=round(L,2)\n", + "print 'additional inductance required=L=',L,'milliHenry'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example8.3,Pg.no.24" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AC line current of the thyristor=I2= 163.4 amperes\n", + "effective reactance of the thyristor=Xt= 0.1 ohms\n", + "cosine value of the commutational angle=C= 0.97\n", + "commutation angle=CA= 14.07 degrees\n", + "cosine value of the firing value=F= 0.72\n", + "firing angle=FA= 43.95 degrees\n", + "AC line current=I2= 163.4 amps\n", + "Current through each device=Ied= 116.0 amps\n", + "power factor=PF= 0.71\n", + "active power drawn from the mains=AP= 83390.99 Watts\n", + "Reactive power drawn=RP= 82709.96 VAR\n" + ] + } + ], + "source": [ + "from math import sqrt,pi\n", + "Id=200 #rated dc current in amperes\n", + "I2=0.817*Id #AC line current in amperes\n", + "print 'AC line current of the thyristor=I2=',I2,'amperes'\n", + "E2=415 #AC line voltage in volts\n", + "Edc=400 #dc terminal voltage in volts\n", + "Xt=0.04*E2/I2 #effective reactance of the thyristor in ohms\n", + "Xt=round(Xt,2)\n", + "print 'effective reactance of the thyristor=Xt=',Xt,'ohms'\n", + "C=1-((Id*Xt)/(E2*sqrt(3))) #cosine value of the commutational angle\n", + "C=round(C,2)\n", + "print 'cosine value of the commutational angle=C=',C\n", + "CA=math.acos(C)*180/pi\n", + "CA=round(CA,2)\n", + "print 'commutation angle=CA=',CA,'degrees'\n", + "F=Edc/(1.35*E2*(1+C)/2) #cosine value of the firing angle\n", + "F=round(F,2)\n", + "print 'cosine value of the firing value=F=',F\n", + "FA=math.acos(F)*180/pi\n", + "FA=round(FA,2)\n", + "print 'firing angle=FA=',FA,'degrees'\n", + "I2=0.817*Id #AC line current in amps\n", + "print 'AC line current=I2=',I2,'amps'\n", + "Ied=0.58*Id #current through each device in amps\n", + "print 'Current through each device=Ied=',Ied,'amps'\n", + "PF=F*(1+C)/2 #power factor\n", + "PF=round(PF,2)\n", + "print 'power factor=PF=',PF\n", + "AP=sqrt(3)*E2*I2*PF #active power drawn from the mains in Watts\n", + "AP=round(AP,2)\n", + "print 'active power drawn from the mains=AP=',AP,'Watts'\n", + "RP=sqrt(3)*E2*I2*sqrt(1-PF**2) #reactive power in VAR\n", + "RP=round(RP,2)\n", + "print 'Reactive power drawn=RP=',RP,'VAR'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example8.4,Pg.no.25" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AC line current of the thyristor=I2= 81.7 amperes\n", + "power factor=PF= 0.69\n", + "Reactive power to be supplied by shunt compensator=RP= 23557.8 VAR\n" + ] + } + ], + "source": [ + "from math import pi,sqrt\n", + "Id=100 #rated dc current in amperes\n", + "I2=0.817*Id #AC line current in amperes\n", + "I2=round(I2,2)\n", + "print 'AC line current of the thyristor=I2=',I2,'amperes'\n", + "E2=230 #AC line voltage in volts\n", + "Edc=200 #dc terminal voltage in volts\n", + "PF=math.cos(pi/4)*(1+math.cos(pi/10))/2 #power factor\n", + "PF=round(PF,2)\n", + "print 'power factor=PF=',PF\n", + "RP=sqrt(3)*E2*I2*sqrt(1-PF**2) #reactive power to be supplied by shunt compensator in VAR\n", + "RP=round(RP,2)\n", + "print 'Reactive power to be supplied by shunt compensator=RP=',RP,'VAR'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example8.5,Pg.no.25" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of MVAR rating of the capacitor=Pc= 7.68 MVAR\n", + "value of the capacitance of shunt filter=C = 606.41 microfarads\n", + "Inductance of filter=L= 0.01 milliHenry\n", + "Resistance of filter=R= 0.99 milliOhms\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "I11=400/11 #amplitude of 11th harmonic current in Amperes\n", + "V1= 11/(sqrt(3)) #Input supply phase voltage in Kilo Volts\n", + "P=7 #supply power per phase of f i l t e r in MVAR/\n", + "Pc=P+((V1**2*I11**2*10**-3)/(11*P)) #AC Converter MVAR rating of the capacitor\n", + "Pc=round(Pc,2)\n", + "print 'value of MVAR rating of the capacitor=Pc=',Pc,'MVAR'\n", + "W=2*3.14*50\n", + "C=(Pc*10**6)/(V1**2*W) #capacitance of the ShuntFilter in microFarad\n", + "C=round(C,2)\n", + "print 'value of the capacitance of shunt filter=C =',C,'microfarads'\n", + "W11=11*W\n", + "L=10**8/(C*W11**2) #inductance of filter in mHenry\n", + "L=round(L,2)\n", + "print 'Inductance of filter=L=',L,'milliHenry'\n", + "Q=35 #value of Q\n", + "R=(W11*L)/Q #Resistance of filter in milliOhms\n", + "R=round(R,2)\n", + "print 'Resistance of filter=R=',R,'milliOhms'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example8.6,Pg.no.26" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For six pulse converter most effective harmonic is 6th and for worst case a=90 degree\n", + "voltage ripple=Wv= 24.1 percent\n", + "Harmonic current for 6th harmonic=I6= 9.81 amp\n", + "max. value of current ripple=Wi= 3.27 percent\n" + ] + } + ], + "source": [ + "import math\n", + "print 'For six pulse converter most effective harmonic is 6th and for worst case a=90 degree'\n", + "h=6.0\n", + "Wv=24.1 #voltage ripple in percentage\n", + "print 'voltage ripple=Wv=',Wv,'percent'\n", + "Edc=460.0 #dc voltage in volts\n", + "W=2*3.14*50\n", + "Ldc=6.0 #total dc circuit inductance in milliHenry\n", + "I6=Wv*Edc*10/(Ldc*h*W) #Harmonic current for 6th harmonic in amp\n", + "I6=round(I6,2)\n", + "print 'Harmonic current for 6th harmonic=I6=',I6,'amp'\n", + "Id=300.0\n", + "Wi=100*I6/Id #maximum value of current ripple in percentage\n", + "Wi=round(Wi,2)\n", + "print 'max. value of current ripple=Wi=',Wi,'percent'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example8.7,Pg.no.27" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "voltage ripple of the 6th harmonic=Wv= 17.38 percent\n", + "For six pulse converter most effective harmonic is 6th and for worst case A=90degrees\n", + "maximum voltage ripple=Wv6= 24.24 percent\n", + "voltage ripple of the 12th harmonic=Wv= 8.42 percent\n", + "maximum voltage ripple=Wv12= 11.87 percent\n", + "percentage reduction in max. voltage ripple=PR= 51.03 percent\n" + ] + } + ], + "source": [ + "from math import pi,sqrt\n", + "#given\n", + "A=pi/4\n", + "h=6\n", + "#calculations\n", + "Wv=sqrt(2)*sqrt(h**2-math.cos(A)**2*(h**2-1))*100/(h**2-1)\n", + "Wv=round(Wv,2)\n", + "print 'voltage ripple of the 6th harmonic=Wv=',Wv,'percent'\n", + "print 'For six pulse converter most effective harmonic is 6th and for worst case A=90degrees'\n", + "A=pi/2\n", + "Wv6=sqrt(2)*sqrt(h**2-math.cos(A)**2*(h**2-1))*100/(h**2-1) #maximum voltage ripple in percentage\n", + "Wv6=round(Wv6,2)\n", + "print 'maximum voltage ripple=Wv6=',Wv6,'percent'\n", + "A=pi/4\n", + "h=12\n", + "Wv=sqrt(2)*sqrt(h**2-math.cos(A)**2*(h**2-1))*100/(h**2-1)\n", + "Wv=round(Wv,2)\n", + "print 'voltage ripple of the 12th harmonic=Wv=',Wv,'percent'\n", + "A=pi/2\n", + "Wv12=sqrt(2)*sqrt(h**2-math.cos(A)**2*(h**2-1))*100/(h**2-1) #maximum voltage ripple in percentage\n", + "Wv12=round(Wv12,2)\n", + "print 'maximum voltage ripple=Wv12=',Wv12,'percent'\n", + "PR=(Wv6-Wv12)*100/Wv6 #percentage reduction in max. voltage ripple\n", + "PR=round(PR,2)\n", + "print 'percentage reduction in max. voltage ripple=PR=',PR,'percent'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example8.8,Pg.no.28" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cosine of triggering angle=C= 0.65\n", + "triggering angle of the device=A= 49.46 degrees\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "#givem\n", + "Wv=18.6\n", + "h=6 \n", + "#calculations\n", + "C=sqrt(14.68/35) #cosine of triggering angle\n", + "C=round(C,2)\n", + "print 'cosine of triggering angle=C=',C\n", + "A=math.acos(C)*180/pi\n", + "A=round(A,2)\n", + "print 'triggering angle of the device=A=',A,'degrees'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example8.9,Pg.no.29" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cosine of the triggering angle=C= 0.75\n", + "triggering angle of the device=A= 41.41 degrees\n", + "power factor=PF= 0.74\n", + "Reactive power to be supplied by shuntcompensator=RP= 79.0 KVAR\n" + ] + } + ], + "source": [ + "from math import pi,sqrt\n", + "E2=415 #AC line voltage in volts\n", + "Edc=380 #dc terminal voltage in volts\n", + "C=1.1*Edc/(1.35*E2)\n", + "C=round(C,2)\n", + "print 'cosine of the triggering angle=C=',C\n", + "A=math.acos(C)*180/pi\n", + "A=round(A,2)\n", + "print 'triggering angle of the device=A=',A,'degrees'\n", + "PF=C*(1+math.cos(pi/12))/2 #power factor\n", + "PF=round(PF,2)\n", + "print 'power factor=PF=',PF\n", + "Id=200\n", + "I2=0.817*Id\n", + "RP=sqrt(3)*E2*I2*sqrt(1-PF**2)/1000 #reactive power to be supplied by shunt compensator in KVAR\n", + "RP=round(RP,2)\n", + "print 'Reactive power to be supplied by shuntcompensator=RP=',RP,'KVAR'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter_2_The_Device__1.ipynb b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter_2_The_Device__1.ipynb new file mode 100644 index 00000000..4d4e44fe --- /dev/null +++ b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/Chapter_2_The_Device__1.ipynb @@ -0,0 +1,250 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 2 The Device" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.1,Page number 7" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of voltage safety factor= 2.56\n" + ] + } + ], + "source": [ + "from math import pi,sqrt\n", + "import math \n", + "Vpiv=1500 # peak inverse voltage\n", + "V=415 # main supply\n", + "Vf=Vpiv/(sqrt(2)*V) # voltage safety factor\n", + "Vf=round(Vf,2)\n", + "print 'value of voltage safety factor=',Vf" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.2,Page number 7" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of peak inverse voltage= 683.07 volts\n" + ] + } + ], + "source": [ + "from math import pi,sqrt\n", + "import math \n", + "Vf=2.1 # voltage safety factor \n", + "V=230 # main supply\n", + "Vpiv=sqrt(2)*Vf*V # peak inverse voltage\n", + "Vpiv=round(Vpiv,2)\n", + "print 'value of peak inverse voltage=',Vpiv,'volts'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.3,Page number 8" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of capacitive current= 0.0045 Amp\n" + ] + } + ], + "source": [ + "import math \n", + "C=30*10**-12 # equivalent capacitance \n", + "diffV=150*10**6 # dv/dt value of capacitor\n", + "Ic=C*(diffV) # capacitive current\n", + "print 'value of capacitive current=',Ic,'Amp'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.4,Page number 8" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of equivalent capacitance= 28.57 pico farad\n" + ] + } + ], + "source": [ + "import math \n", + "Ic=5.0 # capacitive current in milli amperes\n", + "difV=175.0 # dv/dt value in mega V/s\n", + "C=Ic/(difV)*10**3 # equivalent capacitance in pico farad\n", + "C=round(C,2)\n", + "print 'value of equivalent capacitance=',C,'pico farad'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.5,Page number 8" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of dv/dt= 240.0 Mv/s\n" + ] + } + ], + "source": [ + "import math \n", + "Ic=6*10**-3 # capacitive current\n", + "C=25*10**-12 # equivalent capacitance\n", + "diffV=Ic/C # dv/dt value of capacitor\n", + "diffV=diffV/10**6\n", + "print 'value of dv/dt=',diffV,'Mv/s'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.6,Page number 9" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of dv/dt that can trigger the device= 142 V/microseconds\n" + ] + } + ], + "source": [ + "import math \n", + "Ic=5 # capacitive current in milli amperes\n", + "C=35 # equivalent capacitance in pico farad\n", + "difV=Ic*10**3/C # value of dv/dt that can trigger the device in V/ microseconds\n", + "print 'value of dv/dt that can trigger the device=',difV,'V/microseconds'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.7,Page number 9" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of voltage safety factor= 2.3 v\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "import math \n", + "Vpiv=1350 # peak inverse voltage in volts\n", + "V=415 # main supply in volts\n", + "Vf=Vpiv/(sqrt(2)*V) # voltage safety factor\n", + "Vf=round(Vf,2)\n", + "print 'value of voltage safety factor=',Vf,'v'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/screenshots/11.JPG b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/screenshots/11.JPG Binary files differnew file mode 100644 index 00000000..6fe03ba9 --- /dev/null +++ b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/screenshots/11.JPG diff --git a/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/screenshots/15.JPG b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/screenshots/15.JPG Binary files differnew file mode 100644 index 00000000..fdeacb17 --- /dev/null +++ b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/screenshots/15.JPG diff --git a/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/screenshots/8.JPG b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/screenshots/8.JPG Binary files differnew file mode 100644 index 00000000..ff9aee58 --- /dev/null +++ b/Thyristors_Theory_And_Applications_by_R._K._Sugandhi_And_K._K._Sugandhi/screenshots/8.JPG |
