In [2]:

```
import math
# Variables:
N1 = 150. #rpm
d1 = 750. #mm
d2 = 450. #mm
d3 = 900. #mm
d4 = 150. #mm
#Solution:
#Calculating the speed of the dynamo shaft when there is no slip
N41 = N1*(d1*d3)/(d2*d4) #rpm
#Calculating the speed of the dynamo shaft whne there is a slip of 2% at each drive
s1 = 2.
s2 = 2. #%
N42 = N1*(d1*d3)/(d2*d4)*(1-s1/100)*(1-s2/100) #rpm
#Results:
print " Speed of the dynamo shaft when there is no slip, N4 = %d rpm."%(N41)
print " Speed of the dynamo shaft when there is a slip of 2 %% at each drive, N4 = %d rpm."%(N42)
```

In [7]:

```
import math
# Variables:
d1 = 1.
d2 = 2.25 #m
N1 = 200. #rpm
sigma1 = 1.4*10**6
sigma2 = 0.5*10**6
E = 100.*10**6 #N/m**2
#Solution:
#Calculating the speed of the driven pulley
N21 = round(N1*(d1/d2),1) #rpm
#Calculating the speed of the shaft considering creep
N22 = N1*(d1/d2)*(E+math.sqrt(sigma2))/(E+math.sqrt(sigma1)) #rpm
#Calculating the speed lost by the driven pulley due to creep
Nl = N21-N22 #Speed lost by the driven pulley due to creep rpm
#Results:
print " Speed lost by the driven pulley due to creep = %.3f rpm."%(Nl)
# note : answer is accurate. please check using calculator.
```

In [6]:

```
from numpy import linalg
from scipy.optimize import fsolve
import math
# Variables:
N1 = 160. #rpm
N3 = N1 #rpm
N5 = N3 #rpm
N2 = 60. #rpm
N4 = 80. #rpm
N6 = 100. #rpm
x = 720.
r1 = 40. #mm
#Solution:
#For a crossed belt:
#Calcluating the radii of pulleys 2 3 4 5 and 6
r2 = r1*(N1/N2) #mm
#For pulleys 3 and 4 r4 = r3*(N3/N4) or r3*(N3/N4)-r4 = 0
#For a crossed belt drive r3+r4 = r1+r2
A = [[N3/N4, -1],[ 1, 1]]
B = [0, r1+r2]
V = linalg.solve(A,B)
r3 = V[0] #mm
r4 = V[1] #mm
#For pulleys 5 and 6 r6 = r5*(N5/N6) or r5*(N5/N6)-r6 = 0
#For a crossed belt drive r5+r6 = r1+r2
A = [[N5/N6, -1],[ 1, 1]]
B = [0, r1+r2]
V = linalg.solve(A,B)
r5 = V[0] #mm
r6 = V[1] #mm
#Results:
print " For a crossed belt, r2 = %.1fmm;"%(r2)
print " r3 = %.1f mm;"%(r3)
print " r4 = %.1f mm;"%(r4)
print " r5 = %.1f mm;"%(r5)
print " r6 = %.1f mm."%(r6)
#For an open belt:
#Calcluating the radii of pulleys 2 3 4 5 and 6
r2 = r1*(N1/N2) #mm
#Calculating the length of belt for an open belt drive
L = math.pi*(r1+r2)+(r2-r1)**2/x+2*x #mm
#For pulleys 3 and 4 r4 = r3*(N3/N4) or r3*(N3/N4)-r4 = 0
#Since L is constant for pulleys 3 and 4 pi*(r3+r4)+(r4-r3)**2/x+2*x-L = 0
def f(a):
r3 = a[0]
r4 = a[1]
y = [0,0]
y[0] = r3*(N3/N4)-r4
y[1] = math.pi*(r3+r4)+(r4-r3)**2/x+2*x-L
return y
z = fsolve(f,[1,1])
r3 = z[0] #mm
r4 = z[1] #mm
#For pulleys 5 and 6 r6 = r5*(N5/N6) or r5*(N5/N6)-r6 = 0
#Since L is constant for pulleys 5 and 6 pi*(r5+r6)+(r6-r5)**2/x+2*x-L = 0
def f1(a):
r5 = a[0]
r6 = a[1]
y = [0,0]
y[0] = r5*(N5/N6)-r6
y[1] = math.pi*(r5+r6)+(r6-r5)**2/x+2*x-L
return y
z = fsolve(f1,[1,1])
r5 = z[0] #mm
r6 = z[1] #mm
#Results:
print " For an open belt, r2 = %.1fmm"%(r2)
print " r3 = %.1f mm;"%(r3)
print " r4 = %.1f mm;"%(r4)
print " r5 = %d mm;"%(round(r5,-1))
print " r6 = %d mm."%(r6)
# note : answers are slightly different because of fsolve function and rounding off error.
```

