Python For Structural Engineers

import numpy
import pandas
import comtypes.client

CONSTANT_A = 386.1

def main():
    print("hello world! Our script starts here")
    answer = add_function(a=1, b=1)
    print(f"1 + 1 is equal to: {answer}")
    return answer

def add_function(a, b):
    """This function returns the sum of a and b"""
    var = a + b
    return var

# Boiler plate code to call main() and avoiding global namespace pollution.
if __name__ == '__main__':
    MAIN_RETURN = main()

"""
Multi-line comment with triple quote
"""
# Single-line comment with pound sign (#)

# Importing modules and packages
import numpy as np
import math

# Variable assignment
a = int(42)             # integer
b = 3.14                # float
c = "hello world"       # string

# List
my_list  = [1, 2, 3]    # define a list of elements
first = my_list[0]      # return the first element (0-based indexing)

# Dictionary
my_dict  = {            # define a dictionary
    "key": "value",
    "key2": "value2",
    "key3": "value3"
    }
f = my_dict["key2"]     # return value associated with key2

# Math operations
a+b, a-b, a*b, a/b,     # basic algebra
a**2,                   # exponent using **
a//b,                   # floor division 5//2=2
a%b,                    # modulo (remainder) 5%2=1
abs(a),                 # absolute value
max([a,b]),             # max
min([a,b]),             # min
math.sin(b),            # comes with math module. Similar for cos, tan, atan, etc.
math.sqrt(b),           # or just use x**(1/2)
math.isclose(a,b),      # never compare two floats with ==. Use this instead

# Printing to console
print("hello world")
print(f"value of a = {a}, and b = {b}")
print("alternative method: value of a = {} and b = {}".format(a,b))
print("insert line break with \n and tab with \t")

# Use 'pass' when you need a blank filler that doesn't do anything
pass

# If statement
if condition:
    pass
elif:
    pass
else:
    pass

# While loops
while condition:
    pass

# For-loop with index
n = len(my_list)
for i in range(n):
    print(my_list[i])

# For-loop by element
for element in my_list:
    print(element)

# Raising exception when you detect an error
if ret_vaue != 0:
    raise RuntimeError('Stopped code. Detected some error.')

# Defining a function
def someFunction(arg1, arg2, default_arg1=3.14):
    """Doc string explains what this function does, input arg, and return values"""
    a = 1 + 1
    return a

# Calling a function
ret_value = some_function(arg1 = 1, arg2 = 2)

# Asking user for input
user_input = input("User can enter a value. Returns as a string")

# Defining lists
my_list = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
matrix = [[1, 0, 0, 0],
          [0, 1, 0, 0],
          [0, 0, 1, 0],
          [0, 0, 0, 1]]

# List indexing. Python has 0-based indexing. 0 is first element.
first  = my_list[0]    	        # 0
fourth = my_list[3]    	        # 30
last   = my_list[-1]            # 90
second_list = my_list[-2]       # 80

# List Slicing [start:stop:step]
middle_slice = my_list[2:5]     # [20, 30, 40]
seven_to_end = my_list[7:]      # [70, 80, 90]
up_to_3      = my_list[:3]      # [0, 10, 20]
exclude_last_4 = my_list[:-4]   # [0, 10, 20, 30, 40, 50]

# Advanced indexing
a = my_list[-2]                 # returns second last element = 80
a = my_list[::-1]               # reverses the list [90, 80, 70, 60, 50, 40, 30, 20, 10, 0]

# Find index of an element you're looking for
idx = my_list.index(8)          # Find first instance

# Extending a list
my_list.append('new item')
list1.extend(list2)             # Splice list2 to the end of list1 in place
list3 = list1 + list2           # Returns same as above
list1.insert(idx,val)           # Val is assigned to idx index. Everything else pushed back

# Removing elements from list
my_list.remove(element)         # Remove first instance found
del my_list[0:4]                # Remove a slice from list

# Other useful operations
my_list.sort()                  # Sort in increasing order in place
sorted_list = sorted(my_list)   # Return sorted list
my_list.reverse()               # Reverse a list in place
reversed_list = my_list[::-1]   # Return a reversed list

