In [1]:

```
# Given Data;
f = 50.; #frequency
p = 6.; # number of poles
V = 400.; #voltage supply
S = 4.; #percentage slip
# Calculations and Results
Ns = (120*f)/p; #synchronous speed
print "Syhchronous speed, Ns = %d "%(Ns);
Nr = (1-(S/100))*Ns;
print "speed of rotor with slip 4 percent, Nr is %d rpm "%(Nr);
```

In [2]:

```
# Given Data;
f = 50.; #frequency
V = 400.; #voltage supply
# Calculations and Results
p = 2.;
print "when P = 2, Syhchronous speed, Ns = %d "%((120*f)/p);
p = 4;
print "when P = 2, Syhchronous speed,Ns = %d "%(120*f/p);
p = 6;
print "when P = 2, Syhchronous speed, Ns = %d "%(120*f/p);
p = 8;
print "when P = 2 Syhchronous speed, Ns = %d "%(120*f/p);
print ("for Nr to be 1440 , Ns will be 1500, thus p = 4")
Ns = 1500;Nr1 = 1440;
S1 = ((Ns-Nr1)/Ns)*100;
print "slip = %d"%(S1);
print ("for Nr to be 940 , Ns will be 1000, thus p = 6")
Ns = 1000;Nr2 = 940;
S2 = ((Ns-Nr2)/Ns)*100;
print "slip = %d"%(S2);
if S1>S2:
print ("motor running at 1440 rpm is running at higher slip")
elif S2>S1:
print ("motor running at 940 rpm is running at higher slip")
```

In [3]:

```
# Given Data;
P = 10.; #poles of alternator
N = 600.; #speed of alternator
# Calculations and Results
f = (P*N)/120 #frequency
print "frequency = %d"%(f);
print ("when P = 2");p = 2
Ns = (120*f)/p; #synchronous speed
print "Syhchronous speed, Ns = %d "%(Ns);
print ("when P = 4");p = 4;
Ns = (120*f)/p; #synchronous speed
print "Syhchronous speed, Ns = %d "%(Ns);
#speed of rotor(1440) is less than synchronous speed 1500, therefore P = 4
print ("speed of rotor(1440) is less than synchronous speed 1500, therefore P = 4")
Ns = 1500.;
Nr = 1440.;
S = ((Ns-Nr)/Ns)*100
print "slip is %d percent and number of poles is 4"%(S)
```

In [4]:

```
# Given Data
Nr = 1440.; #rotor speed in rpm
f = 50.; #frequency in hertz
# Calculations
#calculating Ns for values of P = 2,4,6,8 etc
#by checking P = 4
P = 4;
Ns = (120*f)/P; #Synchronous speed
S = (Ns-Nr)/Ns; #slip
Fr = S*f; #rotor frequency
# Results
print "Rotor frequency = %dHz"%(Fr)
```

In [5]:

```
# Given Data
f = 50.; #induction motor frequency in hertz
fr = 1.5; #rotor frequency in hertz
# Calculations and Results
S = fr/f; #slip
P = 8; #pole
Ns = (120*f)/P;
print "synchronous speed = %frpm"%(Ns)
Nr = Ns-(S*Ns);
print "motor running speed = %frpm"%(Nr)
S1 = S*100;
print "slip percent = %fpercent"%(S1)
```

In [7]:

```
import math
# Given Data
E20 = 100.; #induced emf in volts
R2 = 0.05; #rotor resistance in ohms
X20 = 0.1; #rotor reactance in ohms
# Calculations and Results
E20p = E20/math.sqrt(3);
print ("When S = 0.04")
S = 0.04;
I2 = (S*E20p)/math.sqrt(R2**2+(S*X20)**2)
print "I2 = %dA"%(I2);
phi2 = math.degrees(math.acos(R2/(math.sqrt(R2**2+(S*X20)**2))));
print "Phase angle between rotor voltage and rotor current = %f degrees"%(phi2);
print ("When S = 1")
S = 1;
I2 = (S*E20p)/math.sqrt(R2**2+(S*X20)**2)
print "I2 = %dA"%(I2);
phi2 = math.degrees(math.acos(R2/(math.sqrt(R2**2+(S*X20)**2))));
print "Phase angle between rotor voltage and rotor current = %f degrees"%(phi2);
```