In [4]:

```
import math
# Variables:
d = 600./1000 #m
N = 200. #rpm
mu = 0.25
theta = 160*math.pi/180 #radians
T1 = 2500. #N
#Solution:
#Calcluating the velocity of the belt
v = math.pi*d*N/60 #m/s
#Calcluating the tension in the slack side of the belt
T2 = T1/math.exp(mu*theta) #N
#Calcluating the power transmitted by the belt
P = (T1-T2)*v/1000 #kW
#Results:
print " Power transmitted by the belt, P = %.2f kW."%(P)
```

In [5]:

```
import math
# Variables:
W = 9.*1000
T1 = W #N
d = 300./1000 #m
N = 20. #rpm
mu = 0.25
#Solution:
#Force required by the man:
#Calculating the angle of contact
theta = 2.5*2*math.pi #rad
#Calculating the force required by the man
T2 = T1/math.exp(mu*theta) #N
#Power to raise the casting:
#Calculating the velocity of the rope
v = math.pi*d*N/60 #m/s
#Calculating the power to raise the casting
P = (T1-T2)*v/1000 #kW
#Results:
print " Force required by the man, T2 = %.2f N."%(T2)
print " Power to raise the casting, P = %.3f kW."%(P)
```

In [7]:

```
import math
# Variables:
d1 = 450./1000 #mm
r1 = d1/2 #m
d2 = 200./1000 #m
r2 = d2/2
x = 1.95 #m
N1 = 200. #rpm
T1 = 1.*1000 #N
mu = 0.25
#Solution:
#Calculating the speed of the belt
v = math.pi*d1*N1/60 #m/s
#Length of the belt:
#Calculating the length of the crossed belt
L = math.pi*(r1+r2)+2*x+(r1+r2)**2/x #m
#Angle of contact between the belt and each pulley:
#Calculating the angle alpha
alpha = math.sin((r1+r2)/x)*180/math.pi #degrees
#Calculating the angle of contact between the belt and each pulley
theta = (180+2*alpha)*math.pi/180 #radians
#Power transmitted:
#Calculating the tension in the slack side of the belt
T2 = T1/math.exp(mu*theta) #N
#Calculating the power transmitted
P = (T1-T2)*v/1000 #kW
#Results:
print " Length of the belt, L = %.3f m."%(L)
print " Angle of contact between the belt and each pulley, theta = %.3f rad."%(theta)
print " Power transmitted, P = %.2f kW."%(P)
```

In [10]:

