# CHAPTER 2: DYNAMO CONSTRUCTION AND WINDINGS¶

## Example 2.1, Page number 48¶

In [1]:
#Variable declaration
m = 3.0   #Multipicity of the armature
P = 14.0  #Number of poles

#Calculation
a_lap = m*P    #Number of paths in the armature for lap winding
a_wave = 2*m   #Number of paths in the armature for wave winding

#Result
print('Case(a): Number of paths in the armature for lap winding , a = %.f paths' %a_lap)
print('Case(b): Number of paths in the armature for wave winding , a = %.f paths' %a_wave)

Case(a): Number of paths in the armature for lap winding , a = 42 paths
Case(b): Number of paths in the armature for wave winding , a = 6 paths


## Example 2.2, Page number 48¶

In [1]:
#Variable declaration
P = 14.0                    #Number of poles
phi = 4.2*10**6             #Flux per pole(lines)
S = 60.0                    #Generator speed(rpm)
coils = 420.0               #Number of coils
turns_per_coil = 20.0       #Turns per coil
conductors_per_turn = 2.0   #Conductors per turn
a_lap = 42.0                #Number of parallel paths in the armature for a lap winding
a_wave = 6.0                #Number of parallel paths in the armature for a wave winding

#Calculation
Z = coils*turns_per_coil*conductors_per_turn     #Number of conductors
E_g_lap = phi*Z*S*P/(60*a_lap)*10**-8            #Generated EMF for lap winding(V)
E_g_wave = phi*Z*S*P/(60*a_wave)*10**-8          #Generated EMF for wave winding(V)

#Result
print('Case(a): Generated EMF for lap winding , E_g = %.1f V' %E_g_lap)
print('Case(b): Generated EMF for wave winding , E_g = %.1f V' %E_g_wave)

Case(a): Generated EMF for lap winding , E_g = 235.2 V
Case(b): Generated EMF for wave winding , E_g = 1646.4 V


## Example 2.3, Page number 53¶

In [1]:
import math

#Variable declaration
slots = 72.0               #Number of slots
P = 4.0                    #Number of poles
coils_spanned = 14.0       #14 slots are spanned while winding the coils

#Calculation
coil_span = slots/P                          #Full-pitch coil span(slots/pole)
p_degree = coils_spanned/coil_span*180       #Span of the coil in electrical degrees
beta = (180-p_degree)                        #Beta(degree)
k_p1 = math.cos(beta/2*(math.pi/180))        #Pitch factor using eq(2-7)
k_p2 = math.sin(p_degree/2*(math.pi/180))    #Pitch factor using eq(2-8)

#Result
print('Case(a): Full-pitch coil span = %.f slots/pole' %coil_span)
print('Case(b): Span of the coil in electrical degrees , p° = %.f°' %p_degree)
print('Case(c): Pitch factor , k_p = %.2f ' %k_p1)
print('Case(d): Pitch factor , k_p = %.2f ' %k_p2)

Case(a): Full-pitch coil span = 18 slots/pole
Case(b): Span of the coil in electrical degrees , p° = 140°
Case(c): Pitch factor , k_p = 0.94
Case(d): Pitch factor , k_p = 0.94


## Example 2.4, Page number 54¶

In [1]:
import math

#Variable declaration
fractional_pitch = 13.0/16     #Coils having fractional pitch
slot =96.0                     #Number of slots
P = 6.0                        #Number of poles

#Calculation
p_degree = fractional_pitch*180             #Span of the coil in electrical degrees
k_p = math.sin(p_degree/2*(math.pi/180))    #Pitch factor

#Result
print('Pitch factor , k_p = %.4f ' %k_p)

Pitch factor , k_p = 0.9569


## Example 2.5, Page number 54¶

In [1]:
#Variable declaration
P = 12.0            #Number of poles
theta = 360.0       #Number of mechanical degrees of rotation
alpha_b = 180.0     #Number of electrical degrees in case(b)