# List comprehension - automatically apply transformations to a list in one-line
squared_list = [x*x for x in my_list2]
filtered_list = [x for x in my_list2 if x>2]
product_list = [a*b for a,b in zip(my_list1, my_list2)]

# Strings are just list of characters, and can be indexed the same way
mystr = "abcdefghijklmn"
mystr[1]        # returns b
mystr[4:8]      # returns efgh
mystr[:4]       # returns abcd (first 4 letters)
mystr[4:]       # returns efghijklmn (everything after first 4 letters)
mystr[-4:]      # returns klmn (last 4 letters)
"""
The trick is to picture index on the left of char. Imagine boundary line on left 
 a b c d e f g h
0 1 2 3 4 5 6 7 8
We want to make cut at 4 and 8. Leaving us efgh

Since string is just a list of characters. The above operation also works on lists
"""

# Other useful string operations for parsing
concat = str1 + str2        # concatenate strings
"word" in string            # checks if "word" is in the string. Returns boolean
string.find("word")         # find the index where "word" occurs. Returns -1 if failed
string.strip()              # removes spaces and \n \t
string.strip(",.abc:;")     # remove occurence of these characters
string.split(" ")           # Split into list of strings at white space
string.split(",")           # Split into list of strings at comma or any other character
string.count("word")        # count how many times substring "word" occured
string.uppercase()          # convert all to uppercase
string.lowercase()          # convert all to lowercase
string.swapcase()           # swap lower and upper case. Vice versa
string.startwith("2020")    # see if string starts with prefix "2020"
string.endswith(".jpeg")    # see if string ends in suffix ".jpeg"

# Dictionaries are key-value Pairs. Key must be unique, value doesn't have to be
# Creating a dictionary
my_dict = dict()
my_dict['key1'] = 123
my_dict['key2'] = "abcd"

# or define with multiple lines
my_dict = {
    "key1": 123,
    "key2": "abcd"
}

# Accessing a dictionary
myval = my_dict['key1']   # returns "abcd"

# Loop through dictionaries. Order is NOT guaranteed.
for key in my_dict.keys():
    pass
for value in my_dict.Values():
    pass
for k,v in my_dict.items():
    pass

# Other useful methods
my_dict.items()              # Return tuples of all key-value pair
my_dict.values()             # Return all values
my_dict.keys()               # Return all keys
'key' in dict                # Check if key is in dict
my_dict[key1]=None           # If you want to disassociate a value to key
my_dict.pop(key)             # Remove entire key-value pair

# Convert JSON to python dictionary and vice versa
import json
with open("read.json", "r") as file:
    my_dict = json.load(file)

with open("write.json", "w") as file:
    json.dump(my_dict, file)

# Tuple are just lists that cannot be modified nor appended
myTuple = (1, 2, 3)

# Tuple unpacking - assigning multiple variables with one-line
var1, var2, var3 = 1, 2, 3
def func():
    return a,b
var1, var2 = func()


# Sets are list, but they contain only unique entries
my_list = [1, 1, 2, 2, 3]
myset = set(my_list)             # equals {1, 2, 3}

# Can use intersection of sets or union of sets
item_in_both = setA & setB       # Intersection
item_in_either = setA | setB     # Union

# Other methods
set1.add()              # Append value to set
set1.difference(set2)   # Returns value that only occur in set1 but not set2
set1.issubset(set2)     # Check if set1 is subset of set2
set1.issuperset(set2)   # Check if set1 is superset of set2
set1.discard(set2)      # Discard element from set1 if it exists in set 2

import os

# When not specifying any path, file is assumed to be in working directory
pd.read_csv("data.csv")

# When specifying abs path, always convert to raw with 'r' prefix
file_path = r"C:\Users\wcfro\Python\snippets"

# Get current working directory
os.getcwd()

# Get folder path where .py file is located. This is more robust than getcwd()
os.path.dirname(os.path.abspath(__file__))

# Make a new directory
os.mkdir("new_folder")

# Check if directory exists
os.isdir()