```
from numpy import linalg
import math
# Variables:
N1 = 200.
N2 = 300. #rpm
P = 6.*1000 #W
b = 100.
t = 10. #mm
x = 4.
d2 = 0.5 #m
mu = 0.3
#Solution:
#Stress in the belt for an open belt drive:
#Calculating the diameter of the larger pulley
d1 = d2*(N2/N1) #m
#Calculating the velocity of the belt
v = math.pi*d2*N2/60 #m/s
#Calculating the angle alpha for an open belt drive
alphao = math.sin((r1-r2)/x)*180/math.pi #degrees
#Calculating the angle of contact on the smaller pulley
thetao = (180-2*alphao)*math.pi/180 #radians
#Calculating the tensions in the belt
#Ratio of the tensions in the belt T1/T2 = math.exp(mu*thetao) or T1-T2*math.exp(mu*thetao) = 0
#Power transmitted P = (T1-T2)*v or T1-T2 = P/v
A = [[1, -math.exp(mu*thetao)],[ 1, -1]]
B = [0, P/v]
V = linalg.solve(A,B)
T1o = V[0] #N
T2o = V[1] #N
#Calculating the stress in the belt
sigmao = T1o/(b*t) #MPa
#Stress in the belt for a cross belt drive:
#Calculating the angle alpha for a cross belt drive
alphac = math.sin((d1+d2)/(2*x))*180/math.pi #degrees
#Calculating the angle of contact
thetac = (180+2*alphac)*math.pi/180 #radians
#Calculating the tensions in the belt
#Ratio of the tensions in the belt T1/T2 = math.exp(mu*thetac) or T1-T2*math.exp(mu*thetac) = 0
#Power transmitted P = (T1-T2)*v or T1-T2 = P/v
A = [[1, -math.exp(mu*thetac)],[ 1, -1]]
B = [0, P/v]
V = linalg.solve(A,B)
T1c = V[0] #N
T2c = V[1] #N
#Calculating the stress in the belt
sigmac = T1c/(b*t) #MPa
#Results:
print " Stress in the belt for an open belt drive, sigma = %.3f MPa."%(sigmao)
print " Stress in the belt for a cross belt drive, sigma = %.3f MPa."%(sigmac)
```

In [11]:

```
import math
# Variables:
P = 7.5*1000 #W
d = 1.2 #m
t = 10./1000 #m
N = 250. #rpm
theta = 165.*math.pi/180 #radians
mu = 0.3
sigma = 1.5*10**6 #N/m**2
rho = 1.*10**3 #kg/m**3
#Solution:
#Calculating the velocity of the belt
v = math.pi*d*N/60 #m/s
#Calculating the tensions in the belt
#Power transmitted P = (T1-T2)*v or T1-T2 = P/v
#Ratio of tensions in the belt math.log(T1/T2) = mu*theta or T1-T2*math.exp(mu*theta) = 0
A = [[1, -1],[1, -math.exp(mu*theta)]]
B = [P/v, 0]
V = linalg.solve(A,B)
T1 = V[0] #N
T2 = V[1] #N
#Calculating the width of the belt
b = T1/(sigma*t-t*1*rho*v**2)*1000 #mm
#Results:
print " Width of the belt, b = %.1f mm."%(b)
```

In [12]:

```
from numpy import linalg
import math
# Variables:
t = 9.75/1000
d1 = 300./1000
x = 3. #m
P = 15.*1000 #W
N1 = 900.
N2 = 300. #rpm
rho = 1000. #kg/m**3
sigma = 2.5*10**6 #N/m**2
mu = 0.3
#Solution:
#Calculating the diameter of the driven pulley
d2 = d1*(N1/N2) #m
#Calculating the velocity of the belt
v = math.pi*d1*N1/60 #m/s
#Calculating the angle alpha for an open belt drive
alpha = math.sin((d2-d1)/(2*x))*180/math.pi #degrees
#Calculating the angle of lap
theta = (180-2*alpha)*math.pi/180 #radians
#Calculating the tensions in the belt
#Ratio of tensions math.log(T1/T2) = mu*theta or T1-T2*math.exp(mu*theta) = 0
#Power transmitted P = (T1-T2)*v or T1-T2 = P/v
A = [[1, -math.exp(mu*theta)],[ 1, -1]]
B = [0, P/v]
V = linalg.solve(A,B)
T1 = V[0] #N
T2 = V[1] #N
#Calculating the width of the belt
b = T1/(sigma*t-t*1*rho*v**2)*1000 #mm
#Results:
print " Width of the belt, b = %d mm."%(b)
```

