diff --git a/arch_subdivision_automatisation.ipynb b/arch_subdivision_automatisation.ipynb index 879b4cf..9210804 100644 --- a/arch_subdivision_automatisation.ipynb +++ b/arch_subdivision_automatisation.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 136, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -76,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": 137, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -109,7 +109,7 @@ }, { "cell_type": "code", - "execution_count": 138, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -128,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 139, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -146,18 +146,9 @@ }, { "cell_type": "code", - "execution_count": 140, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "centre_angle = 146.7651\n", - "springing_angle = 16.6174\n" - ] - } - ], + "outputs": [], "source": [ "# Arch angle attributes\n", "centre_angle = 4 * math.atan((2 * rise_int)/span_length)\n", @@ -181,19 +172,9 @@ }, { "cell_type": "code", - "execution_count": 141, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "radius_int = 4.832\n", - "radius_centre = 5.082\n", - "radius_ext = 5.332\n" - ] - } - ], + "outputs": [], "source": [ "# Arch radius attributes\n", "radius_int = span_length/(2*math.cos(springing_angle))\n", @@ -207,18 +188,9 @@ }, { "cell_type": "code", - "execution_count": 142, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "span_length_centre = 9.739\n", - "span_length_ext = 10.218\n" - ] - } - ], + "outputs": [], "source": [ "# Arch span length attributes\n", "span_length_centre = span_length + 2 * ((arch_thickness/2) * math.cos(springing_angle))\n", @@ -230,18 +202,9 @@ }, { "cell_type": "code", - "execution_count": 143, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "rise_centre = 3.629\n", - "rise_ext = 3.807\n" - ] - } - ], + "outputs": [], "source": [ "# Arch rise attributes\n", "rise_centre = (span_length_centre/2) * math.tan(centre_angle/4)\n", @@ -282,7 +245,7 @@ }, { "cell_type": "code", - "execution_count": 144, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -294,17 +257,9 @@ }, { "cell_type": "code", - "execution_count": 145, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Spandrel wall springing height: 5.982\n" - ] - } - ], + "outputs": [], "source": [ "# Input of spandrel wall attributes\n", "spandrel_wall_thickness = 0.20\n", @@ -318,7 +273,7 @@ }, { "cell_type": "code", - "execution_count": 146, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -346,7 +301,7 @@ }, { "cell_type": "code", - "execution_count": 147, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -377,45 +332,25 @@ }, { "cell_type": "code", - "execution_count": 148, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Point ID: 1 ; Point angle: 16.6174 ; x_O: 4.87 ; y_O: 1.453\n", - "Point ID: 2 ; Point angle: 53.3087 ; x_O: 3.036 ; y_O: 4.075\n", - "Point ID: 3 ; Point angle: 90.0 ; x_O: 0.0 ; y_O: 5.082\n", - "Point ID: 4 ; Point angle: 126.6913 ; x_O: -3.036 ; y_O: 4.075\n", - "Point ID: 5 ; Point angle: 163.3826 ; x_O: -4.87 ; y_O: 1.453\n" - ] - } - ], + "outputs": [], "source": [ "point_coordinates = divide_half_circle(radius_centre, span_length_centre, elements)" ] }, { "cell_type": "code", - "execution_count": 149, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1, 16.6174, 4.87, 1.453)\n" - ] - } - ], + "outputs": [], "source": [ "print(point_coordinates[0])" ] }, { "cell_type": "code", - "execution_count": 150, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -442,29 +377,16 @@ }, { "cell_type": "code", - "execution_count": 151, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plots = plot_elements_and_half_circle(point_coordinates, radius_centre, span_length_centre)" ] }, { "cell_type": "code", - "execution_count": 152, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -484,17 +406,9 @@ }, { "cell_type": "code", - "execution_count": 153, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Data has been exported to /Users/fn20944/Library/CloudStorage/OneDrive-UniversityofBristol/YEAR 3_2022-23/RESOURCES FOR FRAGILITY CURVE FRAMEWORK/PROGRAMMING CODES/arch_compression/AFTER THE IALCEE PAPER/circle_points_coordinates.csv successfully.\n" - ] - } - ], + "outputs": [], "source": [ "filename = 'circle_points_coordinates.csv'\n", "export_to_csv(point_coordinates, filename)" @@ -511,7 +425,7 @@ }, { "cell_type": "code", - "execution_count": 154, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -520,7 +434,7 @@ " angle_per_point = centre_angle/elements\n", " coordinates = []\n", "\n", - " for i in range(elements+1):\n", + " for i in range(elements+1): \n", " current_angle = springing_angle + (i * angle_per_point)\n", " x_O = round(radius * math.cos(springing_angle) - radius * math.cos(current_angle),3)\n", " y_O = round(radius * math.sin(current_angle), 3)\n", @@ -534,7 +448,7 @@ }, { "cell_type": "code", - "execution_count": 155, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -561,7 +475,7 @@ }, { "cell_type": "code", - "execution_count": 156, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -581,60 +495,27 @@ }, { "cell_type": "code", - "execution_count": 157, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Point ID: 1 ; Point angle: 16.6174 ; x_O: 0.0 ; y_O: 1.453\n", - "Point ID: 2 ; Point angle: 53.3087 ; x_O: 1.833 ; y_O: 4.075\n", - "Point ID: 3 ; Point angle: 90.0 ; x_O: 4.87 ; y_O: 5.082\n", - "Point ID: 4 ; Point angle: 126.6913 ; x_O: 7.906 ; y_O: 4.075\n", - "Point ID: 5 ; Point angle: 163.3826 ; x_O: 9.739 ; y_O: 1.453\n" - ] - } - ], + "outputs": [], "source": [ "point_coordinates_prime = divide_half_circle(radius_centre, span_length_centre, elements)" ] }, { "cell_type": "code", - "execution_count": 158, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plots = plot_elements_and_half_circle(point_coordinates, radius_centre, span_length_centre)" ] }, { "cell_type": "code", - "execution_count": 159, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Data has been exported to /Users/fn20944/Library/CloudStorage/OneDrive-UniversityofBristol/YEAR 3_2022-23/RESOURCES FOR FRAGILITY CURVE FRAMEWORK/PROGRAMMING CODES/arch_compression/AFTER THE IALCEE PAPER/circle_points_coordinates_left_origin.csv successfully.\n" - ] - } - ], + "outputs": [], "source": [ "filename = 'circle_points_coordinates_left_origin.csv'\n", "export_to_csv(point_coordinates_prime, filename)" @@ -648,46 +529,6 @@ "Functions of loads" ] }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Uniform load function" - ] - }, - { - "cell_type": "code", - "execution_count": 160, - "metadata": {}, - "outputs": [], - "source": [ - "# def uniform_load(x, y, thickness, height, unit_weight):\n", - "# load = thickness * height * unit_weight\n", - "# return load\n", - "\n", - "# def assign_uniform_load(coordinates):\n", - "# for i, coordinate in enumerate(coordinates):\n", - "# x = coordinates[2]\n", - "# y = coordinates[3]\n", - "# parapet_load = round(uniform_load(x, y, parapet_thickness, parapet_height, parapet_unit_weight), 3)\n", - "# self_weight_load = round(uniform_load(x, y, arch_barrell_width, arch_barrell_height, arch_barrell_unit_weight), 3) \n", - "# coordinates[i] = coordinate + (parapet_load,) + (self_weight_load,)\n", - "\n", - "# for i, coordinate in enumerate(coordinates):\n", - "# print(\"Point ID: \", coordinate[0], \"; Point angle: \", coordinate[1], \"; x_O_prime: \", round(coordinate[2],3), \"; y_O_prime: \", round(coordinate[3],3), \n", - "# \"; Parapet load: \", round(parapet_load,3), \"; Arch weight: \", round(self_weight_load,3))" - ] - }, - { - "cell_type": "code", - "execution_count": 161, - "metadata": {}, - "outputs": [], - "source": [ - "# assign_uniform_load(point_coordinates_prime)" - ] - }, { "attachments": {}, "cell_type": "markdown", @@ -698,7 +539,7 @@ }, { "cell_type": "code", - "execution_count": 162, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -714,7 +555,7 @@ }, { "cell_type": "code", - "execution_count": 163, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -735,125 +576,161 @@ }, { "cell_type": "code", - "execution_count": 164, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# spandrel_wall_load = circular_load(points_x, points_y, spandrel_wall_thickness, spandrel_wall_springing_height, spandrel_wall_unit_weight)" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calculation of nodal loads" + ] + }, { "cell_type": "code", - "execution_count": 165, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# def assign_load(coordinates):\n", - "# for i, coordinate in enumerate(coordinates):\n", - "# x = coordinates[2]\n", - "# y = coordinates[3]\n", - "# parapet_load = round(uniform_load(x, y, parapet_thickness, parapet_height, parapet_unit_weight), 3)\n", - "# self_weight_load = round(uniform_load(x, y, arch_barrell_width, arch_barrell_height, arch_barrell_unit_weight), 3)\n", - "# spandrel_wall_load = circular_load(points_x, points_y, spandrel_wall_thickness, spandrel_wall_springing_height, spandrel_wall_unit_weight)\n", - "# coordinates[i] = coordinate + (parapet_load,) + (self_weight_load,) + (spandrel_wall_load,)\n", - "\n", - "# for i, coordinate in enumerate(coordinates):\n", - "# print(\"Point ID: \", coordinate[0], \"; Point angle: \", coordinate[1], \"; x_O_prime: \", round(coordinate[2],3), \"; y_O_prime: \", round(coordinate[3],3), \n", - "# \"; Parapet load: \", round(parapet_load,3), \"; Arch weight: \", round(self_weight_load,3), \n", - "# \"; Spandrel wall\", spandrel_wall_load[i])" + "def uniform_load(coordinates, thickness, height, unit_weight):\n", + " load = thickness * height * unit_weight\n", + " return load" ] }, { "cell_type": "code", - "execution_count": 166, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# assign_load(point_coordinates_prime)" + "def points_distance(coordinates):\n", + " for i, coordinate in enumerate(coordinates):\n", + " if i ==0:\n", + " elements_length = 0\n", + " else:\n", + " elements_length = abs(coordinates[i][2] - coordinates[i-1][2])\n", + " coordinates[i] = coordinate + (elements_length,)\n", + " return coordinates" ] }, { "cell_type": "code", - "execution_count": 167, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# def export_to_csv(coordinates, filename):\n", - "# headers = ['Point ID', 'Point angle', 'X', 'Y', 'Parapet load', 'Arch self weight', 'Spandrel wall']\n", - "\n", - "# current_dir = os.getcwd()\n", - "# filepath = os.path.join(current_dir, filename)\n", - "\n", - "# with open(filepath, 'w', newline = '') as file:\n", - "# writer = csv.writer(file)\n", - "# writer.writerow(headers)\n", - "# writer.writerows(coordinates)\n", - "\n", - "# print(f\"Data has been exported to {filepath} successfully.\")" + "points_coordinates_prime_distances = points_distance(point_coordinates_prime)" ] }, { "cell_type": "code", - "execution_count": 168, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# filename = 'circle_points_coordinates_left_origin_loads.csv'\n", - "# export_to_csv(point_coordinates_prime, filename)" + "def calculate_nodal_loads(coordinates, thickness, height, unit_weight):\n", + " nodal_load_list = []\n", + " target_tuple=[]\n", + " for i, coordinate in enumerate(coordinates):\n", + " load = uniform_load(coordinates, thickness, height, unit_weight)\n", + " if i == 0:\n", + " nodal_load = 1/2 * load * points_coordinates_prime_distances[1][4]\n", + " elif 0 < i < len(coordinates)-1:\n", + " nodal_load = 1/2 * load * (points_coordinates_prime_distances[i][4]+points_coordinates_prime_distances[i+1][4])\n", + " elif i > len(coordinates)-1:\n", + " nodal_load = 1/2 * load * points_coordinates_prime_distances[i][4]\n", + " nodal_load_list.append(nodal_load)\n", + "\n", + " target_tuple = list(points_coordinates_prime_distances[i])\n", + " target_tuple.append(nodal_load_list[i])\n", + " target_tuple = tuple(target_tuple)\n", + " coordinates[i] = target_tuple\n", + "\n", + " # Print column headers\n", + " headers = [\"Point ID\", \"Point angle\", \"X\", \"Y\", \"Point mutual distance\", \"Nodal load\"]\n", + " header_format = \"{:<10s} {:<15s} {:<10s} {:<10s} {:<20s} {:<15s}\"\n", + " print(header_format.format(*headers))\n", + "\n", + " # Print coordinate values\n", + " for coordinate in coordinates:\n", + " print(\"{:<10d} {:<15f} {:<10f} {:<10f} {:<20f} {:<15f}\".format(*coordinate))\n", + " \n", + " return coordinates" ] }, { - "attachments": {}, - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "Calculation of nodal loads" + "calculate_nodal_loads(point_coordinates_prime, parapet_thickness, parapet_height, parapet_unit_weight)" ] }, { "cell_type": "code", - "execution_count": 169, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Point ID: 1 ; Point angle: 16.6174 ; X: 0.0 ; Y: 1.453 ; Function value: 0.0\n", - "Point ID: 2 ; Point angle: 53.3087 ; X: 1.833 ; Y: 4.075 ; Function value: 3.7099920000000006\n", - "Point ID: 3 ; Point angle: 90.0 ; X: 4.87 ; Y: 5.082 ; Function value: 6.1468880000000015\n", - "Point ID: 4 ; Point angle: 126.6913 ; X: 7.906 ; Y: 4.075 ; Function value: 6.144864000000001\n", - "Point ID: 5 ; Point angle: 163.3826 ; X: 9.739 ; Y: 1.453 ; Function value: 3.709992000000003\n" - ] - } - ], + "outputs": [], "source": [ - "def uniform_load(x, y, thickness, height, unit_weight):\n", - " load = thickness * height * unit_weight\n", - " return load\n", + "def calculate_nodal_loads(coordinates, thickness, height, unit_weight, load_name):\n", + " nodal_load_list = []\n", + " target_tuple=[]\n", + " for i, coordinate in enumerate(coordinates):\n", + " load = uniform_load(coordinates, thickness, height, unit_weight)\n", + " if i == 0:\n", + " nodal_load = 1/2 * load * points_coordinates_prime_distances[1][4]\n", + " elif 0 < i < len(coordinates)-1:\n", + " nodal_load = 1/2 * load * (points_coordinates_prime_distances[i][4]+points_coordinates_prime_distances[i+1][4])\n", + " elif i > len(coordinates)-1:\n", + " nodal_load = 1/2 * load * points_coordinates_prime_distances[i][4]\n", + " nodal_load_list.append(nodal_load)\n", "\n", - "def calculate_function_value(x, y, thickness, height, unit_weight, distance):\n", - " load = uniform_load(x, y, thickness, height, unit_weight)\n", - " function_value = load * (distance / 2)\n", - " return function_value\n", + " target_tuple = list(points_coordinates_prime_distances[i])\n", + " target_tuple.append(nodal_load_list[i])\n", + " target_tuple = tuple(target_tuple)\n", + " coordinates[i] = target_tuple\n", "\n", - "def assign_function_value(coordinates, thickness, height, unit_weight):\n", - " for i, coordinate in enumerate(coordinates):\n", - " x = coordinate[2]\n", - " y = coordinate[3]\n", - " distance = 0 # Initialize distance to 0 for the first point\n", - " if i > 0:\n", - " # Calculate the distance between the current point and the previous point\n", - " distance = abs(coordinates[i][2] - coordinates[i-1][2])\n", - " function_value = calculate_function_value(x, y, thickness, height, unit_weight, distance)\n", - " coordinates[i] = coordinate + (function_value, )\n", + " # Print column headers\n", + " headers = [\"Point ID\", \"Point angle\", \"X\", \"Y\", \"Point mutual distance\", load_name]\n", + " header_format = \"{:<10s} {:<15s} {:<10s} {:<10s} {:<20s} {:<15s}\"\n", + " print(header_format.format(*headers))\n", "\n", - " for i, coordinate in enumerate(coordinates):\n", - " print(\"Point ID: \", coordinate[0], \"; Point angle: \", coordinate[1], \"; X: \", coordinate[2], \"; Y: \", coordinate[3], \n", - " \"; Function value: \", coordinate[4])\n", + " # Print coordinate values\n", + " for coordinate in coordinates:\n", + " print(\"{:<10d} {:<15f} {:<10f} {:<10f} {:<20f} {:<15f}\".format(*coordinate))\n", + " \n", + " return coordinates, headers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "nodal_loads, headers = calculate_nodal_loads(point_coordinates_prime, parapet_thickness, parapet_height, parapet_unit_weight, \"Parapet load\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def export_coordinates_to_csv(coordinates, headers, filename):\n", + " with open(filename, 'w', newline='') as csvfile:\n", + " writer = csv.writer(csvfile)\n", + " writer.writerow(headers) # Write the column headers\n", + " writer.writerows(coordinates) # Write the coordinate values\n", "\n", - "# Example usage:\n", - "assign_function_value(point_coordinates_prime, parapet_thickness, parapet_height, parapet_unit_weight)\n" + "# Example usage\n", + "export_coordinates_to_csv(nodal_loads, headers, 'points_coordinates_nodal_loads.csv')\n" ] } ], diff --git a/circle_points_coordinates_left_origin_loads.csv b/circle_points_coordinates_left_origin_loads.csv deleted file mode 100644 index 6cad240..0000000 --- a/circle_points_coordinates_left_origin_loads.csv +++ /dev/null @@ -1,6 +0,0 @@ -Point ID,Point angle,X,Y,Parapet load,Arch self weight,Spandrel wall -1,16.6174,4.87,1.453,4.048,11.0,4.048,11.0,[19.92670725 8.38990725 3.95910725 8.38990725 19.92670725] -2,53.3087,3.036,4.075,4.048,11.0,4.048,11.0,[19.92670725 8.38990725 3.95910725 8.38990725 19.92670725] -3,90.0,0.0,5.082,4.048,11.0,4.048,11.0,[19.92670725 8.38990725 3.95910725 8.38990725 19.92670725] -4,126.6913,-3.036,4.075,4.048,11.0,4.048,11.0,[19.92670725 8.38990725 3.95910725 8.38990725 19.92670725] -5,163.3826,-4.87,1.453,4.048,11.0,4.048,11.0,[19.92670725 8.38990725 3.95910725 8.38990725 19.92670725] diff --git a/coordinates.csv b/coordinates.csv new file mode 100644 index 0000000..dd61067 --- /dev/null +++ b/coordinates.csv @@ -0,0 +1,6 @@ +Point ID,Point angle,X,Y,Point mutual distance,Parapet load +1,16.6174,0.0,1.453,0,3.7099920000000006,3.7099920000000006 +2,53.3087,1.833,4.075,1.833,9.856880000000002,9.856880000000002 +3,90.0,4.87,5.082,3.037,12.291752000000002,12.291752000000002 +4,126.6913,7.906,4.075,3.0359999999999996,9.854856000000003,9.854856000000003 +5,163.3826,9.739,1.453,1.833000000000001,9.854856000000003,9.854856000000003