In [8]:

```
# Given Data
f = 50.; #frequency of induction motor
P = 4.; #pole
Ns = (120*f)/P;
S = 3.; #slip percent
# Calculations
Nr = Ns-((Ns*S)/100)
fr = (S*f)/100;
# Results
print "synchronous speed = %frpm"%(Ns)
print "speed of running motor = %frpm"%(Nr)
print "rotor frequency = %fHz"%(fr)
```

In [9]:

```
# Given Data
fr = 2.; #frequency of motor induced emf in hertz
f = 50.; #frequency of induction motor in hertz
S = (fr/f)*100; #slip percent
P = 6.; #pole
# Calculations
Ns = (120*f)/P;
Nr = Ns-((Ns*S)/100);
# Results
print "percentage slip = %fpercent"%(S)
print "rotor speed = %frpm"%(Nr)
```

In [10]:

```
# Given Data
P = 12.; #pole
f = 50.; #frequency of induction motor in hertz
Nr = 485.; #induction motor speed in rpm
# Calculations
Ns = (120*f)/P;
S = (Ns-Nr)/Nr;
fr = S*f;
# Results
print "frequency of rotor current = %fHz"%(fr)
```

In [11]:

```
# Given Data
E20 = 100.; #induced emf of induction motor at stanstill in volts
E20p = E20/math.sqrt(3); #induced emf per phase in volts
S = 0.40; #slip
# Calculations and Results
E2 = S*E20p; #rotor induced emf at slip S in volts
print "Rotor induced emf at a slip E2 = %fV"%(E2);
R2 = 0.4; #resistance per phase in ohms
X20 = 2.25; #stanstill resistance per phase i ohms
Z2 = math.sqrt((R2)**2+(S*X20)**2); #rotor impedence at slip S in ohms
print "Rotor impedence at a slip S, Z2 = %fohms"%(Z2)
I = E2/Z2;
print "rotor current = %fA"%(I)
```

In [12]:

```
# Given Data
S = 0.03; #slip
SI = 50.; #stator input in kilowatts
SL = 2.; #stator loss in kilowatts
# Calculations and Results
RI = SI-SL; #rotor input in kilowatts
RIL = S*RI; #rotor I**2R loss
#rotor core loss can be neglected at 3percent slip
PDR = RI-RIL; #power developed by the rotor
print "Power developed by the rotor = %fkW"%(PDR);
FWL = 1; #friction and windage loss in kilowatt
OP = PDR-FWL; #output power
print "Output power = %fkW"%(OP);
effi = (OP*100)/SI;
print "Efficiency of the motor = %f percent"%(effi)
```

In [13]:

```
# Given Data
f = 50.; #frequency of induction motor in hertz
hp = 20.; #horse power
ph = 3.; #Three phase supply
P = 4.; #number of poles
# Calculations and Results
losses = 500; #friction and vintage losses
print "Output of the motor = %fW"%(hp*735.5)
Pd = (hp*735.5)+losses; #power developed in watt
print "Power developed by the rotor = %dW"%(Pd);
s = 0.04; #slip
rotorloss = (s*Pd)/(1-s);
print "Rotor I**2R-loss = %fW"%(rotorloss);
Ns = (120*f)/P;
print "Ns = %drpm"%(Ns);
Nr = Ns*(1-s);
print "Nr = %drpm"%(Nr);
```

In [16]:

```
# Given Data
f = 50.; #frequency of induction motor in hertz
P = 6.; #number of poles
ph = 3.; #Three phase supply
# Calculations and Results
R2 = 0.1; #rotor resistance in ohms
Ns = (120*f)/P;
print "Syncronous speed, Ns = %drpm"%(Ns);
Nr = 940; #rotor speed in rpm
S = (Ns-Nr)/Ns;
print "Slip, S = %f"%(S);
print "stanstill rotor reactance, X20 = %fohms"%(R2/S);
```