In [13]:

```
import math
# Variables:
theta = 120*math.pi/180 #degrees #radians
b = 100./1000
t = 6./1000 #m
rho = 1000. #kg/m**3
mu = 0.3
sigma = 2*10**6 #N/m**2
#Solution:
#Speed of the belt for greatest power:
#Calculating the maximum tension in the belt
T = sigma*b*t #N
#Calculating the mass of the belt per metre length
l = 1. #m
m = b*t*l*rho #kg/m
#Calculating the speed of the belt for greatest power
v = math.sqrt(T/(3*m)) #m/s
#Greatest power which the belt can transmit
#Calculating the centrifugal tension for maximum power to be transmitted
TC = T/3 #N
#Calculating the tension in the tight side of the belt
T1 = T-TC #N
#Calculating the tension in the slack side of the belt
T2 = T1/math.exp(mu*theta) #N
#Calculating the greatest power which the belt can transmit
P = (T1-T2)*v/1000 #kW
#Results:
print " Speed of the belt for greatest power, v = %.2f m/s."%(v)
print " Greatest power which the belt can transmit, P = %.2f kW."%(P)
```

In [15]:

```
import math
# Variables:
d1 = 1.2 #m
r1 = d1/2 #m
d2 = 0.5 #m
r2 = d2/2 #m
x = 4. #m
m = 0.9 #kg/m
T = 2000. #N
mu = 0.3
N1 = 200. #rpm
N2 = 450. #rpm
#Solution:
#Calculating the velocity of the belt
v = math.pi*d1*N1/60 #m/s
#Calculating the centrifugal tension
TC = m*v**2 #N
#Calculating the tension in the tight side of the belt
T1 = T-TC #N
#Calculating the angle alpha for an open belt drive
alpha = math.sin((r1-r2)/x)*180/math.pi #degrees
#Calculating the angle of lap on the smaller pulley
theta = (180-2*alpha)*math.pi/180 #radians
#Calculating the tension in the slack side of the belt
T2 = T1/math.exp(mu*theta) #N
#Calculating the torque on the shaft of larger pulley
TL = (T1-T2)*r1 #N-m
#Calculating the torque on the shaft of smaller pulley
TS = (T1-T2)*r2 #N-m
#Calculating the power transmitted
P = (T1-T2)*v/1000 #kW
#Power lost in friction:
#Calculating the input power
P1 = TL*2*math.pi*N1/(60*1000) #kW
#Calculating the output power
P2 = TS*2*math.pi*N2/(60*1000) #kW
#Calculating the power lost in friction
Pf = P1-P2 #Power lost in friction kW
#Calculating the efficiency of the drive
eta = P2/P1*100 #%
#Results:
print " Torque on the shaft of larger pulley, TL = %.1f N-m."%(TL)
print " Torque on the shaft of smaller pulley, TS = %d N-m."%(TS)
print " Power transmitted, P = %.2f kW."%(P)
print " Power lost in friction = %.2f kW."%(Pf)
print " Efficiency of the drive, eta = %.1f %%."%(eta)
```

In [16]:

```
from numpy import linalg
import math
# Variables:
T0 = 2000. #N
mu0 = 0.3
theta = 150.*math.pi/180 #radians
r2 = 200./1000
d2 = 2*r2 #m
N2 = 500. #rpm
#Solution:
#Calculating the velocity of the belt
v = math.pi*d2*N2/60 #m/s
#Calculating the tensions in the belt
#Initial tension T0 = (T1+T2)/2 or T1+T2 = 2*T0
#Ratio of the tensions in the belt math.log(T1/T2) = mu*theta or T1-T2*math.exp(mu*theta) = 0
A = [[1, 1],[ 1 ,-math.exp(mu*theta)]]
B = [2*T0, 0]
V = linalg.solve(A,B)
T1 = V[0] #N
T2 = V[1] #N
#Calculating the power transmitted
P = (T1-T2)*v/1000 #kW
#Results:
print " Power transmitted, P = %.1f kW."%(P)
```

