KIT’S College Of Engineering
(Autonomous), Kolhapur
2023-2024
STUDIO LAB (UCVC0606)
ACTIVITY NO: - 03
APPLICATION OF PYTHON LANGUAGE IN CIVIL ENGINEERING
CLASS :- T.Y (B-TECH) CIVIL –B, BATCH :- B3.
ROLL NO. NAME
LAB INCHARGE: - SUB. COORDINATOR:
CERTIFICATE
This is to certify that, following students of Semester -VI, B.Tech.(Civil
Engineering), KIT’s College of Engineering (Autonomous), Kolhapur
affiliated to Shivaji University, Kolhapur has successfully completed the lab
work connected with the Studio ab (UCVC 0606) as prescribed by the college
during the Academic year 2023-2024.
ROLL NO. NAME
Date: - / /2024
Place: - Kolhapur.
ALGORITHM FOR 1st PROBLEM
STEP 1 :- Start.
STEP 2:- Create a class named RailTrack to handle rail track calculations.
And initialize their parameter such as length , Rail length & Sleeper distance
etc.
STEP 3:- Define methods to calculate the number of rails , sleepers & Fish
Bolts .
Calculate the number of rails by -
(Total length of track / length of rail )*2
Calculate the number of sleepers by -
(Total length of Track / length of each sleeper) + 1
Calculate the number of fish bolts by –
(Number of sleepers * 2)
STEP 4:- Prompt the user to input the length of the track ,length of each rail
& distance between each sleeper
STEP 5:- Create an instance of the RailTrack class with the provided user
inputs. Call the methods to calculate rail, sleepers & fish bolts.
STEP 6:- Print the calculated number of rails, sleepers & fish bolts to the user
STEP 7:- Stop.
ALGORITHM FOR 2nd PROBLEM
STEP 1 :- Start.
STEP 2:- Read inputs
Total Unit weight of soil.
Specific gravity of soil.
Water content of soil
STEP 3:-Define methods to calculate Dry Unit weight & porosity.
a) Dry unit weight :
(Total unit wt.- (water content * Total unit weight ))
b) Porosity :
(Specific Gravity – 1)/ specific gravity
STEP 4:-Define methods to calculate void ratio & Degree of saturation
a) Void Ratio :
Porosity /(1- porosity )
b) Degree of saturation :
(water content * specific gravity ) / ((specific gravity– 1)*(1- porosity))
STEP 5:-Output print calculated properties
Dry unit weight
Porosity
Void ratio
Degree of Saturation
STEP 6:-Stop.s
ALGORITHM FOR 3rd PROBLEM
STEP 1 :- Start.
STEP 2:-Read inputs
Bottom width
Side slope
Discharge
Chezy’s constant
STEP 3:-Create an instance of the Trapezoidal Channel class with the
input parameters.
STEP 4:-Define methods to calculate radius & Chezy’s velocity of
trapezoidal channel
a) Radius : (Bottom width + side Slope *2)/(2*side slope)
b) Chezy’s velocity : Chezy’s constant * √Radius
STEP 5:-Define methods to calculate bed slope of trapezoidal channel :
(Chezy’s velocity * 2 ) / ( radius *2/3) / (bottom width * 2/3 )
STEP 6:-Print the calculated bed slope.
STEP 7:-Stop.
FLOWCHART FOR 1st PROBLEM
START
Input length of track , rail
length & Sleeper distance
Create RailTrack Object with input Parameter
Calculate number of rails using calculated rails method
Calculate number of sleepers using calculated sleeper’s method
Calculate number of fish bolts using calculated fish bolts method
Display number of rails,
sleepers & fish bolts.
STOP
FLOWCHART FOR 2nd PROBLEM
START
Input total unit weight, specific
gravity, water content
Calculation of dry unit weight
Calculation of porosity
Calculation of void ratio
Calculation of degree of saturation
Print result
STOP
FLOWCHART FOR 3rd PROBLEM
START
Input bottom width, side slope,
discharge & Chezy’s Constant
Create trapezoidal channel object with input parameters
Calculate hydraulic radius using given inputs
Calculate chezy’s velocity using chezy’s constant & hydraulic radius
Calculate bed slope using chezy’s velocity & hydraulic radius
Display calculated bed slope
STOP
PROBLEM No. 2
Q.2) This problem aims to develop a Python application to calculate
various properties of soil based on given parameters, including the total
unit weight, specific gravity, and water content. The properties to be
determined include the dry unit weight, porosity, void ratio, and degree
of saturation.
ANS:
def calculate_dry_unit_weight(total_unit_weight, water_content):
return total_unit_weight - (water_content * total_unit_weight)
def calculate_porosity(specific_gravity):
return (specific_gravity - 1) / specific_gravity
def calculate_void_ratio(porosity):
return porosity / (1 - porosity)
def calculate_degree_of_saturation(water_content, specific_gravity,
porosity):
return (water_content * specific_gravity) / ((specific_gravity - 1)
* (1 - porosity))
def main():
total_unit_weight = float(input("Enter the total unit weight of
soil: "))
specific_gravity = float(input("Enter the specific gravity of soil:
"))
water_content = float(input("Enter the water content of soil: "))
print("Define methods to calculate Dry Unit weight & porosity.")
dry_unit_weight = calculate_dry_unit_weight(total_unit_weight,
water_content)
porosity = calculate_porosity(specific_gravity)
print("Define methods to calculate void ratio & Degree of
saturation")
void_ratio = calculate_void_ratio(porosity)
degree_of_saturation =
calculate_degree_of_saturation(water_content, specific_gravity,
porosity)
print("Output print calculated properties")
print("Dry unit weight:", dry_unit_weight)
print("Porosity:", porosity)
print("Void ratio:", void_ratio)
print("Degree of Saturation:", degree_of_saturation)
if __name__ == "__main__":
main()
Enter the total unit weight of soil: 20
Enter the specific gravity of soil: 2.5
Enter the water content of soil: 20
Define methods to calculate Dry Unit weight & porosity.
Define methods to calculate void ratio & Degree of saturation
Output print calculated properties
Dry unit weight: -380.0
Porosity: 0.6
Void ratio: 1.4999999999999998
Degree of Saturation: 83.33333333333331
PROBLEM No. 3
Q.3) To develop a Python application for determining the bed slope of a
trapezoidal channel based on given channel dimensions and discharge,
using Chezy's constant.
ANS:import math
class TrapezoidalChannel:
def __init__(self, bottom_width, side_slope, discharge, chezy_constant):
self.bottom_width = bottom_width
self.side_slope = side_slope
self.discharge = discharge
self.chezy_constant = chezy_constant
def hydraulic_radius(self):
return (self.bottom_width + self.side_slope**2) / (2 *
self.side_slope)
def chezy_velocity(self):
return self.chezy_constant * math.sqrt(self.hydraulic_radius())
def bed_slope(self):
return (self.chezy_velocity() ** 2) / (self.hydraulic_radius() **
(2/3)) / (self.bottom_width ** (2/3))
if __name__ == "__main__":
bottom_width = float(input("Enter bottom width of the trapezoidal channel
(in meters): "))
side_slope = float(input("Enter side slope of the trapezoidal channel: "))
discharge = float(input("Enter discharge (in cubic meters per second): "))
chezy_constant = float(input("Enter Chezy's constant: "))
channel = TrapezoidalChannel(bottom_width, side_slope, discharge,
chezy_constant)
bed_slope = channel.bed_slope()
print("\nBed Slope of the trapezoidal channel:", bed_slope)
Enter bottom width of the trapezoidal channel (in meters): 6
Enter side slope of the trapezoidal channel: 0.33
Enter discharge (in cubic meters per second): 14.04
Enter Chezy's constant: 50
Bed Slope of the trapezoidal channel: 1589.6891200331402
PROBLEM No. 1
Q1) To develop a Python application for determining no of rails ,no of
sleepers , no of fish bolts etc on given length of rail track
ANS:
def calculate_rails(track_length, rail_length):
return (track_length // rail_length)*2
def calculate_sleepers(track_length, sleeper_spacing):
return (track_length // sleeper_spacing) + 1
def calculate_fish_bolts(track_length, sleeper_spacing):
return calculate_sleepers(track_length, sleeper_spacing) *2
def main():
track_length = float(input("Enter the length of the track (in meters):
"))
rail_length = float(input("Enter the length of each rail (in meters):
"))
sleeper_spacing = float(input("Enter the spacing between sleepers (in
meters): "))
rails = calculate_rails(track_length, rail_length)
sleepers = calculate_sleepers(track_length, sleeper_spacing)
fish_bolts = calculate_fish_bolts(track_length, sleeper_spacing)
print("Number of rails:", rails)
print("Number of sleepers:", sleepers)
print("Number of fish bolts:", fish_bolts)
if __name__ == "__main__":
main()
Enter the length of the track (in meters): 2000
Enter the length of each rail (in meters): 200
Enter the spacing between sleepers (in meters): 1
Number of rails: 20.0
Number of sleepers: 2001.0
Number of fish bolts: 4002.0