In [18]:

```
# Given Data
f = 50.; #frequency of induction motor in hertz
P = 4.; #number of poles
Nr = 1440.; #rotor speed in rpm
R2 = 0.1; #rotor resistance in ohms
X20 = 0.6; #rotor stanstill resistance in ohms
# Calculations and Results
Ns = (120*f)/P;
print "Synchronous speed = %drpm"%(Ns);
S1 = (Ns-Nr)*(100/Ns);
print "Full-load slip with rotor resistance, R2 i.e. S1 = %f"%(S1);
print ("on adding extra resistance o.1ohm")
#on solving we get S2 = 0.08
S2 = 0.08;
Nr2 = Ns*(1-S2);
print "New rotor speed = %drpm"%(Nr2);
```

In [19]:

```
# Given Data
f = 50.; #frequency in hertz
P = 4.; #number of poles
R2 = 0.04; #rotor resistance in ohms
# Calculations and Results
Ns = (120*f)/P;
print "Syncronous speed = %drpm"%(Ns);
Nr = 1200; #rotor speed at maximium torque in rpm
S = (Ns-Nr)/Ns;
print "Slip at maximium torque = %f"%(S);
X20 = R2/S;
#starting torque is developed when S = 1
#r = (Tst/Tm)
r = (R2/(R2**2+X20**2))*(2*X20);
print "Therefore, starting torque is %fpercent of the maximium torque"%(r*100)
```

In [20]:

```
# Given Data
P = 4.; #number of poles
f = 50.; #frequency in hertz
ph = 3.; #three phase supply
R2 = 0.25; #rotor resistance in ohms
Nr = 1440.; #rotor speed in rpm
# Calculations and Results
Ns = (120*f)/P;
S1 = (Ns-Nr)/Ns;
print "S1 = %f"%(S1);
Nr2 = 1200; #rotor speed when external is added
S2 = (Ns-Nr2)/Ns;
#torque remains consmath.tant,we get the relation R2' = R2*(S2/S1)
R2dash = R2*(S2/S1)
print "Extra resistance to be connected in the motor circuit = %fohms"%(R2dash-R2)
```

In [21]:

```
# Given Data
hp = 20.;
P = 4.; #number of poles
f = 50.;
S = 0.03; #slip
# Calculations and Results
MSO = hp*735.5; #motor shaft output
losses = 0.02*MSO #friction and windage loss in watts
Pd = MSO+losses; #power developed by the rotor in watts
RCL = (S*Pd)/(1-S); #rotor I**2*R loss
print "rotor copper loss = %fW"%(RCL);
Ri = Pd+RCL #rotor iron loss is neglected
print "Rotor input = %fW"%(Ri);
Ns = (120*f)/P;
Nr = Ns*(1-S)*(1./60); #rotor speed in rps
OT = MSO/(2*3.14*Nr); #outp[ut torque in Nm
print "output torque = %fNm"%(OT)
```

In [23]:

```
# Given Data
f = 50.; #frequency of induction motor in hertz
P = 6.; #pole
Ns = (120.*f)/P;
Nr = 975.; #induction motor running speed in rpm
# Calculations and Results
S = (Ns-Nr)/Ns;
print "the slip = %f"%(S)
Pin = 40.; #power input to stator in kW
Sl = 1.; #stator losses in kW
Rin = Pin-Sl; #output from stator in kW
Rc = S*Rin;
print "rotor copper losses = %fkW"%(Rc)
l = 2.; #total losses in kW
p = Rin-Rc-l; #output power in kw
HP = (p*1000)/735.5;
print "output horse output = %fHP"%(HP)
in1 = 40.; #input in kW
effi = (p/in1)*100;
print "efficiency = %fpercent"%(effi)
```

In [24]:

```
# Given Data
f = 50.; #frequency of induction motor in hertz
P = 6.; #pole
# Calculations and Results
Ns = (120.*f)/P;
print "synchronous speed = %frpm"%(Ns)
fr = 120./60; #rotor frequency
S = fr/f;
print "the slip = %f"%(S)
Nr = Ns-(Ns*S);
print "rotor speed = %frpm"%(Nr)
Rin = 80.; #rotor input in kW
Rc = S*Rin; #Rotor copper loss in kW
Ph = 3.; #number of phases
Rcp = (Rc/Ph)*1000; #loss per phase in watt
p = ((Rin-Rc)*1000)/735.5;
print "mechanical power developed = %fhp"%(p)
Ir = 60; #rotor current in amperes
R2 = Rcp/(Ir)**2;
print "rotor resistance per phase at rotor current 60A = %fohms"%(R2)
```

In [25]:

```
# Given Data
# we know (Ts/Tm) = ((2*a)/(1+a**2))
#where a = (R2/X20)
#at starting contion math.since Tm = Ts
print ("At starting contion math.since Tm = Ts")
# Calculations and Results
a = 1 #we obtain from the relations
R2 = 0.05; #circuit resistance in ohms
X2 = 0.4; #stanstill reactance in ohms
r = (a*X2)-R2; #r is the extra that is added to the rotor circuit
print "extra resistance added ,r = %fohms"%(r)
```

In [26]:

```
# Given Data
V = 400.; #supply voltage in volts
f = 50.; #frequency in hertz
P = 6.; #number of poles
ph = 3.; #three phase supply
R2 = 0.03; #rotor resistance in ohms
X20 = 0.4; #rptor reactance in ohms
Nr = 960.; #full load speed in rpm
# Calculations and Results
Ns = (120*f)/P;
print "synchronous speed = %drpm"%(Ns)
S = (Ns-Nr)/Ns; #corresponding slip
#maximium torque Tm occurs at S = (R2/X20)
#we get Tm = k/(2*X20)
a = R2/X20;
#r = Tm/T
r = (a**2+S**2)/(2*a*S);
Sm = (R2/X20);
print "Slip at maximium torque, Sm = %f"%(Sm);
#corresponding speed
Nr2 = Ns*(1-Sm);
print "Rotor speed at maximium torque = %drpm"%(Nr2)
```

In [27]:

```
import math
# Given Data
V = 400.; #supply voltage in volts
f = 50.; #frequency in hertz
P = 4.; #number of poles
ph = 3.; #three phase supply
S = 0.04;
If = 30.; #Full load current in amperes
# Calculations and Results
Isc = 6*If;
#let r be the ratio of starting torque nd full load torque, r = Ts/Tf
r = (Isc/If)**2*S;
#Tf = Tm is produced when voltage is Vm
Vm = math.sqrt(V**2/r);
print "voltage at maximium torque = %fvolts"%(Vm);
Is = 6*If*(Vm/V);
print "Full-load current at 333.3 volts is = %fA"%(Is)
```

In [29]:

```
# Given Data
V = 400.; #supply voltage in volts
f = 50.; #frequency in hertz
Id = 75.; #current taken when delta-connected in amperes
# Calculations and Results
print "current taken when delta-connected = %dA"%(Id);
Is = Id/3; #current taken when star-connected in amperes
print "current taken when star-connected = %dA"%(Is);
#Tfl be the full load torque
#r = Ts/Tfl
r = 1.5;
#math.since voltage becomes (1/math.sqrt(3)) when star connected
#torque is directly proportional to square of voltage
print "Starting torque with winding star connected = %f times of Tfl"%(r/3);
```

In [31]:

```
import math
# Given Data
ph = 3;
#rotor copper loss = slip*rotor input
#Tst = starting torque
#Tfl = torque at full load
#Ist/Ifl = r
r = 6;
# Calculations and Results
S = 0.04
print " At slip = 0.04"
print "For direct-on-line starting ( Tst/Tfl) = %f"%(r**2*S);
#phase current in start is (1/math.sqrt(3)) times the phase current in delta
print "For direct-on-line starting( Tst/Tfl) = %f"%((r/math.sqrt(3))**2*S);
```