In [8]:

```
from numpy import linalg
import math
# Variables:
x = 4.8
d1 = 1.5 #m
d2 = 1. #m
T0 = 3.*1000 #N
m = 1.5 #kg/m
mu = 0.3
N2 = 400. #rpm
#Solution:
#Calculating the velocity of the belt
v = math.pi*d2*N2/60 #m/s
#Calculating the centrifugal tension
TC = m*v**2 #N
#Calculating the angle alpha
alpha = math.sin((d1-d2)/(2*x))*180/math.pi #degrees
#Calculating the angle of lap for the smaller pulley
theta = (180-2*alpha)*math.pi/180 #radians
#Calculating the tensions in the belt
#Initial tension T0 = (T1+T2+2*TC)/2 or T1+T2 = 2*(T0-TC)
#Ratio of tensions in the belt math.log(T1/T2) = mu*theta or T1-T2*math.exp(mu*theta) = 0
A = [[1, 1],[1, -math.exp(mu*theta)]]
B = [2*(T0-TC), 0]
V = linalg.solve(A,B)
T1 = V[0] #N
T2 = V[1] #N
#Calculating the power transmitted
P = (T1-T2)*v/1000 #kW
#Results:
print " Power transmitted, P = %.f kW."%(P)
# answer are slightly different because of solve function
```

In [19]:

```
import math
# Variables:
x = 1.2 #m
d2 = 400./1000 #m
t = 5./1000 #m
b = 80./1000 #m
N1 = 350. #rpm
N2 = 140. #rpm
mu = 0.3
sigma = 1.4*10**6 #N/m**2
#Solution:
#Calculating the diameter of the driving pulley
d1 = d2*(N2/N1) #m
#Maximum power transmitted by the belting:
#Refer Fig. 11.18
#Calculating the angle alpha
alpha = math.sin((d2-d1)/(2*x))*180/math.pi #degrees
#Calculating the angle of contact of the belt on the driving pulley
theta = (180-2*alpha)*math.pi/180 #radians
#Calculating the maximum tension to which the belt can be subjected
T1 = sigma*b*t #N
#Calculating the tension in the slack side of the belt
T2 = T1/math.exp(mu*theta) #N
#Calculating the velocity of the belt
v = math.pi*d1*N1/60 #m/s
#Calculating the power transmitted
P = (T1-T2)*v/1000 #kW
#Calculating the required initial belt tension
T0 = (T1+T2)/2 #N
#Results:
print " Diameter of the driving pulley, d1 = %.2f m."%(d1)
print " Maximum power transmitted by the belting, P = %.3f kW."%(P)
print " Required initial belt tension, T0 = %.1f N."%(T0)
```

In [21]:

```
from numpy import linalg
import math
# Variables:
d2 = 240./1000 #m
d1 = 600./1000 #m
x = 3. #m
P = 4.*1000 #W
N2 = 300. #rpm
mu = 0.3
T1s = 10. #Safe working tension N/mm width
#Solution:
#Minimum width of the belt:
#Calculating the velocity of the belt
v = math.pi*d2*N2/60 #m/s
#Calculating the angle alpha for an open belt drive
alpha = math.sin((d1-d2)/(2*x))*180/math.pi #degrees
#Calculating the angle of lap on the smaller pulley
theta = (180-2*alpha)*math.pi/180 #radians
#Calculating the tensions in the belt
#Power transmitted P = (T1-T2)*v or T1-T2 = P/v
#Ratio of tensions math.log(T1/T2) = mu*theta or T1-T2*math.exp(mu*theta) = 0
A = [[1, -1],[ 1, -math.exp(mu*theta)]]
B = [P/v, 0]
V = linalg.solve(A, B)
T1 = V[0] #N
T2 = V[1] #N
#Calculating the minimum width of the belt
b = T1/T1s #mm
#Calculating the initial belt tension
T0 = (T1+T2)/2 #N
#Calculating the length of the belt required
L = math.pi/2*(d1+d2)+2*x+(d1-d2)**2/(4*x) #m
#Results:
print " Minimum width of the belt, b = %.1f mm."%(b)
print " Initial belt tension, T0 = %.1f N."%(T0)
print " Length of the belt required, L = %.2f m."%(L)
```