# List out all files in the folder
file_list = os.listdir(my_path)

# Get All files of a specific format
png_list=[]
for f in file_list:
    if f.endswith(".png"):
        png_list.append(f)

# Return parent folder "C:\Users\wcfro\Python\snippets"
os.path.dirname(r"C:\Users\wcfro\Python\snippets\file.csv")

# Can call dirname() recursively to get the parent folders n levels up
# This returns "C:\Users\wcfro\Python"
os.path.dirname(os.path.dirname(r"C:\Users\wcfro\Python\snippets\file.csv"))

# Joining path
file_path = os.path.join(os.getcwd, "scripts", "file.csv")

# Reading txt file with iostream
with open('file.txt', 'r') as f:
    firstline = next(f) # skip first line
    secondline = next(f) # skip to second line
    for line in f: # Loop through all other lines
        split_data = line.split() #split line
        Col1.append(float(split_data[0])) #extract column 1 data
        Col2.append(float(split_data[1])) #extract column 2 data
        Col3.append(float(split_data[2])) #extract column 3 data

# Alternatively, read entire file in one go. Get a list of all lines
with open('file.txt', 'r') as f:
    linesdata = f.readlines()

# Writing to File. Good for texts. Recommend using libraries for csv (e.g. pd.to_csv())
with open("my_output",'w') as f:
    for items in mylist:
        f.write('{},{},{}\n'.format(items[0],items[1],items[3]))

def calculate_moment_capacity(b, d, As, fpc, fy):
    """
    This function calculates the moment capacity of a rectangular
    reinforced-concrete beam using ACI 318.
    
    Args:
        b               float:: section width (inches)
        d               float:: section depth (inches)
        As              float:: area of steel (in^2)
        fpc             float:: concrete strength (ksi)
        fy              float:: rebar strength (ksi)
        
    Return:
        phi_Mn          float:: design moment capacity (k.in)
    """    
    # calculate beta factor
    if fpc <= 4:
        beta = 0.85
    elif fpc >= 8:
        beta = 0.65
    else:
        beta = 0.85 - 0.05*(fpc - 4)
        
    # calculate neutral axis and depth of rectangular stress block
    a = fy * As / 0.85 / fpc / b
    c = a/beta
    
    # Calculate resistance factor
    e_yield = fy/29000
    et = 0.003*(d - c)/c
    if et > 0.005: 
        phi = 0.9 # tension-controlled
    elif et < e_yield:
        phi = 0.65 # compression-controlled
    else: 
        phi = 0.65 + (0.25*(et - e_yield))/(0.005-e_yield) # transition zone
        
    # calculate flexural capacity
    Mn = fy*As*(d - a/2)
    phi_Mn = phi * Mn
    return phi_Mn


# User input
fy = 60 #ksi
fpc = 4 #ksi
b = 12 #in
h = 24 #in
cover = 2 #in
rebar_count = 4
rebar_size = "#6"

# Rebar information stored in a dictionary
REBAR_DICT = {
    "#3":  {"area":0.11, "diameter":0.375},
    "#4":  {"area":0.20, "diameter":0.500},
    "#5":  {"area":0.31, "diameter":0.625},
    "#6":  {"area":0.44, "diameter":0.750},
    "#7":  {"area":0.60, "diameter":0.875},
    "#8":  {"area":0.79, "diameter":1.000},
    "#9":  {"area":1.00, "diameter":1.128},
    "#10": {"area":1.27, "diameter":1.270},
    "#11": {"area":1.56, "diameter":1.410},
}

# calculate rebar depth and area outside
d = h - cover - REBAR_DICT[rebar_size]["diameter"]/2
As = rebar_count * REBAR_DICT[rebar_size]["area"]

# calculate moment capacity
phi_Mn = calculate_moment_capacity(b = b, 
                                   d = d,
                                   As = As, 
                                   fpc = fpc, 
                                   fy = fy)
# print out results
print(f"{b} in x {h} in concrete beam with ({rebar_count}) {rebar_size} bottom:")
print("Design Moment Capacity = {:.2f} k.in".format(phi_Mn))