In [32]:

```
# Given Data
V = 400.; #voltage in volts
f = 50.; #frequency in hertz
P = 4.; #number of poles
#r1 = (Ts/Tfl)
r1 = 1.6;
#r2 = (Tm/Tfl)
r2 = 2.;
#r3 = (Ts/Tm) = (2*a)/(1+a**2)
r3 = 0.8;
#on solving , we get a = 0.04 ,
a = 0.04;
# Calculations and Results
Sm = 0.04; #slip at maximium torque
print "Slip at maximium torque, Sm = %f"%(Sm)
Ns = (120*f)/P; #synchronous speed in rpm
Nr = Ns*(1-Sm) #rotor speed in rpm
#r2 = (a**2+Sfl**2)/(2*a*Sfl)
Sfl = 0.01;
Nr2 = Ns*(1-Sfl);
print "full load speed, Nr = %drpm"%(Nr2)
```

In [33]:

```
# Given Data
hp = 20.; #power in horsepower
f = 50.; #frequency in hertz
P = 4.; #number of poles
# Calculations and Results
Ns = (120*f)/P; #synchronous speed
print "Synchronous speed, Ns = %drpm"%(Ns);
S = 0.04; #slip
Nr = Ns*(1-S);
OP = hp*735.5;
print "Output power = %fW"%(OP);
OT = OP/(2*3.14*(Nr/60));
print "Output torque = %fNm"%(OT);
FL = 0.02*OP; #Friction and windage loss
PD = OP+FL;
print "Power developed by the rotor = %fW"%(PD);
#from relation, (rotor I**2R-loss = S*Rotor input) we get following relation
RL = (S*PD)/(1-S);
print "Rotor I**2R-loss = %fW"%(RL);
RI = RL/S;
print "Rotor input = %dW"%(RI)
```

In [34]:

```
# Given Data
P = 4.; #number of poles
f = 50.; #frequency in hertz
V = 230.; #voltage in volts
hp = 5.; #power in horsepower
Ib = 15.; #current in block rotor test in amperes
# Calculations and Results
output = hp*735.5; #output in watts
#in block rotor test: power input = Full = load I**2R losses = 735W
FLl = 735; #Full-load I**2R losses
print "Full-load I**2R losses = %fW"%(FLl);
Re = FLl/(3*Ib**2);
Io = 6.3; #current in no load condition in amperes
lossNL = (3*(Io)**2*Re); #I**2R loss at no-load condition
print "I**2R loss at no-load = %fW"%(lossNL);
PiNL = 275; #power input at no-load
print "Core loss plus friction and windage loss = %dW"%(PiNL-lossNL);
TL = FLl+(PiNL-lossNL);
effi = (output*100)/(output+TL);
print "Efficiency = %fpercent"%(effi)
```

In [35]:

```
# Given Data
Vl = 415.; #voltage in volts
Il = 50.; #line current in amperes
R1 = 0.5; #resistrance of stator winding per phase in ohms
pf = 0.85; #power factor
S = 0.04;
# Calculations and Results
IFL = (math.sqrt(3)*Vl*Il*pf) #input to the motor on full load
print "Input to the motor on full load = %dW"%(IFL);
I1 = Il/math.sqrt(3);
SLFL = (3*I1**2*R1) #Stator I**2R loss on full load
print "Stator I**2R loss on full load = %dW"%(SLFL);
#given ratio of stator core loss friction and windahe loss be r = (r1:r2)
r1 = 3.;
r2 = 2.;
TL = 1500.; #total loss
SCL = (r1*TL)/(r1+r2); #stator core loss
FWL = (r2*TL)/(r1+r2); #Friction and windage loss
SL = SLFL+SCL; #total stator loss
SI = IFL; #Stator input
Pa = SI-SL; #power transferred through the air-gap = input to the rotor
RI = Pa
RL = S*RI; #rotor losses
TRL = FWL+RL; #total rotor losses
OP = RI-TRL; #Output power at the shaft
effi = (OP*100)/SI;
print "Efficiency = %f percent"%(effi)
```

