ENGR30003-Numerical-Programming-for-Engineers

Learning Outcomes

This project requires you to demonstrate your understanding of dynamic memory, linked lists and basic numerical computation. The key objective of this request is to solve a set of tasks which involve processing of flow around a flat plate.

Flow Around a Flat Plate

In the field of Fluid Mechanics, flow around a flat plate perpendicular to the flow direction is still an active area of research. With advent of high performance computing and supercomputers, it has now become possible to look at this simple case with a greater deal of accuracy. The problem consists of a flat plate that is perpendicular to the main flow direction as shown in Figure 1 (left). The blue arrows indicate the direction of the flow while the shaded object is the flat plate. This generates a wake behind the flat plate and exerts a pressure force on the plate, similar to the force you feel when you hold your hand out in a moving car. At a given instant the flow behind the flat plate is extremely complex and a snapshot of the flow domain is shown in Figure 1 (right).

Working with the Data

For this request, you will process the wake data from a flat plate case. The data has been provided to you in a CSV format file (flow data.csv) with the following form:

x, y, u, v
10.028, -20, 1.0079, -0.0054866
10.077, -20, 1.0079, -0.0054739
10.126, -20, 1.0079, -0.0054612
10.175, -20, 1.0079, -0.0054484
10.224, -20, 1.0079, -0.0054357

Each line corresponds to a point in the flow domain with coordinates (x,y). The velocities at that given point in x and y are given by u and v respectively.

Processing Tasks

This request consists of four processing tasks which will be assessed independently. For each task you are to measure the run time it takes to complete the described task using your program (see program output below). Each of the four tasks must not require more than 60 seconds to run on dimefox. This means, in order to complete the task within this time limit, you may need to focus on the efficiency of your solution for each problem. Overall you have to write a single program, performing each of the four tasks sequentially. For each task you have to write your results to a file on the disk.

Task 1: Maximum Velocity Difference

It is sometimes helpful to understand what’s the range of velocities in the flow. For the first task, you must compute the maximum velocity difference in u and v after coordinate x = 20. Specifically, you must output first the two points in the domain where the magnitude of the u velocity difference is maximum followed by the two points in the grid where the magnitude of the v velocity difference is maximum. For each set of points, the point with the maximum of the given velocity must be first followed by the point with the minimum velocity. The output should be to the file called task1.csv and should be formatted as below. There must be no blank spaces between the values and around the commas. Each value must be written to 6 decimal places.

It is imperative that you write it out the way described above and shown below otherwise comparing your output to the solution would result in an error and you would lose marks.

x, y, u, v
40.512346, -19.595387, 1.007986, -0.001002
66.899192, -0.729056, 0.850117, 0.0005807
69.552467, -0.729056, 0.852483, 0.0004275
60.961891, 0.442134, 0.838355, -0.0006330

The above is an example of what the file should look like and is not the actual solution. Also note that the data provided in flow data.csv is not in any chronological order and you must efficiently look only at points where the value of x is greater than 20. You can use file io.c to understand how to output data to a file.

Task 2: Mean Velocities on a Coarser Grid

Each line in the file flow data.csv is a point location in the domain. These points when joined together will create a mesh (also called a grid). For this task, you will map these points onto a coarser grid, computing the new average coordinates (x,y) and the corresponding velocities (u,v). The flow domain can be thought as divided into a two dimensional grid such that each cell of the grid would contain multiple points, the number of which would depend on the cell upper and lower dimensions and the coordinates of the points. You would compute the average coordinates and velocities for each cell using the formula below for all points k within a given cell (this is for the x coordinate; same formula to be used for y, u, v).

Finally, you must output the results of the averaged values and the score to task2.csv in descending order based on the score for each cell. An example of what the output should look like is shown below. There must be no blank spaces between the values and around the commas. Any float value must be written to 6 decimal places as shown:

x, y, u, v, S
20.464390, 19.001188, 1.009472, 0.003123, 3.614885
26.493395, -2.917140, 0.950080, 0.003106, 3.564577
26.493395, 2.922365, 0.949606, -0.002937, 3.562721
26.493443, 10.961477, 1.016337, 0.001415, 3.544763
26.493443, -11.009443, 1.016268, -0.001393, 3.542255
23.490141, -16.954090, 1.010923, -0.002471, 3.489632
23.490141, 16.966158, 1.010908, 0.002496, 3.488729

The size of the grid (number of cells in each direction) must be an input parameter, allowing the code to run different grid sizes. Your implementation would be checked for the grid resolution of 24 i.e. 24 cells in x and 24 cells in y. The domain extent for this coarse grid in x and y is 10 to 70 units and -20 to 20 units respectively. An example of the coarse grid is shown in Figure 2 (left). The 24 cells in x direction would span from -10 to 70 units while the 24 cells in y direction would span -20 to 20 units. Also shown is an example of a cell within this grid. As can be seen, the cell is of width x and height y and the black dots show the points in the original grid. Once you do the averaging for all these points, you will end up with one average point (shown in red).

Task 3: Velocity and It’s Statistics

For this task, you have to compute the threshold statistics of u velocity magnitudes i.e. how many points in the domain have the magnitude of u under 0.5, under 0.6 and so on. Then you must compute the % of points under each band. An example of this is given below.

threshold, points, percentage
0.500000, 126, 11.012561
0.600000, 256, 22.536942
0.700000, 348, 30.613564
0.800000, 582, 51.300236
0.900000, 810, 71.352145
1.000000, 902, 79.496213
1.100000, 1136, 100.000000

This example shows that there are 582 points in the domain where the magnitude of u is under 0.8. You must output the results in the same format as above to task3.csv. There must be no blank spaces between the values and around the commas. Any float value must be written to 6 decimal places as shown above.

Task 4: Wake Profile Visualization

For this task, you will visualise the wake profile generated by writing the wake boundaries to a text file. To do this, you will first calculate the y coordinate of maximum u velocity. This is to be done for locations x = 10,15,20,25,30,35,40,45,50,55,60,65, i.e. you will look through all the relevant points for each specified x location to choose the maximum of u and pick the corresponding y coordinate. Since the data doesn’t contain exact x coordinates as described here, you will take the x coordinate which are closest to these these numbers. For instance, the closest number to x = 50 in the data file is x = 49.999. To pick the relevant x coordinate, you can use a bound of 0.05 about the specified location (Note that there is exactly one x coordinate that will fall inside the bound so you don’t have to worry about a tie). Output the chosen x location and the magnitude of the corresponding y coordinate in the following format to task4 1.csv. There must be no blank spaces between the values and around the commas. Any float value must be written to 6 decimal places as shown:

x, y_h
29.980000, 5.921400
49.999001, 6.739500
54.983002, 6.956200

Now that you’ve obtained the y coordinates, calculate the spacing for each location using the following formula:

spacing = ceil(10 |y|)

A skeleton version has been provided to you, complete with the print statements to print out the wake boundary. All you need to to do is to obtain the spacings for these 12 x locations into the array yheight where yheight[0] corresponds to the spacing for x=10. The output should be written to the file task4_2.txt.

Submission

You need to submit your program for assessment. Submissions will not be done via the LMS; instead you will need to log in to the server dimefox and submit your files using the command submit . You can (and should) use submit both early and often to get used to the way it works, and also to check that your program compiles correctly on our test system, which has some different characteristics to the lab machines. Only the last submission will be marked. The submission server may be very slow towards the deadline as many students are submitting. Therefore, please do not wait until the last few minutes to make the first attempt of submission. If you make a submission attempt a few minutes before the deadline but the submission was completed after the deadline, your submission will be treated as a submission AFTER the deadline.