In [4]:

```
import math
from numpy import linalg
# Variables:
theta = 30. #degrees
P1 = 180. #Pulling force N
P2 = 220. #Pushing force N
#Solution:
#Resolving the forces horizontally for the pull of 180N
F1 = P1*math.cos(math.radians(theta)) #N
#Resolving the forces for the push of 220 N
F2 = P2*math.cos(math.radians(theta)) #N
#Calculating the coefficient of friction
#For the pull of 180N F1 = mu*W-90*mu or F1/mu-W = -90 .....(i)
#For the push of 220N F2 = W*mu+110*mu or F2/mu-W = 110 .....(ii)
A = [[F1, -1],[ F2, -1]]
B = [-90., 110.]
V = linalg.solve(A, B)
mu = 1/V[0]
W = V[1]
#Results:
print " The weight of the body, W = %d N."%(round(W,-2))
print " The coefficient of friction, mu = %.4f."%(mu)
# note : rounding off error
```

In [2]:

```
import math
from numpy import linalg
# Variables:
P1 = 1500.
P2 = 1720. #N
alpha1 = 12.
alpha2 = 15. #degrees
#Solution:
#Refer Fig. 10.10
#Effort applied parallel to the plane P1 = W*(math.sin(alpha1)+mu*math.cos(alpha1)) or P1/W-mu*math.cos(alpha1) = math.sin(alpha1) .....(i)
#Effort applied parallel to the plane P2 = W*(math.sin(alpha2)+mu*math.cos(alpha2)) or P2/W-mu*math.cos(alpha2) = math.sin(alpha2) .....(ii)
A = [[P1, -math.cos(math.radians(alpha1))],[ P2, -math.cos(math.radians(alpha2))]]
B = [math.sin(math.radians(alpha1)), math.sin(math.radians(alpha2))]
V = linalg.solve(A, B)
W = 1.0/V[0]
mu = V[1]
#Results:
print " Coefficient of friction, mu = %.3f."%(mu)
print " Weight of the body, W = %d N."%(W)
```

In [4]:

```
import math
# Variables:
W = 75.*1000 #W
v = 300. #mm/min
p = 6.
d0 = 40. #mm
mu = 0.1
#Solution:
#Calculating the mean diameter of the screw
d = (d0-p/2)/1000 #m
#Calculating the helix angle
alpha = math.tan(p/(math.pi*d*1000)) #radians
#Calculating the force required at the circumference of the screw
phi = math.tan(mu) #Limiting angle of friction radians
P = W*math.tan(alpha+phi) #N
#Calculating the torque required to overcome the friction
T = P*d/2 #N-m
#Calculating the speed of the screw
N = v/p #rpm
#Calculating the angular speed
omega = round(2*math.pi*N/60,2) #rad/s
#Calculating the power of the motor
Power = T*omega/1000 #Power of the motor kW
#Results:
print " Power of the motor required = %.3f kW."%(Power)
# rounding off error
```

In [7]:

```
import math
# Variables:
p = 12.
d = 40. #mm
mu = 0.16
W = 2500. #N
#Solutiom:
#Work done in drawing the wagons together agianst a steady load of 2500 N:
#Calculating the helix angle
alpha = math.tan(p/(math.pi*d)) #radians
#Calculating the effort required at the circumference of the screw
phi = math.tan(mu) #Limiting angle of friction radians
P = W*math.tan(alpha+phi) #N
#Calculating the torque required to overcome friction between the screw and nut
T = P*d/(2*1000) #N-m
#Calculating the number of turns required
N = 240/(2*p)
#Calculating the work done
W1 = T*2*math.pi*N #Work done N-m
#Work done in drawing the wagons together when the load increases from 2500 N to 6000 N:
W2 = W1*(6000.-2500)/2500.0 #Work done N-m
#Results:
print " Work done in drawing the wagons together agianst a steady load of 2500 N = %.1f N-m."%(W1)
print " Work done in drawing the wagons together when the load increases from 2500 N to 6000 N = %.1f N-m."%(W2)
# note : answer in book is wrong.
```

In [3]:

```
import math
# Variables:
D = 150./1000 #m
ps = 2.*10**6 #N/m**2
d0 = 50.
p = 6. #mm
mu = 0.12
#Solution:
#Calculating the load on the valve
W = ps*math.pi/4*D**2 #N
#Calculating the mean diameter of the screw
d = (d0-p/2)/1000 #m
#Calculating the helix angle
alpha = math.tan(p/(math.pi*d*1000))
#Calculating the force required to turn the handle
phi = math.tan(mu) #Limiting angle of friction radians
P = W*math.tan(alpha+phi) #N
#Calculating the torque required to turn the handle
T = P*d/2 #N-m
#Results:
print " The torque required to turn the handle, T = %.1f N-m."%(T)
# rounding off error
```

In [8]:

```
import math
# Variables:
dc = 22.5 #mm
p = 5. #mm
D = 50. #mm
R = D/2 #mm
l = 500. #mm
mu = 0.1
mu1 = 0.16
W = 10.*1000 #N
#Solution:
#Calculating the mean diameter of the screw
d = dc+p/2 #mm
#Calculating the helix angle
alpha = p/(math.pi*d) #radians
#Calculating the force required at the circumference of the screw
phi = math.tan(mu) #Limiting angle of friction radians
P = W*math.tan(alpha+phi) #N
#Calculating the total torque required
T = P*d/2+mu1*W*R #N-mm
#Calculating the force required at the end of a spanner
P1 = T/l #N
#Results:
print " Force required at the end of a spanner, P1 = %.2f N."%(P1)
```

In [10]:

```
import math
# Variables:
d = 50. #mm
p = 12.5 #mm
D = 60. #mm
R = D/2 #mm
W = 10.*1000 #N
P1 = 100. #N
mu = 0.15
mu1 = 0.18
#Solution:
#Calculating the helix angle
alpha = math.tan(p/(math.pi*d)) #radians
#Calculating the math.tangential force required at the circumference of the screw
phi = math.tan(mu) #Limiting angle of friction radians
P = W*math.tan(alpha+phi) #N
#Calculating the total torque required to turn the hand wheel
T = P*d/2+mu1*W*R #N-mm
#Calculating the diameter of the hand wheel
D1 = T/(2*P1*1000)*2 #m
#Results:
print " Diameter of the hand wheel, D1 = %.3f m."%(D1)
```

In [11]:

```
import math
# Variables:
d0 = 55. #mm
D2 = 60. #mm
R2 = D2/2 #mm
D1 = 90. #mm
R1 = D1/2 #mm
p = 10./1000 #m
W = 400. #N
mu = 0.15
v = 6. #Cutting speed m/min
#Solution:
#Calculating the mean diameter of the screw
d = d0-p/2 #mm
#Calculating the helix angle
alpha = p/(math.pi*d) #radians
#Calculating the force required at the circumference of the screw
phi = math.tan(mu) #Limiting angle of friction radians
P = W*math.tan(alpha+phi) #N
#Calculating the mean radius of the flat surface
R = (R1+R2)/2 #mm
#Calculating the torque required
T = (P*d/2+mu1*W*R)/1000 #N-m
#Calculating the speed of the screw
N = v/p #rpm
#Calculating the angular speed
omega = 2*math.pi*N/60 #rad/s
#Calculating the power required to operate the nut
Power = T*omega/1000 #Power required to operate the nut kW
#Results:
print " Power required to operate the nut = %.3f kW."%(Power)
```

In [12]:

```
import math
# Variables:
d = 50./1000
l = 0.7 #m
p = 10. #mm
mu = 0.15
W = 20.*1000 #N
#Solution:
#Calculating the helix angle
alpha = math.tan(p/(math.pi*d*1000)) #radians
#Force required to raise the load:
#Calculating the force required at the circumference of the screw
phi = math.tan(mu) #Limiting angle of friction radians
P1 = W*math.tan(alpha+phi) #N
#Calculating the force required at the end of the lever
P11 = P1*d/(2*l) #N
#Calculating the force required at the circumference of the screw
P2 = W*(phi-alpha) #N
#Foce rewuired to lower the load:
#Calculating the force required at the end of the lever
P21 = P2*d/(2*l) #N
#Results:
print " Force required at the end of the lever to raise the load, P1 = %d N."%(P11)
print " Force required at the end of the lever to lower the load, P1 = %d N."%(P21)
```

In [14]:

```
import math
# Variables:
d = 50.
p = 12.5 #mm
mu = 0.13
W = 25.*1000 #N
#Solution:
#Calculating the helix angle
alpha = round(math.tan(p/(math.pi*d)),2) #radians
#Calculating the force required on the screw to raise the load
phi = round(math.tan(mu),2) #Limiting angle of friction radians
P1 = W*(alpha+phi)/(1-(alpha*phi)) #N
#Calculating the torque required on the screw to raise the load
T1 = P1*d/2 #N-mm
#Calculating the force required on the screw to lower the load
P2 = W*math.tan(phi-alpha) #N
#Calculating the torque required to lower the load
T2 = P2*d/2 #N
#Calculating the ratio of the torques required
r = T1/T2 #Ratio of the torques required N-mm
#Calculating the efficiency of the machine
eta = math.tan(alpha)/math.tan(alpha+phi)*100 #%
#Results:
print " Torque required on the screw to raise the load, T1 = %d N-mm."%(T1)
print " Ratio of the torque required to raise the load to the torque required to lower the load = %.1f."%(r)
print " Efficiency of the machine, eta = %.1f %%."%(eta)
# rounding off error
```