#Calculation
alpha = (P*theta)/2      #Number of electrical degrees in one revolution(degree)
n = alpha/360            #Number of ac cycles
theta_b = (2*alpha_b)/P  #Number of mechanical degrees of rotation

#Result
print('Case(a): Number of electrical degrees in one revolution , α = %.f° ' %alpha)
print('         Number of ac cycles , n = %.f cycles' %n)
print('Case(b): Mechanical angle , θ = %.f mechanical degrees' %theta_b)

Case(a): Number of electrical degrees in one revolution , α = 2160°
Number of ac cycles , n = 6 cycles
Case(b): Mechanical angle , θ = 30 mechanical degrees


## Example 2.6, Page number 56¶

In [1]:
import math

#Variable declaration
P = 4.0         #Number of poles
phi = 3.0       #Number of phases
slot_1 = 12.0   #Number of slots for case 1
slot_2 = 24.0   #Number of slots for case 2
slot_3 = 48.0   #Number of slots for case 3
slot_4 = 84.0   #Number of slots for case 4

#Calculation
electrical_degrees = 180.0*P    #Electrical degrees
#Case(a)
alpha_1 = electrical_degrees/slot_1                                                 #Number of electrical degrees(°/slot)
n_1 = slot_1/(P*phi)                                                                #Number of slots per pole per phase(slot/pole-phase)
k_d1 = math.sin(n_1*alpha_1/2*(math.pi/180))/(n_1*math.sin(alpha_1/2*(math.pi/180)))#Distribution factor
#Case(b)
alpha_2 = electrical_degrees/slot_2                                                 #Number of electrical degrees(°/slot)
n_2 = slot_2/(P*phi)                                                                #Number of slots per pole per phase(slot/pole-phase)
k_d2 = math.sin(n_2*alpha_2/2*(math.pi/180))/(n_2*math.sin(alpha_2/2*(math.pi/180)))#Distribution factor
#Case(c)
alpha_3 = electrical_degrees/slot_3                                                 #Number of electrical degrees(°/slot)
n_3 = slot_3/(P*phi)                                                                #Number of slots per pole per phase(slot/pole-phase)
k_d3 = math.sin(n_3*alpha_3/2*(math.pi/180))/(n_3*math.sin(alpha_3/2*(math.pi/180)))#Distribution factor
#Case(d)
alpha_4 = electrical_degrees/slot_4                                                 #Number of electrical degrees(°/slot)
n_4 = slot_4/(P*phi)                                                                #Number of slots per pole per phase(slot/pole-phase)
k_d4 = math.sin(n_4*alpha_4/2*(math.pi/180))/(n_4*math.sin(alpha_4/2*(math.pi/180)))#Distribution factor

#Result
print('Case(a): Distribution factor , k_d')
print('      1: k_d = %.1f ' %k_d1)
print('      2: k_d = %.3f ' %k_d2)
print('      3: k_d = %.3f ' %k_d3)
print('      4: k_d = %.3f ' %k_d4)
print('\nCase(b): Tabular column')
print('         ________________________')
print('           n \t α \t k_d')
print('         ________________________')
print('           %d \t %d° \t %.1f' %(n_1,alpha_1,k_d1))
print('           %d \t %d° \t %.3f' %(n_2,alpha_2,k_d2))
print('           %d \t %d° \t %.3f' %(n_3,alpha_3,k_d3))
print('           %d \t %.2f° \t %.3f' %(n_4,alpha_4,k_d4))
print('         ________________________')

Case(a): Distribution factor , k_d
1: k_d = 1.0
2: k_d = 0.966
3: k_d = 0.958
4: k_d = 0.956

Case(b): Tabular column
________________________
n 	 α 	 k_d
________________________
1 	 60° 	 1.0
2 	 30° 	 0.966
4 	 15° 	 0.958
7 	 8.57° 	 0.956
________________________


