Added(A)/Deleted(D) following books

 A  A_TEXTBOOK_OF_ELECTRICAL_TECHNOLOGY_(VOL-III)_by_B.L.Thareja/chapter40.ipynb
A  A_TEXTBOOK_OF_ELECTRICAL_TECHNOLOGY_(VOL-III)_by_B.L.Thareja/chapter41.ipynb
A  A_TEXTBOOK_OF_ELECTRICAL_TECHNOLOGY_(VOL-III)_by_B.L.Thareja/chapter43.ipynb
A  A_TEXTBOOK_OF_ELECTRICAL_TECHNOLOGY_(VOL-III)_by_B.L.Thareja/chapter44.ipynb
A  A_TEXTBOOK_OF_ELECTRICAL_TECHNOLOGY_(VOL-III)_by_B.L.Thareja/chapter45.ipynb
A  A_TEXTBOOK_OF_ELECTRICAL_TECHNOLOGY_(VOL-III)_by_B.L.Thareja/chapter46.ipynb
A  A_TEXTBOOK_OF_ELECTRICAL_TECHNOLOGY_(VOL-III)_by_B.L.Thareja/chapter47.ipynb
A  A_TEXTBOOK_OF_ELECTRICAL_TECHNOLOGY_(VOL-III)_by_B.L.Thareja/chapter49.ipynb
A  A_TEXTBOOK_OF_ELECTRICAL_TECHNOLOGY_(VOL-III)_by_B.L.Thareja/chapter50.ipynb
A  A_TEXTBOOK_OF_ELECTRICAL_TECHNOLOGY_(VOL-III)_by_B.L.Thareja/screenshots/figure_1.png
A  A_TEXTBOOK_OF_ELECTRICAL_TECHNOLOGY_(VOL-III)_by_B.L.Thareja/screenshots/figure_2.png
A  A_TEXTBOOK_OF_ELECTRICAL_TECHNOLOGY_(VOL-III)_by_B.L.Thareja/screenshots/figure_3.png

1 files changed, 1281 insertions, 0 deletions