In [6]:

```
from numpy import linalg
import math
# Variables:
d1 = 400./1000 #m
d2 = 250./1000 #m
x = 2.
mu = 0.4 #m
T = 1200. #N
v = 10. #m/s
#Solution:
#Power transmitted:
#Calculating the angle alpha for an open belt drive
alpha = math.sin((d1-d2)/(2*x))*180/math.pi #degrees
#Calculating the angle of contact
theta = (180-2*alpha)*math.pi/180 #radians
#Calculating the tension in the tight side of the belt
T1 = T #Neglecting centrifugal tension N
#Calculating the tension in the slack side of the belt
T2 = T1/math.exp(mu*theta) #N
#Calculating the power transmitted
P = (T1-T2)*v/1000 #kW
#Results:
print " Power transmitted, P = %.2f kW."%(P)
#Power transmitted when initial tension is increased by 10%:
#Calculating the initial tension
T0 = (T1+T2)/2 #N
#Calculating the increased initial tension
T0dash = T0+10./100*T0 #N
#Calculating the corresponding tensions in the belt
#We have T0dash = (T1+T2)/2 or T1+T2 = 2*T0dash
#Ratio of the tensions math.log(T1/T2) = mu*theta or T1-T2*math.exp(mu*theta) = 0
A = [[1, 1],[ 1, -math.exp(mu*theta)]]
B = [2*T0dash, 0]
V = linalg.solve(A,B)
T1 = V[0] #N
T2 = V[1] #N
#Calculating the power transmitted
P1 = (T1-T2)*v/1000 #kW
#Power transmitted when coefficient of friction is increased by 10%:
#Calculating the increased coefficient of friction
mudash = mu+10./100*mu
#Calculating the corresponding tensions in the belt
#Ratio of the tensions math.log(T1/T2) = mudash*theta or T1-T2*math.exp(mudash*theta) = 0
#Initial tension T0 = (T1+T2)/2 or T1+T2 = 2*T0
A = [[1, -math.exp(mudash*theta)],[ 1, 1]]
B = [0, 2*T0]
V = linalg.solve(A,B)
T1 = V[0] #N
T2 = V[1] #N
#Calculating the power transmitted
P2 = (T1-T2)*v/1000 #kW
#Results:
if P1>P2:
print " Since the power transmitted by increasing the initial tension is more\
therefore in order to increase the power transmitted we shall adopt\
the method of increasing the initial tension."
else:
print " Since the power transmitted by increasing the coefficient of friction is more,\
therefore in order to increase the power transmitted we shall adopt the method of increasing\
the coefficient of friction."
#Percentage increase in power:\
#Calculating the percentage increase in power when the initial tension is increased
I1 = (P1-P)/P*100. #Percentage increase in power when the initial tension is increased %
#Calculating the percentage increase in power when coefficient of friction is increased
I2 = (P2-P)/P*100. #Percentage increase in power when coefficient of friction is increased %
#Results:
print " Percentage increase in power when the initial tension is increased = %.2f %%."%(I1)
print " Percentage increase in power when coefficient of friction is increased = %.1f %%."%(I2)
#rounding off error
```

In [25]:

```
import math
# Variables:
beta = 30./2 #degrees
alpha = 750.*10**-6 #mm**2
mu = 0.12
rho = 1.2*1000 #kg/m**3
sigma = 7.*10**6 #N/m**2
d = 300./1000 #m
N = 1500. #rpm
#Solution:
#Power transmitted:
#Calculating the velocity of the belt
v = math.pi*d*N/60 #m/s
#Calculating the mass of the belt per metre length
l = 1 #m
m = alpha*l*rho #kg/m
#Calculating the centrifugal tension
TC = m*v**2 #N
#Calculating the maximum tension in the belt
T = sigma*alpha #N
#Calculating the tension in the tight side of the belt
T1 = T-TC #N
#Calculating the tension in the slack side of the belt
theta = math.pi #Angle of contact radians
T2 = T1/math.exp(mu*theta*(1/math.sin(math.radians(beta)))) #N
#Calculating the power transmitted
P = (T1-T2)*v*2/1000 #kW
#Shaft speed:
#Calculating the belt speed for maximum power transmitted
v1 = math.sqrt(T/(3*m)) #m/s
#Calculating the shaft speed for maximum power transmitted
N1 = v1*60/(math.pi*d) #rpm
#Results:
print " Power transmitted, P = %.3f kW."%(P)
print " Shaft speed at which the power transmitted would be maximum, N1 = %d rpm."%(N1)
```

In [28]:

```
import math
# Variables:
beta = 30./2 #degrees
t = 20./1000
b = 20./1000 #m
m = 0.35 #kg/m
sigma = 1.4*10**6 #N/m**2
theta = 140.*math.pi/180 #radians
mu = 0.15
#Solution:
#Calculating the maximum tension in the belt
T = sigma*b*t #N
#Calculating the velocity of the belt for maximum power to be transmitted
v = math.sqrt(T/(3*m)) #m/s
#Calculating the centrifugal tension
TC = T/3 #N
#Calculating the tension in the tight side of the belt
T1 = T-TC #N
#Calculating the tension in the slack side of the belt
T2 = T1/math.exp(mu*theta*(1/math.sin(math.radians(beta)))) #N
#Calculating the maximum power transmitted
P = (T1-T2)*v/1000 #kW
#Results:
print " Maximum power transmitted, P = %.2f kW."%(P)
```

In [17]:

```
import math
# Variables:
P = 90. #kW
N2 = 250.
N1 = 750. #rpm
d2 = 1.
x = 1.75 #m
v = 1600./60 #m/s
a = 375.*10**-6 #m**2
rho = 1000. #kg/m**3
sigma = 2.5*10**6 #N/m**2
beta = 35./2 #degrees
mu = 0.25
#Solution:
#Calculating the diameter of the pulley on the motor shaft
d1 = d2*(N2/N1) #m
#Calculating the mass of the belt per metre length
l = 1 #m
m = a*l*rho #kg/m
#Calculating the centrifugal tension
TC = m*v**2 #N
#Calculating the maximum tension in the belt
T = sigma*a #N
#Calculating the tension in the tight side of the belt
T1 = T-TC #N
#Refer Fig. 11.21
#Calculating the angle alpha
alpha = math.sin(math.radians((d2-d1)/(2*x)))*180/math.pi #degrees
#Calculating the angle of lap on smaller pulley
theta = (180-2*alpha)*math.pi/180 #radians
#Calculating the tension in the slack side of the belt
T2 = T1/math.exp(mu*theta*(1/math.sin(math.radians(beta)))) #N
#Number of V-belts:
#Calculating the power transmitted per belt
P1 = (T1-T2)*v/1000 #Power transmitted per belt kW
#Calculating the number of V-belts
n = P/16.086 #Number of V-belts
#Calculating the length each of belt for an open belt drive
L = math.pi/2*(d2+d1)+2*x+(d2-d1)**2/(4*x) #m
#Results:
print " Number of V-belts = %.f."%(n)
print " Length of each belt, L = %.2f m."%(L)
```

In [18]:

```
import math
# Variables:
P = 600. #kW
d = 4. #m
N = 90. #rpm
theta = 160.*math.pi/180 #radians
beta = 45./2 #degrees
mu = 0.28
m = 1.5 #kg/m
T = 2400. #N
#Solution:
#Calculating the velocity of the rope
v = math.pi*d*N/60 #m/s
#Calculating the centrifugal tension
TC = m*v**2 #N
#Calculating the tension in the tight side of the rope
T1 = T-TC #N
#Calculating the tension in the slack side of the belt
T2 = T1/math.exp(mu*theta*(1/math.sin(math.radians(beta)))) #N
#Calculating the power transmitted per rope
P1 = (T1-T2)*v/1000 #Power transmitted per rope kW
#Calculating the number of ropes
n = P/P1 #Number of ropes
#Results:
print " Number of ropes required = %d."%(n+1)
```