## Example 2.7, Page number 56¶

In [1]:
import math

#Variable declaration
slots = 72.0       #Number of slots
P = 6.0            #Number of poles
phase = 3.0        #Three phase stator armature
N_c = 20.0         #Number of turns per coil
pitch = 5.0/6      #Pitch
phi = 4.8*10**6    #Flux per pole(lines)
S = 1200.0         #Rotor speed(rpm)

#Calculation
#Case(a)
f = (P*S)/120                        #Frequency of rotor(Hz)
E_g_percoil = 4.44*phi*N_c*f*10**-8  #Generated effective voltage per coil of a full pitch coil(V/coil)
#Case(b)
N_p = (slots/phase)*N_c              #Total number of turns per phase(turns/phase)
#Case(c)
n = slots/(phase*P)                  #Number of slots per pole per phase(slots/pole-phase)
alpha = (P*180)/slots                #Number of electrical degrees between adjacent slots(degree)
k_d = math.sin(n*alpha/2*(math.pi/180))/(n*math.sin(alpha/2*(math.pi/180)))  #Distribution factor
#Case(d)
span = pitch*180                     #Span of the coil in electrical degrees
k_p = math.sin(span/2*(math.pi/180)) #Pitch factor
#Case(e)
E_gp = 4.44*phi*N_p*f*k_p*k_d*10**-8 #Total generated voltage(V/phase)

#Result
print('Case(a): Generated effective voltage per coil of a full-pitch coil , E_g/coil = %.f V/coil' %E_g_percoil)
print('Case(b): Total number of turns per phase , N_p = %.f turns/phase' %N_p)
print('Case(c): Distribution factor , k_d = %.3f ' %k_d)
print('Case(d): Pitch factor , k_p = %.3f ' %k_p)
print('Case(e): Total generated voltage per phase , E_gp = %.f V/phase' %E_gp)

Case(a): Generated effective voltage per coil of a full-pitch coil , E_g/coil = 256 V/coil
Case(b): Total number of turns per phase , N_p = 480 turns/phase
Case(c): Distribution factor , k_d = 0.958
Case(d): Pitch factor , k_p = 0.966
Case(e): Total generated voltage per phase , E_gp = 5678 V/phase


## Example 2.8, Page number 62¶

In [1]:
import math

#Variable declaration
P = 8.0         #Number of poles
S = 900.0       #Speed(rev/min)
f_1 = 50.0      #Frequency(Hz)
f_2 = 25.0      #Frequency(Hz)

#Calculation
f = (P*S)/120                  #Frequency of the generated voltage(Hz)
S_1 = (120*f_1)/P              #Speed of prime mover to generate 50 Hz(rpm)
S_2 = (120*f_2)/P              #Speed of prime mover to generate 25 Hz(rpm)
omega_1 = (4*math.pi*f_1)/P    #Speed of prime mover to generate 50 Hz(rad/s)
omega_2 = (4*math.pi*f_2)/P    #Speed of prime mover to generate 25 Hz(rad/s)

#Result
print('Case(a): Frequency of the generated voltage , f = %.f Hz' %f)
print('Case(b): Prime mover speed required to generate 50 Hz , S = %.f rpm' %S_1)
print('         Prime mover speed required to generate 25 Hz , S = %.f rpm' %S_2)
print('Case(c): Prime mover speed required to generate 50 Hz , S = %.fπ rad/s' %(omega_1/math.pi))
print('         Prime mover speed required to generate 25 Hz , S = %.1fπ rad/s' %(omega_2/math.pi))

Case(a): Frequency of the generated voltage , f = 60 Hz
Case(b): Prime mover speed required to generate 50 Hz , S = 750 rpm
Prime mover speed required to generate 25 Hz , S = 375 rpm
Case(c): Prime mover speed required to generate 50 Hz , S = 25π rad/s
Prime mover speed required to generate 25 Hz , S = 12.5π rad/s