In [24]:

```
import math
# Variables:
p = 10. #mm
d = 50. #mm
D2 = 60. #mm
R2 = D2/2 #mm
D1 = 10. #mm
R1 = D1/2 #mm
W = 20.*1000 #N
mu = 0.08
mu1 = mu
#Solution:
#Calculating the helix angle
alpha = round(math.tan(p/(math.pi*d)),4) #radians
#Calculating the force required at the circumference of the screw to lift the load
phi = round(math.tan(mu),2) #Limiting angle of friction radians
P = round(W*(alpha+phi)/(1 - (alpha*phi)),-1) #math.tan(alpha+phi) #N
#Calculating the torque required to overcome friction at the screw
T = P*d/(2*1000) #N-m
#Calculating the number of rotations made by the screw
N = 170/p
#When the load rotates with the screw:
#Calculating the work done in lifting the load
W1 = T*2*math.pi*N #Work done in lifting the load N-m
#Calculating the efficiency of the screw jack
eta1 = math.tan(alpha)/math.tan(alpha+phi)*100 #%
#When the load does not rotate with the screw:
#Calculating the mean radius of the bearing surface
R = (R1+R2)/2 #mm
#Calculating the torque required to overcome friction at the screw and the collar
T = (P*d/2+mu1*W*R)/1000 #N-m
#Calculating the work done by the torque in lifting the load
W2 = T*2*math.pi*N #Work done by the torque in lifting the load N-m
#Calculating the torque required to lift the load neglecting frition
T0 = (W*math.tan(alpha)*d/2)/1000 #N-m
#Calculating the efficiency of the screw jack
eta2 = T0/T*100 #%
#Results:
print " When the load rotates with the screw, work done in lifting the load = %.f N-m."%(W1)
print " Efficiency of the screw jack, eta = %.1f %%."%(eta1)
print " When the load does not rotate with the screw, work done in lifting the load = %d N-m."%(round(W2,-1))
print " Efficiency of the screw jack, eta = %.1f %%."%(eta2)
# rounding off error
```

In [17]:

```
import math
# Variables:
W = 10.*1000 #N
P1 = 100. #N
p = 12. #mm
d = 50. #mm
mu = 0.15
#Solution:
#Calculating the helix angle
alpha = math.tan(p/(math.pi*d)) #radians
#Calculating the effort required at the circumference of the screw to raise the load
phi = math.tan(mu) #Limiting angle of friction radians
P = W*math.tan(alpha+phi) #N
#Calculating the torque required to overcome friction
T = P*d/2 #N-mm
#Calculating the length of the lever
l = T/P1 #mm
#Calculating the mechanical advantage
MA = W/P1
#Calculating the efficiency of the screw jack
eta = math.tan(alpha)/math.tan(alpha+phi)*100 #%
#Results:
print " The length of the lever to be used, l = %.1f mm."%(l)
print " Mechanical advantage obtained, M.A. = %d."%(MA)
if eta<50:
print " The screw is a self locking screw.";
else:
print " The screw is not a self locking screw.";
```

In [1]:

```
import math
# Variables:
d = 22. #mm
p = 3. #mm
beta = 60./2 #degrees
W = 40.*1000 #N
mu = 0.15
#Solution:
#Calculating the helix angle
alpha = round(math.tan(p/(math.pi*d)),4) #radians
#Calculating the virtual coefficient of friction
mu1 = round(mu/math.cos(math.radians(beta)),3)
#Calculating the force required at the circumference of the screw
P = W*((alpha+mu1)/(1 - alpha * mu1))
#Calculating the torque on one rod
T = P*d/(2.*1000) #N-m
#Calculating the torque required on the nut
T1 = 2*T #N-m
#Results:
print " The torque required on the nut, T1 = %.2f N-m."%(T1)
```

In [16]:

```
import math
# Variables:
d = 25. #mm
p = 5. #mm
R = 25. #mm
beta = 27.5 #degrees
mu = 0.1
mu2 = 0.16
l = 0.5 #m
W = 10.*1000 #N
#Solution:
#Calculating the virtual coefficient of friction
mu1 = mu/math.cos(math.radians(beta))
#Calculating the helix angle
alpha = math.tan(p/(math.pi*d)) #radians
#Calculating the force on the screw
phi1 = math.tan(mu1) #Virtual limiting angle of frcition radians
P = W*math.tan(alpha+phi1) #N
#Calculating the total torque transmitted
T = (P*d/2+mu2*W*R)/1000 #N-m
#Calculating the force required at the end of a spanner
P1 = T/l #N
#Results:
print " Force required at the end of a spanner, P1 = %.1f N."%(P1)
```

In [20]:

```
import math
# Variables:
d = 60.
r = d/2. #mm
W = 2000. #N
mu = 0.03
N = 1440. #rpm
#Solution:
#Calculating the angular speed of the shaft
omega = 2*math.pi*N/60 #rad/s
#Calculating the torque transmitted
T = mu*W*(r/1000) #N-m
#Calculating the power transmitted
P = T*omega #W
#Results:
print " The power transmitted, P = %.1f W."%(P)
```

In [21]:

```
import math
# Variables:
D = 150./1000 #m
R = D/2 #m
N = 100. #rpm
W = 20.*1000 #N
mu = 0.05
#Solution:
#Calculating the angular speed of the shaft
omega = 2*math.pi*N/60 #rad/s
#Calculating the total frictional torque for uniform pressure distribution
T = 2./3*mu*W*R #N-m
#Calculating the power lost in friction
P = T*omega #W
#Results:
print " Power lost in friction, P = %.1f W."%(P)
```

In [27]:

```
import math
# Variables:
W = 20.*1000 #N
alpha = 120./2 #degrees
Pn = 0.3 #N/mm**2
N = 200. #rpm
mu = 0.1
#Solution:
#Calculating the angular speed of the shaft
omega = 2*math.pi*N/60 #rad/s
#Calculating the inner radius of the bearing surface
r2 = math.sqrt(W/(3*math.pi*Pn)) #mm
#Calculating the outer radius of the bearing surface
r1 = 2*r2 #mm
#Calculating the total frictional torque assuming uniform pressure
T = 2./3*mu*W*(1/math.sin(math.radians(alpha)))*(r1**3-r2**3)/(r1**2-r2**2)/1000.0 #N-m
#Calculating the power absorbed in friction
P = T*omega/1000.0 #kW
#Results:
print "External Diameters r1= %.f mm"%r1
print "Internal Diameters r2= %.f mm"%r2
print " Power absorbed in friction, P = %.3f kW."%(P)
```

In [19]:

```
import math
# Variables:
D = 200./1000
R = D/2 #m
W = 30.*1000 #N
alpha = 120./2 #degrees
mu = 0.025
N = 140. #rpm
#Solution:
#Calculating the angular speed of the shaft
omega = 2*math.pi*N/60 #rad/s
#Power lost in friction assuming uniform pressure:
#Calculating the total frictional torque
T = 2./3*mu*W*R*(1/math.sin(math.radians(alpha))) #N-m
#Calculating the power lost in friction
P1 = T*omega #Power lost in friction W
#Power lost in friction assuming uniform wear:
#Calculating the total frictional torque
T = 1./2*mu*W*R*(1./math.sin(math.radians(alpha))) #N-m
#Calculating the power lost in friction
P2 = T*omega #Power lost in friction W
#Resluts:
print " Power lost in friction assuming uniform pressure, P = %d W."%(P1)
print " Power lost in friction assuming uniform wear, P = %.1f W."%(P2)
```

In [21]:

```
import math
# Variables:
n = 6.
d1 = 600. #mm
r1 = d1/2 #mm
d2 = 300. #mm
r2 = d2/2 #mm
W = 100.*1000 #N
mu = 0.12
N = 90. #rpm
#Solution:
#Calculating the angular speed of the engine
omega = 2*math.pi*N/60.0 #rad/s
#Power absorbed in friction assuming uniform pressure:
#Calculating the total frictional torque transmitted
T = 2./3*mu*W*(r1**3-r2**3)/(r1**2-r2**2)/1000.0 #N-m
#Calculating the power absorbed in friction
P1 = T*omega/1000.0 #Power absorbed in friction assuming uniform pressure kW
#Power absorbed in friction assuming uniform wear:
#Calculating the total frictional torque transmitted
T = 1./2*mu*W*(r1+r2)/1000.0 #N-m
#Calculating the power absorbed in friction
P2 = T*omega/1000.0 #Power absorbed in friction assuming uniform wear kW
#Results:
print " Power absorbed in friction assuming uniform pressure, P = %.1f kW."%(P1)
print " Power absorbed in friction assuming uniform wear, P = %.2f kW."%(P2)
```

In [27]:

```
import math
# Variables:
d1 = 400. #mm
r1 = d1/2 #mm
d2 = 250. #mm
r2 = d2/2 #mm
p = 0.35 #N/mm**2
mu = 0.05
N = 105. #rpm
W = 150.*1000 #N
#Solution:
#Calculating the angular speed of the shaft
omega = 2*math.pi*N/60 #rad/s
#Calculating the total frictional torque transmitted for uniform pressure
T = 2./3*mu*W*(r1**3-r2**3)/(r1**2-r2**2)/1000 #N-m
#Calculating the power absorbed
P = T*omega/1000 #kW
#Calculating the number of collars required
n = W/(p*math.pi*(r1**2-r2**2))
#Results:
print " Power absorbed, P = %.2f kW."%(P)
print " Number of collars required, n = %d."%(n+1)
```

In [28]:

```
import math
# Variables:
d2 = 300./1000 #mm
r2 = d2/2 #m
W = 200.*1000 #N
N = 75. #rpm
mu = 0.05
p = 0.3 #N/mm**2
P = 16.*1000 #W
#Solution:
#Calculating the angular velocity of the shaft
omega = 2*math.pi*N/60 #rad/s
#Calculating the total frictional torque transmitted
T = P/omega #N-m
#Calculating the external diameter of the collar
#We have T = 2/3*mu*W*(r1**3-r2**3)/(r1**2-r2**2) or (2*mu*W)*r1**2-(3*T-2*mu*W*r2)*r1+(2*mu*W*r2**2-3*T*r2) = 0
A = 2*mu*W
B = -(3*T-2*mu*W*r2)
C = 2*mu*W*r2**2-3*T*r2
r1 = (-B+math.sqrt(B**2-4*A*C))/(2*A)*1000 #mm
d1 = 2*r1 #mm
#Calculating the number of collars
n = W/(p*math.pi*(r1**2-(r2*1000)**2))
#Results:
print " External diameter of the collar, d1 = %d mm."%(d1)
print " Number of collars, n = %d."%(n+1)
```

In [29]:

```
import math
# Variables:
W = 4.*1000 #N
r2 = 50.
r1 = 100. #mm
#Solution:
#Calculating the maximum pressure
pmax = W/(2*math.pi*r2*(r1-r2)) #N/mm**2
#Calculating the minimum pressure
pmin = W/(2*math.pi*r1*(r1-r2)) #N/mm**2
#Calculating the average pressure
pav = W/(math.pi*(r1**2-r2**2)) #N/mm**2
#Results:
print " Maximum pressure, pmax = %.4f N/mm**2."%(pmax)
print " Minimum pressure, pmin = %.4f N/mm**2."%(pmin)
print " Average pressure, pav = %.2f N/mm**2."%(pav)
```

In [30]:

```
import math
# Variables:
d1 = 300. #mm
r1 = d1/2 #mm
d2 = 200. #mm
r2 = d2/2 #mm
p = 0.1 #N/mm**2
mu = 0.3
N = 2500. #rpm
n = 2.
#Solution:
#Calculating the radial speed of the clutch
omega = 2*math.pi*N/60 #rad/s
#Calculating the intensity of pressure
C = p*r2 #N/mm
#Calculating the axial thrust
W = 2*math.pi*C*(r1-r2) #N
#Calculating the mean radius of the friction surfaces for uniform wear
R = (r1+r2)/(2*1000) #m
#Calculating the torque transmitted
T = n*mu*W*R #N-m
#Calculating the power transmitted by a clutch
P = T*omega/1000 #kW
#Results:
print " Power transmitted by a clutch, P = %.3f kW."%(P)
```

In [26]:

```
import math
# Variables:
n = 2.
mu = 0.255
P = 25.*1000 #W
N = 3000. #rpm
r = 1.25 #Ratio of radii r1/r2
p = 0.1 #N/mm**2
#Solution:
#Calculating the angular speed of the clutch
omega = 2*math.pi*N/60 #rad/s
#Calculating the torque transmitted
T = P/omega*1000 #N-mm
#Calculating the inner radius
r2 = (T/(n*mu*2*math.pi*0.1*(1.25-1)*(1.25+1)/2))**(1./3) #mm
#Calculating the outer radius
r1 = r*r2 #mm
#Calculating the axial thrust to be provided by springs
C = 0.1*r2 #Intensity of pressure N/mm
W = 2*math.pi*C*(r1-r2) #N
#Results:
print " Outer radius of the frictional surface, r1 = %.f mm."%(r1)
print " Inner radius of the frictional surface, r2 = %.f mm."%(r2)
print " Axial thrust to be provided by springs, W = %.f N."%(W)
# rounding off error
```

In [28]:

```
from numpy import linalg
import math
# Variables:
P = 7.5*1000 #W
N = 900. #rpm
p = 0.07 #N/mm**2
mu = 0.25
n = 2.
#Solution:
#Calculating the angular speed of the clutch
omega = 2*math.pi*N/60 #rad/s
#Calculating the torque transmitted
T = P/omega*1000 #N-mm
#Calculating the mean radius of the friction lining
R = (T/(math.pi/2*n*mu*p))**(1./3) #mm
#Calculating the face width of the friction lining
w = R/4 #mm
#Calculating the outer and inner radii of the clutch plate
#We have w = r1-r2 or r1-r2 = w .....(i)
#Also R = (r1+r2)/2 or r1+r2 = 2*R .....(ii)
A = [[1, -1],[ 1, 1]]
B = [w,2*R]
V = linalg.solve(A,B)
r1 = V[0]
r2 = V[1]
#Results:
print " Mean radius of the friction lining, R = %d mm."%(R)
print " Face width of the friction lining, w = %.2f mm."%(w)
print " Outer radius of the clutch plate, r1 = %.3f mm."%(r1)
print " Inner radius of the clutch plate, r2 = %.3f mm."%(r2)
# rounding off error
```