diff --git a/A_TEXTBOOK_OF_ELECTRICAL_TECHNOLOGY_(VOL-III)_by_B.L.Thareja/chapter45.ipynb b/A_TEXTBOOK_OF_ELECTRICAL_TECHNOLOGY_(VOL-III)_by_B.L.Thareja/chapter45.ipynb
new file mode 100644
index 00000000..6a963318
--- /dev/null
+++ b/A_TEXTBOOK_OF_ELECTRICAL_TECHNOLOGY_(VOL-III)_by_B.L.Thareja/chapter45.ipynb
@@ -0,0 +1,1281 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# CHAPTER 45 : RATING AND SERVICE CAPACITY"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.1 , PAGE NO :- 1796"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Size of motor = 66.0 KW.\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''An electric motor operates at full-load of 100KW for 10 minutes,at 3/4 full load for the next 10 minutes and at 1/2 load for\n",
+    "next 20 minutes,no-load for the next 20 minutes and this cycle repeats continously.Find the continous rating of the suitable \n",
+    "motor.'''\n",
+    "\n",
+    "import math as m\n",
+    "#Loads\n",
+    "l1 = 100.0        #kW        (load 1)\n",
+    "l2 = 0.75*l1      #kW        (load 2)\n",
+    "l3 = 0.5*l1       #kW        (load 3)\n",
+    "l4 = 0.0            #kW        (no-load)\n",
+    "\n",
+    "#coresponding time\n",
+    "t1 = 10.0         #minutes\n",
+    "t2 = 10.0         #minutes\n",
+    "t3 = 20.0         #minutes\n",
+    "t4 = 20.0         #minutes\n",
+    "\n",
+    "#size of motor required\n",
+    "size = m.sqrt((l1*l1*t1 + l2*l2*t2 + l3*l3*t3 + l4*l4*t4)/(t1+t2+t3+t4/3))     #kW\n",
+    "print \"Size of motor =\",round(size),\"KW.\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.2 , PAGE NO :- 1797"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Size of motor = 141.0 KW.\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''An electric motor has to be selected for a load which rises uniformly from zero to 200KW in 10 minutes after which it remains \n",
+    "constant at 200KW for the next 10 minutes,followed by a no-load period of 15 minutes before the cycle repeats itself.Estimate a \n",
+    "suitable size of continuosly rated motor.'''\n",
+    "\n",
+    "import math as m\n",
+    "#Loads\n",
+    "l1 = 200.0/2        #kW        (load 1)\n",
+    "l2 = 200.0          #kW        (load 2)\n",
+    "l3 = 0.0            #kW        (no-load)\n",
+    "\n",
+    "#coresponding time\n",
+    "t1 = 10.0         #minutes\n",
+    "t2 = 10.0         #minutes\n",
+    "t3 = 15.0         #minutes\n",
+    "\n",
+    "\n",
+    "#size of motor required\n",
+    "size = m.sqrt((l1*l1*t1 + l2*l2*t2 + l3*l3*t3)/(t1+t2+t3/3))     #kW\n",
+    "print \"Size of motor =\",round(size),\"KW.\"\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.3 , PAGE NO :- 1797 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Size of motor =  70.0 KW.\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''A certain motor has to perform the following duty cycle:\n",
+    "(a) 100KW for 10 minutes               (No-load for 5 minutes)\n",
+    "(b) 50KW for 8 minutes                 (No-load for 4 minutes)\n",
+    "The duty cycle is repeated indefinitely.Draw the curve for the load cycle.Assuming that the heating is propotional to the square of\n",
+    "the load,determine suitable size of a continuosly-rated motor.'''\n",
+    "\n",
+    "import math as m\n",
+    "\n",
+    "#Loads\n",
+    "l1 = 100.0      #KW      (load 1)\n",
+    "l3 = 50.0       #KW      (load 2)\n",
+    "\n",
+    "#Time\n",
+    "t1 = 10.0       #minutes\n",
+    "t2 = 5.0        #minutes\n",
+    "t3 = 8.0        #minutes\n",
+    "t4 = 4.0        #minutes\n",
+    "\n",
+    "#Size of the motor is\n",
+    "size = m.sqrt((l1*l1*t1 + l3*l3*t3)/(t1+t2+t3+t4))      #KW\n",
+    "print \"Size of motor = \",round(size,-1),\"KW.\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.4 , PAGE NO :- 1799"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Size of motor =  69.07 H.P.\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''A motor has to perform the following duty cycle :-\n",
+    "(i) 100 H.P (10 mins)            (ii) No Load (5 mins)\n",
+    "(iii)60 H.P (8 mins)             (iv) No Load (4 mins)\n",
+    "which is repeated infinitely.Determine the suitable size of continuosly rated motor.'''\n",
+    "\n",
+    "import math as m\n",
+    "\n",
+    "#Loads\n",
+    "l1 = 100.0      #H.P      (load 1)\n",
+    "l3 = 60.0       #H.P     (load 2)\n",
+    "\n",
+    "#Time\n",
+    "t1 = 10.0       #minutes\n",
+    "t2 = 5.0        #minutes\n",
+    "t3 = 8.0        #minutes\n",
+    "t4 = 4.0        #minutes\n",
+    "\n",
+    "#Size of the motor is\n",
+    "size = m.sqrt((l1*l1*t1 + l3*l3*t3)/(t1+t2+t3+t4))      #H.P\n",
+    "print \"Size of motor = \",round(size,2),\"H.P.\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.5 , PAGE nO :- 1800"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Size of motor = 48.11 H.P .\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''A motor working in a coal mine has to exert power starting from zero and rising uniformly to 100 H.P in 5 min\n",
+    "after which it works at a constant rate of 50 H.P for 10 min.Then, a no load period of 3 min.The cycle is repeated\n",
+    "indefinitely,estimate suitable size of motor.'''\n",
+    "\n",
+    "import math as m\n",
+    "\n",
+    "#Load\n",
+    "l1 = 100.0     #H.P    (load 1)\n",
+    "l2 = 50.0      #H.P    (load 2)\n",
+    "l3 = 0.0       #H.P    (no-load)\n",
+    "\n",
+    "#Time\n",
+    "t1 = 5.0          #min    (time 1) \n",
+    "t2 = 10.0         #min    (time 2)\n",
+    "t3 = 3.0          #min    (time 3)\n",
+    "\n",
+    "#Using Simpson's one-third rule of Integration\n",
+    "rating = m.sqrt((1.0/3*l1*l1*t1 + l2*l2*t2)/(t1 + t2 + t3) )     #H.P\n",
+    "\n",
+    "print \"Size of motor =\",round(rating,2),\"H.P .\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.6 , PAGE NO :- 1800"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Size of motor =  263.19 H.P .\n",
+      "Therefore, suitable size of motor is 300.0 H.P\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''A motor has following duty cycle\n",
+    "Load rising from 200 to 400 H.P              -              4 min.\n",
+    "Uniform load 300 H.P                         -              2 min.\n",
+    "Regenerative braking (50 H.P to 0)           -              1 min.\n",
+    "Idle                                         -              1 min.\n",
+    "Estimate suitable H.P rating of the motor that can be used.'''\n",
+    "\n",
+    "import math as m\n",
+    "\n",
+    "#Loads\n",
+    "l1 = 200.0       #H.P      (load 1)\n",
+    "l2 = 400.0       #H.P      (load 2)\n",
+    "l3 = 300.0       #H.P      (load 3)\n",
+    "l4 = 50.0        #H.P      (load 4)\n",
+    "\n",
+    "#Time\n",
+    "t1 = 4.0        #min       (time 1)\n",
+    "t2 = 2.0        #min       (time 2)\n",
+    "t3 = 1.0        #min       (time 3)\n",
+    "t4 = 1.0        #min       (idle time)\n",
+    "\n",
+    "rating = m.sqrt((1.0/3*(l1*l1 + l1*l2 + l2*l2)*t1 + l3*l3*t2 + 1.0/3*l4*l4*t3)/(t1 + t2 + t3 + t4))   #H.P\n",
+    "\n",
+    "print \"Size of motor = \",round(rating,2),\"H.P .\"\n",
+    "print \"Therefore, suitable size of motor is\",round(rating,-2),\"H.P\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.7 , PAGE NO :- 1802"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Suitable motor size = 30.0 H.P .\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''The load cycle of a motor for 15 min in driving some equipment is as follows :\n",
+    "0 - 5 min     -     30 H.P\n",
+    "5 - 9 min     -     No load\n",
+    "9 - 12 min    -     45 H.P\n",
+    "12 - 15 min   -     No load\n",
+    "The load cycle is repeated indefinitely.Suggest a suitable size of continuosly rated motor.'''\n",
+    "\n",
+    "import math as m\n",
+    "\n",
+    "#Loads\n",
+    "l1 = 30.0       #H.P\n",
+    "l3 = 45.0       #H.P\n",
+    "\n",
+    "#Time\n",
+    "t1 = 5.0        #min\n",
+    "t2 = 4.0        #min\n",
+    "t3 = 3.0        #min\n",
+    "t4 = 3.0        #min\n",
+    "\n",
+    "#Size of motor is\n",
+    "Size = m.sqrt((l1*l1*t1 + l3*l3*t3)/(t1+t2+t3+t4))     #H.P\n",
+    "print \"Suitable motor size =\",round(Size,-1),\"H.P .\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.8 , PAGE NO :- 1802"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Size of continously rated motor =  505.0 H.P .\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''A motor driving a colliery winder has the following acceleration period :\n",
+    "  load cycle 0-15 sec    :   Load rises uniformly from 0-1000 H.P .\n",
+    "  Full speed period      :   15-85 sec. Load constant at 600 H.P .\n",
+    "  Decceleration period   :   85-95 sec. Regenerative braking the H.P returned uniformly from 200 to 0 H.P.\n",
+    "  95 - 120 sec           :   Motor stationary.\n",
+    "Estimate the size of continuosly rated motor.'''\n",
+    "\n",
+    "import math as m\n",
+    "\n",
+    "#Loads\n",
+    "l1 = 1000.0        #H.P         (load 1)\n",
+    "l2 = 600.0         #H.P         (load 2)\n",
+    "l3 = 200.0         #H.P         (load 3)\n",
+    "\n",
+    "#Time\n",
+    "t1 = 15.0            #s\n",
+    "t2 = 70.0            #s\n",
+    "t3 = 10.0            #s\n",
+    "t4 = 25.0            #s\n",
+    "\n",
+    "#Size of motor is\n",
+    "\n",
+    "size = m.sqrt((l1*l1*t1/3 + l2*l2*t2 + l3*l3*t3/3)/(t1+t2+t3+t4))      #H.P\n",
+    "\n",
+    "while(round(size)%5!=0):\n",
+    "    size = size + 1\n",
+    "    \n",
+    "print \"Size of continously rated motor = \",round(size),\"H.P .\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.9 , PAGE NO :- 1807"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 1/2 hour rating =  75.13 KW.\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''A 40KW motor when run continuosly on full load,attains a temperature of 35C , above the surrounding air.Its heating time \n",
+    "constant is 90 min.What would be the 1/2 hour rating of the motor for this temperature rise?Assume that the machine cools down \n",
+    "completely between each load period and that the losses are propotional to square of the load.'''\n",
+    "\n",
+    "\n",
+    "from sympy import Symbol,Eq,solve\n",
+    "import math as m\n",
+    "# Let 'P' KW be 1/2 hour rating of the motor\n",
+    "# theta1 - final temp rise at P KW\n",
+    "# theta2 - final temp rise at 40 KW\n",
+    "#Losses at P KW is directlt propotional to P^2\n",
+    "\n",
+    "theta2 = 35.0      # *C\n",
+    "tau =  1.5         #hr        (time constant)\n",
+    "t = 0.5            #hr        (motor running time)\n",
+    "\n",
+    "#Now,  (theta1/theta2) = loss at P KW/loss at 40KW = (P/40)^2\n",
+    "P = Symbol('P')\n",
+    "theta1 = theta2*(P/40)*(P/40)            #*C\n",
+    "\n",
+    "#Now, theta2 = theta1*(1 - exp(-t/tau))\n",
+    "\n",
+    "theta2a =  theta1*(1-m.exp(-t/tau))      #*C\n",
+    "eq = Eq(theta2,theta2a)\n",
+    "P = solve(eq)\n",
+    "P1 = P[1]                #KW\n",
+    "\n",
+    "print \"1/2 hour rating = \",round(P1,2),\"KW.\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.10 , PAGE NO :- 1807"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1 hour rating =  24.0 H.P.\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''Determine the one-hour rating of a 15 H.P motor having heating time contant of 2 hours.The motor attains the temperature of\n",
+    "40*C on continuos run at full load.Assume that the losses are propotional to square of the load and the motor is allowed to cool\n",
+    "down to the ambient temperature before being loaded again.'''\n",
+    "\n",
+    "from sympy import Symbol,Eq,solve\n",
+    "import math as m\n",
+    "# Let 'P' H.P be 1 hour rating of the motor\n",
+    "# theta2 - final temp rise at P H.P\n",
+    "# theta1 - final temp rise at 15 H.P\n",
+    "#Losses at P H.P is directlt propotional to P^2\n",
+    "\n",
+    "theta1 = 40.0      # *C\n",
+    "tau =  2.0         #hr        (time constant)\n",
+    "t = 1.0            #hr        (motor running time)\n",
+    "\n",
+    "#Now,  (theta2/theta1) = loss at P H.P/loss at 15 H.P = (P/15)^2\n",
+    "P = Symbol('P')\n",
+    "theta2 = theta1*(P/15)*(P/15)            #*C\n",
+    "\n",
+    "#Now, theta1 = theta2*(1 - exp(-t/tau))\n",
+    "\n",
+    "theta1a =  theta2*(1-m.exp(-t/tau))      #*C\n",
+    "eq = Eq(theta1,theta1a)\n",
+    "P = solve(eq)\n",
+    "P1 = P[1]                #H.P\n",
+    "\n",
+    "print \"1 hour rating = \",round(P1),\"H.P.\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.11 , PAGE NO :- 1808"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Temperature rise of motor =  35.6 *C .\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''The heating and cooling time constants of a motor are 1 hour and 2 hours respectively.Final temperature rise attained is \n",
+    "100*C.This motor runs at full load for 30 minutes and then kept idle for 12 min and the cycle is repeated indefinitely.Determine \n",
+    "the temperature rise of motor after one cycle.'''\n",
+    "\n",
+    "import math as m\n",
+    "\n",
+    "theta2 = 100.0         #*C    (Final temperature rise)\n",
+    "tau_h = 1.0            #hr    (heating time constant)\n",
+    "tau_c = 2.0            #hr    (cooling time constant)\n",
+    "t1 = 30.0/60           #hr    (motor running time)\n",
+    "t2 = 12.0/60           #hr    (motor idle time)\n",
+    "\n",
+    "#Heating cycle\n",
+    "theta1 = theta2*(1 - m.exp(-t1/tau_h))\n",
+    "\n",
+    "#Cooling cycle\n",
+    "thetac = theta1*m.exp(-t2/tau_c)\n",
+    "\n",
+    "print \"Temperature rise of motor = \",round(thetac,2),\"*C .\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.12 , PAGE NO :- 1808"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Maximum overload that can be carried by motor =  25.82 KW.\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''Calculate the maximum overload that can be carried by a 20KW output motor,if the temperature rise is not to exceed 50*C after\n",
+    "one hour on overload .The temperature rise on full load,after 1 hour is 30*C and after 2 hour is 40*C . Assume losses propotional\n",
+    "to square of load.'''\n",
+    "\n",
+    "from sympy import solve,Symbol,Eq\n",
+    "import math as m\n",
+    "\n",
+    "# As theta = thetaf*(1 - exp(-t/T))\n",
+    "\n",
+    "theta1 = 30.0      #*C        (temperature rise in time1)\n",
+    "t1 = 1              #hr        (time 1)\n",
+    "theta2 = 40.0      #*C        (temperature rise in time2)\n",
+    "t2 = 2              #hr        (time 2)\n",
+    "#Now   theta1/theta2 = (1-exp(-t1/T))/(1-exp(-t2/T))\n",
+    "#Let us assume that x = exp(-1/T).Therefore\n",
+    "x = Symbol('x')\n",
+    "ratio1 = (1 - x**t1)/(1-x**t2)       #(theta1/theta2)\n",
+    "ratio2 = theta1/theta2\n",
+    "\n",
+    "#As ratio1 = ratio2\n",
+    "eq = Eq(ratio1,ratio2)\n",
+    "x1 = solve(eq)\n",
+    "x = x1[0]             #variable \n",
+    "\n",
+    "#x = exp(-1/T) . Therefore,\n",
+    "T = -1/m.log(x)\n",
+    "\n",
+    "#Now, theta1 = thetaf1*(1 - exp(-t1/T))\n",
+    "\n",
+    "thetaf1 = theta1/(1-x**t1)           #*C\n",
+    "\n",
+    "#Also theta3 = thetaf3*(1 - exp(-t3/T))\n",
+    "theta3 = 50.0        #*C         (max temp)\n",
+    "t3 = 1               #hr         (time 3) \n",
+    "thetaf3 = theta3/(1-x**t3)            #*C\n",
+    "\n",
+    "#Given that temp is directly propotional to square of power output i.e   thetaf1/thetaf3 = (Power1/Power3)^2\n",
+    "P1 = 20.0    #KW\n",
+    "P3 = m.sqrt(thetaf3/thetaf1)*P1         #KW\n",
+    "\n",
+    "print \"Maximum overload that can be carried by motor = \",round(P3,2),\"KW.\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.13 , PAGE NO :- 1809"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Final steady temperature rise = 50.0 *C.\n",
+      "Cooling time constant = 0.93 hr\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''In a transformer the temperature rise is 25*C after 1 hour and 37.5*C after 2 hours,starting from cold conditions.Calculate \n",
+    "its final steady temperature rise and the heating time constant.If the transformer temerature falls from the final steady state\n",
+    "value to 40*C in 1.5 hours when disconnected,calculate its cooling time constant.Ambient temperature is 30*C.'''\n",
+    "\n",
+    "from sympy import solve,Symbol,Eq\n",
+    "import math as m\n",
+    "\n",
+    "# As theta = thetaf*(1 - exp(-t/T))\n",
+    "\n",
+    "theta1 = 25.0      #*C        (temperature rise in time1)\n",
+    "t1 = 1              #hr        (time 1)\n",
+    "theta2 = 37.5      #*C        (temperature rise in time2)\n",
+    "t2 = 2              #hr        (time 2)\n",
+    "#Now   theta1/theta2 = (1-exp(-t1/T))/(1-exp(-t2/T))\n",
+    "#Let us assume that x = exp(-1/T).Therefore\n",
+    "x = Symbol('x')\n",
+    "ratio1 = (1 - x**t1)/(1-x**t2)       #(theta1/theta2)\n",
+    "ratio2 = theta1/theta2\n",
+    "\n",
+    "#As ratio1 = ratio2\n",
+    "eq = Eq(ratio1,ratio2)\n",
+    "x1 = solve(eq)\n",
+    "x = x1[0]             #variable \n",
+    "\n",
+    "#x = exp(-1/T) . Therefore,\n",
+    "T = -1/m.log(x)\n",
+    "\n",
+    "#As  theta1 = thetaf1*(1 - exp(-t1/T))\n",
+    "thetaf1 = theta1/(1-x**t1)              #*C\n",
+    "print \"Final steady temperature rise =\",round(thetaf1,2),\"*C.\"\n",
+    "\n",
+    "#Cooling conditions\n",
+    "theta_rise = 40.0 - 30.0           #*C      (temp rise above ambient conditions)\n",
+    "t3 = 1.5                     #hr      (time taken)\n",
+    "\n",
+    "#Now,  theta_rise = thetaf1*exp(-t3/T)\n",
+    "T = -t3/m.log(theta_rise/thetaf1)             #hr\n",
+    "print \"Cooling time constant =\",round(T,2),\"hr\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.14 , PAGE NO :- 1809"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Temperature of machine = 70.58 *C.\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''The initial temperature of machine is 20*C.Calculate the temperature of machine after 1.2 hours,if its final steady \n",
+    "temperature rise is 85*C and the heating time constant is 2.4 hours.Ambient temperature is 25*C.''' \n",
+    "\n",
+    "import math as m\n",
+    "thetaf = 85.0         #*C      (final temp. rise)\n",
+    "theta1 = 20.0         #*C      (initial temp)\n",
+    "t1 = 1.2              #hr      (time taken)\n",
+    "T = 2.4               #hr      (heat time constant)\n",
+    "#Now, Temperature rise above coling medium is\n",
+    "theta = thetaf - (thetaf - theta1)*m.exp(-t1/T)    #*C\n",
+    "\n",
+    "#Therefore, temp. of machine after t1 time is\n",
+    "temp = theta + 25.0\n",
+    "\n",
+    "print \"Temperature of machine =\",round(temp,2),\"*C.\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.15 , PAGE NO :- 1809"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Final steady temperature rise = 45.0 *C .\n",
+      "Time constant = 2.47 hr.\n",
+      "The steady temperature rise = 30.0 *C .\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''The following rises were observed in a teperature rise test on a D.C machine at full loads. :-\n",
+    "After  1 hour  -     15*C\n",
+    "After  2 hours -     25*C\n",
+    "Find out    (i) Final steady temperature rise and time constant.\n",
+    "            (ii)The steady temperature rise after 1 hour at 50% overload,from cold.\n",
+    "Assume that the final temperature rise on 50% overload is 90*C.'''\n",
+    "\n",
+    "\n",
+    "from sympy import solve,Symbol,Eq\n",
+    "import math as m\n",
+    "\n",
+    "# As theta = thetaf*(1 - exp(-t/T))\n",
+    "\n",
+    "theta1 = 15.0      #*C        (temperature rise in time1)\n",
+    "t1 = 1              #hr        (time 1)\n",
+    "theta2 = 25.0      #*C        (temperature rise in time2)\n",
+    "t2 = 2              #hr        (time 2)\n",
+    "#Now   theta1/theta2 = (1-exp(-t1/T))/(1-exp(-t2/T))\n",
+    "#Let us assume that x = exp(-1/T).Therefore\n",
+    "x = Symbol('x')\n",
+    "ratio1 = (1 - x**t1)/(1-x**t2)       #(theta1/theta2)\n",
+    "ratio2 = theta1/theta2\n",
+    "\n",
+    "#As ratio1 = ratio2\n",
+    "eq = Eq(ratio1,ratio2)\n",
+    "x1 = solve(eq)\n",
+    "x = x1[0]             #variable \n",
+    "\n",
+    "#x = exp(-1/T) . Therefore,\n",
+    "T = -1/m.log(x)                     #hr     (time constant)\n",
+    "\n",
+    "#As  theta1 = thetaf1*(1 - exp(-t/T))\n",
+    "thetaf1 = theta1/(1-x**t1)          #*C     (Final steady temp. rise)\n",
+    "print \"Final steady temperature rise =\",round(thetaf1,2),\"*C .\"\n",
+    "print \"Time constant =\",round(T,2),\"hr.\"\n",
+    "\n",
+    "#(ii) Now at 50% overload .Final temp rise is\n",
+    "thetaf3 = 90.0              #*C\n",
+    "t3 = 1                      #hr     (time taken)\n",
+    "#As ,  theta = thetaf*(1 - exp(-t/T))\n",
+    "theta3 = thetaf3*(1 - m.exp(-t3/T))            #*C\n",
+    "\n",
+    "print \"The steady temperature rise =\",round(theta3,2),\"*C .\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.16 , PAGE NO :- 1813"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Moment of Inertia = 2.947543e+06 kg-m^2\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''The following data refers to a 500 H.P rolling mill,induction motor equipped with a flywheel.\n",
+    "               No load speed                      ->   40 rpm\n",
+    "               Slip at full load(torque)          ->   12%\n",
+    "               Load torque during actual rolling  ->  41500 kg-m\n",
+    "               Duration of each rolling period    ->   10 sec.\n",
+    "Determine inertia of flywheel required in the above case to limit motor torque to twice its full load value.Neglect no-load \n",
+    "losses and assume that the rolling mill torque falls to zero between each rolling period.Assume motor slip propotional to\n",
+    "full load torque.'''\n",
+    "\n",
+    "\n",
+    "import math as m\n",
+    "N = 40.0                    #rpm           (No load speed)\n",
+    "P = 500.0*(735.5)           #W             (Power)\n",
+    "w = 2*(3.14)*N/60           #rad/sec       (angular speed)\n",
+    "T0 = 0                      #kg-m          (initial torque)\n",
+    "Tl = 41500.0                #kg-m          (Torque load)  \n",
+    "t = 10.0                    #sec           (time taken)\n",
+    "s = 0.12                    #              (slip)\n",
+    "g = 9.81                    #m/s^2 \n",
+    "Tfull = P/(w*(1-s))         #N-m           (full load torque)\n",
+    "Tfull = Tfull/g             #kg-m\n",
+    "Tm = 2*Tfull                #kg-m          (Max torque)\n",
+    "S = 2*3.14*(0.12*40)/60\n",
+    "#Now,   S = K*Tfl\n",
+    "K = S/Tfull                   #constant\n",
+    "#Also,  Tm = Tl - (Tl-T0)*exp(-tg/IK) .Therefore I is\n",
+    "I =(-t*g)/(K*m.log((Tl-Tm)/(Tl-T0)))       #kg-m^2\n",
+    "\n",
+    "print \"Moment of Inertia = %e kg-m^2\" %round(I,2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.17 , PAGE NO :- 1814  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tm =  47.84 kg-m.\n",
+      "Actual Speed = 942.59 rpm.\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''A 6 pole,50 Hz Induction Motor has a flywheel of 1200 kg-m^2 as moment of inertia.Load torque is 100 kg-m for 10 sec.No load\n",
+    "period is long enough for the flywheel,to regain its full speed.Motor has a slip of 6% at a torque of 50 kg-m.Calculate\n",
+    "(i)Maximum torque exerted by motor\n",
+    "(ii)Speed at the end of deacceleration period.'''\n",
+    "\n",
+    "import math as m\n",
+    "\n",
+    "Tl = 100.0      #kg-m          (load torque)\n",
+    "t = 10.0        #s             (time taken)\n",
+    "g = 9.81        #m/s^2         (gravitational acceleration)\n",
+    "I = 1200.0      #kg-m^2        (moment of inertia)\n",
+    "p = 6           #              (poles)\n",
+    "f = 50.0        #Hz            (frequency)\n",
+    "s = 0.06        #              (slip)\n",
+    "Tfull = 50.0    #kg-m          (full load torque)\n",
+    "Ns = 120*f/p\n",
+    "Nr = (1-s)*Ns\n",
+    "\n",
+    "#Now, S = K*T\n",
+    "S = 2*3.14*(Ns - Nr)/60    #rad/sec\n",
+    "K = S/Tfull         #constant\n",
+    "\n",
+    "#As Tm = Tl*(1-exp(-t*g/I*K))\n",
+    "Tm = Tl*(1 - m.exp(-t*g/(I*K)))      #kg-m\n",
+    "print \"Tm = \",round(Tm,2),\"kg-m.\"\n",
+    "\n",
+    "#(ii)Slip speed\n",
+    "S = K*Tm            #rad/sec      (slip speed)\n",
+    "S = S*(60/(2*3.14))   #rpm\n",
+    "N = Ns - S          #rpm           (actual speed)\n",
+    "print \"Actual Speed =\",round(N,2),\"rpm.\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.18 , PAGE NO :- 1815"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Speed 1 =  691.75 rpm.\n",
+      "Speed 2 =  731.62 rpm.\n",
+      "Speed 1 =  683.89 rpm.\n",
+      "Speed 2 =  731.0 rpm.\n",
+      "Speed 1 =  683.62 rpm.\n",
+      "Speed 2 =  730.98 rpm.\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''An Induction Motor equipped with a flywheel is driving a rolling mill which requires a load torque of 1900 N-m for 10 sec\n",
+    "followed by 250 N-m for 30 sec.This cycle being repeated indefinitely.The synchronus speed of motor is 750 rpm and it has slip of\n",
+    "10% when delivering 1400 N-m torque.The total Moment of Inertia of the flywheel and other rotating parts is 2100 kg-m^2.Draw the \n",
+    "curves showing the torque exerted by the motor and the speed for five complete cycles,assuming the initial torque is zero.'''\n",
+    "\n",
+    "import math as m\n",
+    "\n",
+    "Tl1 = 1900.0      #N-m         (load torque 1)\n",
+    "t1 = 10.0         #s           (time 1)\n",
+    "Tl2 = 280.0       #N-m         (load torque 2)\n",
+    "t2 = 30.0         #s           (time 2)\n",
+    "s = 0.1           #            (slip)\n",
+    "Ns = 750.0        #rpm         (synchronus speed)\n",
+    "I = 2100.0        #kg-m^2      (moment of inertia)\n",
+    "Tm = 1400.0       #N-m\n",
+    "S = Ns*s          #rpm         (slip speed)\n",
+    "S = S*(2*3.14/60) #rad/sec     \n",
+    "\n",
+    "K = S/Tm          #constant\n",
+    "T0 = 0            #N-m\n",
+    "#(i) During  First Cycle\n",
+    "Tm = Tl1 -(Tl1-T0)*m.exp(-t1/(I*K))       #N-m\n",
+    "s2 = K*Tm*(60/(2*3.14))    #rpm\n",
+    "Speed1 = Ns - s2   #rpm\n",
+    "print \"Speed 1 = \",round(Speed1,2),\"rpm.\"\n",
+    "\n",
+    "# Now, Tm = T0 + (Tm' - T0)*exp(-t/(I*K))\n",
+    "Tmb = Tm    #N-m\n",
+    "T0 = Tl2    #N-m         (No Load Torque)\n",
+    "\n",
+    "Tm = T0 + (Tmb - T0)*m.exp(-t2/(I*K))\n",
+    "S2 = K*Tm*(60/(2*3.14))    #rpm\n",
+    "Speed2 = Ns - S2     #rpm\n",
+    "print \"Speed 2 = \",round(Speed2,2),\"rpm.\"\n",
+    "#################################################################\n",
+    "\n",
+    "#(ii) During Second cycle\n",
+    "T0 = Tm\n",
+    "Tm2 = Tl1 -(Tl1-T0)*m.exp(-t1/(I*K))       #N-m\n",
+    "s2 = K*Tm2*(60/(2*3.14))    #rpm\n",
+    "Speed1 = Ns - s2   #rpm\n",
+    "print \"Speed 1 = \",round(Speed1,2),\"rpm.\"\n",
+    "\n",
+    "# Now, Tm = T0 + (Tm' - T0)*exp(-t/(I*K))\n",
+    "Tm2b = Tm2    #N-m\n",
+    "T0 = Tl2    #N-m         (No Load Torque)\n",
+    "\n",
+    "Tm = T0 + (Tm2b - T0)*m.exp(-t2/(I*K))\n",
+    "S2 = K*Tm*(60/(2*3.14))    #rpm\n",
+    "Speed2 = Ns - S2     #rpm\n",
+    "print \"Speed 2 = \",round(Speed2,2),\"rpm.\"\n",
+    "###################################################################\n",
+    "\n",
+    "#(iii) During Third cycle\n",
+    "T0 = Tm\n",
+    "Tm3 = Tl1 -(Tl1-T0)*m.exp(-t1/(I*K))       #N-m\n",
+    "s2 = K*Tm3*(60/(2*3.14))    #rpm\n",
+    "Speed1 = Ns - s2   #rpm\n",
+    "print \"Speed 1 = \",round(Speed1,2),\"rpm.\"\n",
+    "\n",
+    "# Now, Tm = T0 + (Tm' - T0)*exp(-t/(I*K))\n",
+    "Tm3b = Tm3    #N-m\n",
+    "T0 = Tl2    #N-m         (No Load Torque)\n",
+    "\n",
+    "Tm = T0 + (Tm3b - T0)*m.exp(-t2/(I*K))\n",
+    "S2 = K*Tm*(60/(2*3.14))    #rpm\n",
+    "Speed2 = Ns - S2     #rpm\n",
+    "print \"Speed 2 = \",round(Speed2,2),\"rpm.\"\n",
+    "####################################################################"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true
+   },
+   "source": [
+    "## EXAMPLE 45.19 , PAGE NO :- 1817"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Moment of inertia = 2860.94 kg-m^2.\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''A motor fitted with a flywheel supplies a load torque of 150 kg-m for 15 sec.During the no-load period,the flywheel regains \n",
+    "its original speed.The motor torque is required to be limited to 85 kg-m.Determine moment of inertia of flywheel.\n",
+    "The no-load speed of motor is 500 rpm and it has slip of 10% on full load.'''\n",
+    "\n",
+    "from sympy import Symbol,solve,Eq,exp\n",
+    "import math as m\n",
+    "\n",
+    "Tm = 85.0        #kg-m     (Max torque)\n",
+    "Tl = 150.0       #kg-m     (load torque with flywheel)\n",
+    "T0 = 0           #kg-m     (constant load torque)\n",
+    "t = 15.0         #s        (time)\n",
+    "N = 500.0        #rpm      (no load speed)\n",
+    "s = 0.1          #         (slip)\n",
+    "g = 9.82        #m/s^2      \n",
+    "# s = K*T\n",
+    "K = 2*(3.14)*N*s/(60*Tm)      #constant\n",
+    "\n",
+    "# As Tm = Tl*(1 - exp(-t*g/(I*K)))\n",
+    "\n",
+    "I =(-t*g)/(K*m.log(1 - Tm/Tl))      #kg-m^2           (Moment of inertia)\n",
+    "\n",
+    "print \"Moment of inertia =\",round(I,2),\"kg-m^2.\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.20 , PAGE NO :- 1817"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Moment of inertia of flywheel = 1908.86 kg-m^2.\n",
+      "Time taken after removal of additional load = 8.88 s.\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''A 3-phase ,50 KW,6 pole,960 rpm induction motor has a constant load torque of 300 N-m and at wide intervals additional \n",
+    "torque of 1500 N-m for 10 sec.Calculate\n",
+    "(a)The moment of inertia of the flywheel used for load equalization,if the motor torque is not to exceed twice the rated torque.\n",
+    "(b)Time taken after removal of additional load,before the motor torque becomes 700 N-m.'''\n",
+    "\n",
+    "from sympy import Symbol,Eq,solve\n",
+    "import math as m\n",
+    "\n",
+    "P = 50.0e+3      #W          (output power)\n",
+    "Nr = 960.0       #rpm        (rotational speed)\n",
+    "p = 6.0          #           (no. of poles)\n",
+    "t = 10.0         #s          (time)\n",
+    "T0 = 300.0       #N-m        (constant load torque)\n",
+    "Tl = T0 + 1500.0 #N-m        (total load torque)\n",
+    "f = 50.0         #Hz         (frequency)  \n",
+    "\n",
+    "#   Power = T*w (torque*ang_speed)\n",
+    "T = P/(2*3.14*Nr/60)     #N-m        (Full-load torque)\n",
+    "Tm = 2*T                 #N-m        (Max torque)\n",
+    "\n",
+    "Ns = 120*f/p      #rpm        (synchronus speed)\n",
+    "\n",
+    "#Slip speed\n",
+    "sl = Ns-Nr        #rpm\n",
+    "\n",
+    "#Now,  s = K*T\n",
+    "K = 2*3.14*sl/(60*T)      #constant\n",
+    "\n",
+    "#As Tm = Tl - (Tl - T0)*exp(-t/I*K)\n",
+    "\n",
+    "I = (-t)/(K*m.log((Tl - Tm)/(Tl - T0)))         #kg-m^2     (moment of inertia)\n",
+    "\n",
+    "print \"Moment of inertia of flywheel =\",round(I,2),\"kg-m^2.\"\n",
+    "\n",
+    "#(b) Tm2 = T0 + (Tm-T0)*exp(-t/I*K)\n",
+    "Tm2 = 700.0            #N-m                         (Max torque - case 2)\n",
+    "\n",
+    "t1= (-I*K)*m.log((Tm2 - T0)/(Tm - T0))         #s               (time after removal of load)\n",
+    "print \"Time taken after removal of additional load =\",round(t1,2),\"s.\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true
+   },
+   "source": [
+    "## EXAMPLE 45.21 , PAGE NO :- 1818"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Moment of Inertia = 551.35 kg-m^2.\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''A 3-phase,8 pole,50 cps.Induction Motor equipped with a flywheel supplies a constant load torque of 100 N-m and at wide \n",
+    "intervals an additional load torque of 300 N-m for 6 sec.The motor runs at 735 rpm at 100 N-m torque.Find moment of inertia of \n",
+    "the flywheel,if the motor torque is not to exceed 250 N-m.'''\n",
+    "\n",
+    "from sympy import Symbol,Eq,solve\n",
+    "import math as m\n",
+    "\n",
+    "T0 = 100.0           #N-m   (constant load torque)\n",
+    "Tl = T0 + 300.0      #N-m   (Total load torque)\n",
+    "f = 50.0             #Hz    (frequency)\n",
+    "P = 8.0              #      (poles)\n",
+    "Tm = 250.0           #N-m   (Max torque) \n",
+    "Ns = 120*f/P         #rpm   (Synchronus speed)\n",
+    "sl =  Ns - 735.0     #rpm   (Slip speed)\n",
+    "t = 6.0              #s     (time)\n",
+    "#Now, s = K*T0\n",
+    "K = 2*3.14*sl/(60*T0)    #constant\n",
+    "\n",
+    "#Also,   Tm = Tl - (Tl-T0)*exp(-t/I*K)\n",
+    "\n",
+    "I = -t/(K*m.log((Tl - Tm)/(Tl-T0)))           #kg-m^2       (moment of inertia)\n",
+    "\n",
+    "print \"Moment of Inertia =\",round(I,2),\"kg-m^2.\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.22 , PAGE NO :- 1818"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Maximum torque developed by motor =  615.35 N-m.\n",
+      "Speed at the end of deacceleration period = 938.47 rpm.\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''A 6 pole,50 Hz,3-phase wound rotor Induction Motor has a flywheel coupled to its shaft.The total moment of inertia is \n",
+    "1000kg-m^2.Load torque is 1000 N-m for 10 sec followed by a no-load period which is long enough for the motor to reach its \n",
+    "no-load speed.Motor has a slip of 5% at a torque of 500 N-m.Find\n",
+    "(a)Maximum torque developed by motor\n",
+    "(b)Speed at the end of deacceleration period.'''\n",
+    "\n",
+    "import math as m\n",
+    "\n",
+    "P = 6.0                #           (No of poles)\n",
+    "I = 1000.0             #kg-m^2     (Moment of Inertia)\n",
+    "Tl = 1000.0            #N-m        (Load torque with  flywheel)\n",
+    "t = 10.0               #s          (time)\n",
+    "s = 0.05               #           (slip)\n",
+    "Tfl = 500.0            #N-m           (full load Torque)\n",
+    "f = 50.0               #Hz         (frequency)\n",
+    "\n",
+    "Ns = 120*f/P           #rpm        (Synchronus speed)\n",
+    "\n",
+    "#Now, s = K*Tfl\n",
+    "K = 2*3.14*(Ns*s)/(60*Tfl)        #constant\n",
+    "\n",
+    "#K = 6.2e-3          #(considered value)                     \n",
+    "\n",
+    "#Also Tm = Tl*(1-exp(-t/I*K)\n",
+    "Tm = Tl*(1 - m.exp(-t/(I*K)))              #N-m\n",
+    "print \"Maximum torque developed by motor = \",round(Tm,2),\"N-m.\"\n",
+    "         \n",
+    "#(b)    s = K*Tfl  where s = 2*3.14*(Ns - N)/60\n",
+    "N = Ns - (60/(2*3.14))*K*Tm            #rpm\n",
+    "print \"Speed at the end of deacceleration period =\",round(N,2),\"rpm.\"   "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EXAMPLE 45.23 , PAGE NO :- 1819"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Moment of inertia of flywheel = 275.67 kg-m^2.\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''A motor fitted with a flywheel supplies a load torque of 1000 N-m for 2 seconds.During no load period,the flywheel regains its\n",
+    "original speed.The motor torque is to be limited to 500 N-m.Find moment of inertia of the flywheel.No load speed of the motor is \n",
+    "500 rpm and its full load slip is 10%.'''\n",
+    "\n",
+    "from  sympy import solve,Eq,Symbol\n",
+    "import math as m\n",
+    "N = 500.0             #rpm       (No load speed)\n",
+    "s = 0.1               #          (slip)\n",
+    "Tfl = 500.0           #N-m       (full load torque)\n",
+    "Tl = 1000.0           #N-m       (load torque with flywheel)\n",
+    "t = 2.0               #s         (time)     \n",
+    "#Now, s = K*Tfl\n",
+    "K = (2*3.14*(N*s))/(Tfl*60)      #constant\n",
+    "\n",
+    "\n",
+    "#Also,  Tm = Tl*(1 - exp(-t/I*K))\n",
+    "I =-t/(K*m.log(1 - Tfl/Tl))       #(moment of inertia)\n",
+    "\n",
+    "print \"Moment of inertia of flywheel =\",round(I,2),\"kg-m^2.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}