In [36]:

```
# Given Data
E20 = 100.; #induced emf between slip terminals in volts
# Calculations and Results
E20p = E20/math.sqrt(3); #induced emf per phase in volts
print "induced emf per phase = %fV"%(E20p)
S = 3/100; #slip
R2 = 0.2; #resistance in ohms
X20 = 1; #stanstill resistance in ohms
I2 = (S*E20p)/math.sqrt((R2)**2+(S*X20)**2)
print "rotor current at slip 0.03 = %fA per phase"%(I2)
Sm = R2/X20;
I2m = (Sm*E20p)/math.sqrt((R2)**2+(Sm*X20)**2)
print "rotor current when the rotor develops maximum torque = %fA per phase"%(I2m)
```

In [37]:

```
# Given Data
E20 = 120.; #induced emf of motor at stanstill in volts
E20p = 120./math.sqrt(3); #induced emf per phase
f = 50.; #frequency of the motor in hertz
R2 = 0.2; #Rotor resistance per phase
X20 = 1.; #stanstill resistance in ohms
P = 4.; #pole
I = 16.; #
# Calculations and Results
S = (I*R2)/math.sqrt((E20)**2-(I*X20)**2);
Ns = (120*f)/P;
print "Synchronous speed = %frpm"%(Ns)
Nr = Ns-(Ns*S)
Sm = R2/X20;
Nr = Ns-(Ns*Sm)
I2 = (Sm*E20p)/math.sqrt((R2)**2+(Sm*X20)**2)
print "rotor current at maximum torque = %fAper Phase"%(I2)
Pi = (3*((I2)**2)*R2)/Sm;
print "Rotor input for the three phase = %fW"%(Pi)
```

In [38]:

```
import math
# Given Data
R1dc = 0.01; #DC resistance in ohms
V = 400.; #voltage in volts
r = 1.5; #ratio of ac to dc resistance
R1 = r*R1dc; #AC resistance in ohms
#at no-load
Io = 20.; #no-load current in amperes
SL = (3*Io**2*R1); #I**2R loss in the stator phases in watts
FWL = 300.; #Friction and windage loss in watts
TL = 1200.; #total losses = no-load power input in watts
# Calculations
CL = TL-(SL+FWL); #core loss in watt
CLp = CL/math.sqrt(3); #core loss per phase
Vp = V/math.sqrt(3); #voltage per phase
Rm = (Vp**3)/CL; #motor resistance
pf = CL/(Vp*Io);
phi0 = math.degrees(math.acos(pf));
Xm = Vp/(Io*math.sin(math.radians(phi0))); #motor reactance
#Under blocked rotor test
Vb = 100; #voltage in volts
Isc = 45; #current in amperes
Vbp = 100/math.sqrt(3); #voltage per phase in volts
P = 2750; #power supplied in watts
Ze = Vbp/Isc; #Motor impedance reffered to stator side in ohms
Re = P/(3*Isc**2);
R2 = Re-R1; #rotor resistance referred to stator side
Xe = math.sqrt(Ze**2-Re**2);
#assuming X1 = X2
X2 = Xe/2
X1 = X2;
# Results
print "Thus the elements of the equivalent circuit are:";
print "Rm = %fohms"%(Rm);
print "Xm = %fohms"%(Xm);
print "R1 = %fohms"%(R1);
print "rotor resistance referred to stator side, R2 = %fohms"%(R2);
print "equivalent resistance referred to stator side, Re = %fohms"%(Re);
print "X1 = %fohms"%(X1);
print "rotor reactance referred to stator side, X2 = %fohms"%(X2);
print "equivalent reactance referred to stator side, Xe = %fohms"%(Xe);
```