In [33]:

```
import math
# Variables:
P = 100. #kW
N = 2400. #rpm
T = 500.*1000 #N-mm
p = 0.07 #N/mm**2
mu = 0.3
Ns = 8. #Number of springs
k = 40. #Stiffness N/mm
n = 2.
#Solution:
#Calculating the inner radius of the friction plate
r2 = round((T/(n*mu*2*math.pi*p*(1.25-1)*(1.25+1)/2))**(1./3),-1) #mm
#Calculating the outer radius of the friction plate
r1 = 1.25*r2 #mm
#Calculating the total stiffness of the springs
s = k*Ns #N/mm
#Calculating the intensity of pressure
C = p*r2 #N/mm
#Calculating the axial force required to engage the clutch
W = 2*math.pi*C*(r1-r2) #N
#Calculating the initial compression in the springs
IC = W/s #Initial compression in the springs mm
#Results:
print " Outer radius of the friction plate, r1 = %.1f mm."%(r1)
print " Inner radius of the friction plate, r2 = %.f mm."%(r2)
print " Initial compression in the springs = %.1f mm."%(IC)
# book answer is wrong.
```

In [37]:

```
import math
from numpy import linalg
# Variables:
d1 = 220. #mm
r1 = d1/2 #mm
d2 = 160. #mm
r2 = d2/2 #mm
W = 570. #N
m1 = 800. #kg
m2 = 1300. #kg
k1 = 200./1000 #m
k2 = 180./1000 #m
mu = 0.35
N1 = 1250. #rpm
n = 2.
#Solution:
#Calculating the initial angular speed of the motor shaft
omega1 = 2*math.pi*N1/60 #rad/s
#Calculating the moment of inertia for the motor armature and shaft
I1 = m1*k1**2 #kg-m**2
#Calculating the moment of inertia for the rotor
I2 = m2*k2**2 #kg-m**2
#Calculating the final speed of the motor and rotor
omega2 = 0
omega3 = (I1*omega1+I2*omega2)/(I1+I2) #rad/s
#Calculating the mean radius of the friction plate
R = (r1+r2)/(2*1000) #m
#Calculating the frictional torque
T = n*mu*W*R #N-m
#Calculating the angular acceleration of the rotor
alpha2 = T/I2 #rad/s**2
#Calculating the time to reach the speed of omega3
omegaF = omega3
omegaI = omega2
t = (omegaF-omegaI)/alpha2 #seconds
#Calculating the angular kinetic energy before impact
E1 = 1./2*I1*omega1**2+1./2*I2*omega2**2 #N-m
#Calculating the angular kinetic energy after impact
E2 = 1./2*(I1+I2)*omega3**2 #N-m
#Calculating the kinetic energy lost during the period of slipping
E = round(E1-E2,-3) #N-m
#Calculating the torque on armature shaft
T1 = -60-T #N-m
#Calculating the torque on rotor shaft
T2 = T #N-m
#Calculating the time of slipping assuming constant resisting torque:
#Considering armature shaft omega3 = omega1+alpha1*t1 or omega3-(T1/I1)*t1 = omega1 .....(i)
#Considering rotor shaft omega3 = alpha2*t1 or omega3-(T2/I2)*t1 = 0 .....(ii)
A = [[1, -T1/I1],[ 1, -T2/I2]]
B = [omega1, 0]
V = linalg.solve(A,B)
t11 = V[1] #Time of slipping assuming constant resisting torque seconds
#Calculating the time of slipping assuming constant driving torque:
#Calculating the torque on armature shaft
T1 = 60-T #N-m
t12 = (omega2-omega1)/(T1/I1-T2/I2) #Time of slipping assuming constant driving torque seconds
#Results:
print " Final speed of the motor and rotor, omega3 = %.2f rad/s."%(omega3)
print " Time to reach the speed of %.2f rad/s, t = %.1f s."%(omega3,t)
print " Kinetic energy lost during the period of slipping = %d N-m."%(E)
print " Time of slipping assuming constant resisting torque, t1 = %.1f s."%(t11)
print " Time of slipping assuming constant driving torque, t1 = %d s."%(t12)
# rounding off error.
```

In [35]:

```
import math
# Variables:
n = 4.
mu = 0.3
p = 0.127 #N/mm**2
N = 500. #rpm
r1 = 125. #mm
r2 = 75. #mm
#Solution:
#Calculating the angular speed of the clutch
omega = 2*math.pi*N/60 #rad/s
#Calculating the maximum intensity of pressure
C = p*r2 #N/mm
#Calculating the axial force required to engage the clutch
W = 2*math.pi*C*(r1-r2) #N
#Calculating the mean radius of the friction surfaces
R = (r1+r2)/(2*1000) #m
#Calculating the torque transmitted
T = n*mu*W*R #N-m
#Calculating the power transmitted
P = T*omega/1000 #kW
#Results:
print " Power transmitted, P = %.1f kW."%(P)
```