In [32]:

```
import math
# Variables:
d = 3.6 #m
n = 15. #Number of grooves
beta = 45./2 #degrees
theta = 170.*math.pi/180 #radians
mu = 0.28
T = 960. #N
m = 1.5 #kg/m
#Solution:
#Speed of the pulley:
#Calculating the velocity of the rope
v = math.sqrt(T/(3*m)) #m/s
#Calculating the speed of the pulley
N = v*60/(math.pi*d) #rpm
#Power transmitted
#Calculating the centrifugal tension for maximum power
TC = T/3 #N
#Calculating the tension in the tight side of the rope
T1 = T-TC #N
#Calculating the tension in the slack side of the rope
T2 = T1/math.exp(mu*theta*(1/math.sin(math.radians(beta)))) #N
#Calculating the power transmitted per rope
P1 = (T1-T2)*v/1000 #Power transmitted per rope kW
#Calculating the total power transmitted
P = P1*n #Total power transmitted kW
#Results:
print " Speed of the pulley for maximum power, N = %.1f rpm."%(N)
print " Power transmitted = %.2f kW."%(P)
```

In [20]:

```
from numpy import linalg
import math
# Variables:
PT = 24. #kW
d = 400./1000 #m
N = 110. #rpm
beta = 45./2 #degrees
theta = 160.*math.pi/180 #radians
mu = 0.28
n = 10.
#Solution:
#Initial tension:
#Calculating the power transmitted per rope
P = PT/n*1000 #W
#Calculating the velocity of the rope
v = math.pi*d*N/60 #m/s
#Calculating the tensions in the rope
#Power transmitted P = (T1-T2)*v or T1-T2 = P/v
#Ratio of tensions math.log(T1/T2) = mu*theta*(1/math.sin(math.radians(beta)) or T1-T2*math.exp(mu*theta*(1/math.math.sin(math.radians(beta))) = 0
A = [[1, -1],[ 1, -math.exp(mu*theta*(1/math.sin(math.radians(beta))))]]
B = [P/v, 0]
V = linalg.solve(A,B)
T1 = V[0] #N
T2 = V[1] #N
#Calculating the initial tension in each rope
T0 = (T1+T2)/2 #N
#Diameter of each rope:
#Calculating the girth of rope
C = math.sqrt(T1/(122.*10**3-53.*v**2))*1000 #mm
#Calculating the diameter of each rope
d1 = C/math.pi #mm
#Results:
print " Initial tension, T0 = %.2f N."%(T0)
print " Diameter of each rope, d1 = %.2f mm."%(d1)
# rounding off error
```

In [23]:

```
import math
# Variables:
N1 = 240. #rpm
N2 = 120. #rpm
T1 = 20.
d2 = 600./1000 #m
r2 = d2/2 #m
x = 800./1000 #m
#SOlution:
#Calculating the number of teeth on the drive sprocket
T2 = T1*(N1/N2)
#Calculating the pitch of the chain
p = r2*2*math.sin(math.radians(180/T2))*1000 #mm
#Length of the chain:
m = x*1000/p
#Calculating the multiplying factor
K = (T1+T2)/2+2*m+(1/math.sin(math.radians(180/T1))-1/math.sin(math.radians(180/T2)))**2/(4*m)
#Calculating the length of the chain
L = p*K/1000 #m
#Results:
print " Number of teeth on the driven sprocket, T2 = %d."%(T2)
print " Pitch of the chain, p = %.1f mm."%(p)
print " Length of the chain, L = %.4f m."%(L)
# rounding off error
```