In [36]:

```
import math
# Variables:
n1 = 3.
n2 = 2.
mu = 0.3
d1 = 240. #mm
r1 = d1/2 #mm
d2 = 120. #mm
r2 = d2/2 #mm
P = 25.*1000 #W
N = 1575. #rpm
#Solution:
#Calculating the angular speed of the shaft
omega = 2*math.pi*N/60 #rad/s
#Calculating the torque transmitted
T = P/omega #N-m
#Calculating the number of pairs of friction surfaces
n = n1+n2-1
#Calculating the mean radius of friction surfaces for uniform wear
R = (r1+r2)/(2*1000) #m
#Calculating the axial force on each friction surface
W = T/(n*mu*R) #N
#Calculating the maximum axial intensity of pressure
p = W/(2*math.pi*r2*(r1-r2)) #N/mm**2
#Results:
print " Maximum axial intensity of pressure, p = %.3f N/mm**2."%(p)
```

In [37]:

```
import math
# Variables:
n1 = 3.
n2 = 2.
n = 4.
mu = 0.3
d1 = 240. #mm
r1 = d1/2 #mm
d2 = 120. #mm
r2 = d2/2 #mm
P = 25.*1000 #W
N = 1575. #rpm
#Solution:
#Calculating the angular speed of the shaft
omega = 2*math.pi*N/60 #rad/s
#Calculating the torque transmitted
T = P/omega #N-m
#Calculating the mean radius of the contact surface for uniform pressure
R = 2./3*(r1**3-r2**3)/(r1**2-r2**2)/1000 #m
#Calculating the total spring load
W1 = T/(n*mu*R) #N
#Calculating the maximum power transmitted:
# Variables:
ns = 6. #Number of springs
c = 8. #Contact surfaces of the spring
w = 1.25 #Wear on each contact surface mm
k = 13.*1000 #Stiffness of each spring N/m
#Calculating the total wear
Tw = c*w/1000 #Total wear m
#Calculating the reduction in spring force
Rs = Tw*k*ns #N
#Calculating the new axial load
W2 = W1-Rs #N
#Calculating the mean radius of the contact surfaces for uniform wear
R = (r1+r2)/(2*1000) #m
#Calculating the torque transmitted
T = n*mu*W2*R #N-m
#Calculating the maximum power transmitted
P = T*omega/1000 #kw
#Results:
print " Total spring load, W = %d N."%(W1)
print " Maximum power that can be transmitted, P = %.2f kW."%(P)
```

In [30]:

```
from numpy import linalg
import math
# Variables:
P = 90.*1000 #W
N = 1500. #rpm
alpha = 20. #degrees
mu = 0.2
D = 375.
R = D/2. #mm
pn = 0.25 #N/mm**2
#SOlution:
#Calculating the angular speed of the clutch
omega = 2*math.pi*N/60 #rad/s
#Calculating the torque transmitted
T = P*1000/156 #N-mm
#Calculating the width of the bearing surface
b = T/(2*math.pi*mu*pn*R**2) #mm
#Calculating the external and internal radii of the bearing surface
#We know that r1+r2 = 2*R and r1-r2 = b*math.sin(math.radians(alpha)
A = [[1, 1],[1, -1]]
B = [2*R, b*math.sin(math.radians(alpha))]
V = linalg.solve(A,B)
r1 = V[0] #mm
r2 = V[1] #mm
#Calculating the intensity of pressure
C = round(pn*r2,1) #N/mm
#Calculating the axial load required
W = 2*math.pi*C*(r1-r2) #N
#Results:
print " Width of the bearing surface, b = %.1f mm."%(b)
print " External radius of the bearing surface, r1 = %.1f mm."%(r1)
print " Internal radius of the bearing surface, r2 = %.1f mm."%(r2)
print " Axial load required, W = %.f N."%(W)
# rounding off error. Please check.
```

In [45]:

```
import math
# Variables:
P = 45.*1000 #W
N = 1000. #rpm
alpha = 12.5 #degrees
D = 500./1000
R = D/2 #m
mu = 0.2
pn = 0.1 #N/mm**2
#Solution:
#Calculating the angular speed of the shaft
omega = 2*math.pi*N/60 #rad/s
#Calculating the torque developed by the clutch
T = P/omega #N-m
#Calculating the normal load acting on the friction surface
Wn = T/(mu*R) #N
#Calculating the axial spring force necessary to engage the clutch
We = Wn*(math.sin(math.radians(alpha))+mu*math.cos(math.radians(alpha))) #N
#Calculating the face width required
b = Wn/(pn*2*math.pi*R*1000) #mm
#Results:
print " Axial force necessary to engage the clutch, We = %d N."%(round(We,-1))
print " Face width required, b = %.1f mm."%(b)
```

In [48]:

```
from numpy import linalg
import math
# Variables:
alpha = 30./2 #degrees
pn = 0.35 #N/mm**2
P = 22.5*1000 #W
N = 2000. #rpm
mu = 0.15
#Solution:
#Calculating the angular speed of the clutch
omega = 2*math.pi*N/60 #rad/s
#Calculating the torque transmitted by the clutch
T = P/omega*1000 #N-mm
#Calculating the mean radius of the contact surface
R = (T/(2*math.pi*mu*pn/3))**(1./3) #mm
#Calculating the face width of the contact surface
b = R/3
#Calculating the outer and inner radii of the contact surface
#Refer Fig. 10.27
#We have r1-r2 = b*math.sin(math.radians(alpha) and r1+r2 = 2*R
A = [[1, -1],[ 1, 1]]
B = [b*math.sin(math.radians(alpha)), 2*R]
V = linalg.solve(A, B)
r1 = V[0] #mm
r2 = V[1] #mm
#Results:
print " Mean radius of the contact surface, R = %d mm."%(R)
print " Outer radius of the contact surface, r1 = %.2f mm."%(r1)
print " Inner radius of the contact surface, r2 = %.2f mm."%(r2)
# rounding off error
```

In [55]:

```
import math
# Variables:
D = 75./1000 #mm
R = D/2 #m
alpha = 15 #degrees
mu = 0.3
W = 180. #N
NF = 1000. #rpm
m = 13.5 #kg
k = 150./1000 #m
#Solution:
#Calculating the angular speed of the flywheel
omegaF = 2*math.pi*NF/60 #rad/s
#Calculating the torque required to produce slipping
T = round(mu*W*R*(1/math.sin(math.radians(alpha))),1) #N-m
#Calculating the mass moment of inertia of the flywheel
IF = m*k**2 #kg-m**2
#Calculating the angular acceleration of the flywheel
alphaF = T/IF #rad/s**2
#Calculating the time required for the flywheel to attain full speed
tF = round(omegaF/alphaF,1) #seconds
#Calculating the angle turned through by the motor and flywheel in time tF
theta = 1./2*omegaF*tF #rad
#Calculating the energy lost in slipping of the clutch
E = T*theta #Energy lost in slipping of the clutch N-m
#Results:
print " Torque required to produce slipping, T = %.1f N-m."%(T)
print " Time required for the flywheel to attain full speed, tF = %.1f s."%(tF)
print " Energy lost in slipping of the clutch = %d N-m."%(E)
```

In [56]:

```
import math
# Variables:
P = 15.*1000 #W
N = 900. #rpm
n = 4.
mu = 0.25
R = 150./1000
r = 120./1000 #m
theta = 60. #degrees
p = 0.1 #N/mm**2
#Solution:
#Calculating the angular speed of the clutch
omega = 2*math.pi*N/60 #rad/s
#Calculating the speed at which the engagement begins
omega1 = 3./4*omega #rad/s
#Calculating the torque transmitted at the running speed
T = P/omega #N-m
#Calculating the mass of the shoes
m = T/(n*mu*(omega**2*r-omega1**2*r)*R) #kg
#Calculating the contact length of shoes
l = (theta*math.pi/180)*R*1000 #mm
#Calculating the centrifugal force acting on each shoe
Pc = m*omega**2*r #N
#Calculating the inward force on each shoe exerted by the spring
Ps = m*omega1**2*r #N
#Calculating the width of the shoes
b = (Pc-Ps)/(l*p) #mm
#Results:
print " Mass of the shoes, m = %.2f kg."%(m)
print " Width of the shoes, b = %.1f mm."%(b)
```

In [45]:

```
import math
# Variables:
n = 4.
mu = 0.3
c = 5.
r = 160. #mm
S = 500. #N
D = 400./1000
R = D/2 #m
m = 8. #kg
s = 50. #N/mm
N = 500. #rpm
#Solution:
#Calculating the angular speed of the clutch
omega = 2*math.pi*N/60 #rad/s
#Calculating the operating radius
r1 = (r+c)/1000 #m
#Calculating the centrifugal force on each shoe
Pc = m*omega**2*r1 #N
#Calculating the inward force exerted by the spring
Ps = S+c*s #N
#Calculating the frictional force acting math.tangentially on each shoe
F = mu*(Pc-Ps) #N
#Calculating the total frictional torque transmitted by the clutch
T = n*F*R #N-m
#Calculating the power transmitted
P = T*omega/1000 #kW
#Results:
print " Power transmitted, P = %.1f kW."%(P)
```