Mini Project 5: Plotting Bottle Rockets

[10]

First, you'll write a function called calculate_velocity which takes no arguments, but uses the program constants to calculate the vx and vy velocities of the rocket based on an initial velocity, a launch angle (e.g. 45 for 45 degrees from the horizon). The function should return a tuple representing the velocity vector of vxi and vyi float values, which represent the velocities in the same units as INITIAL_VELOCITY.

To calculate velocity, remember from your physics fundamentals to use cos (for x velocity) and sin (for y velocity). We have already imported the math module for you in the starter code for these functions. Since the ANGLE_OF_LAUNCH is in degrees (this makes it easier for users to specify angles), you'll need to convert to radians. You can convert degrees to radians easily with math.radians(<degrees>).

math.radians(0)   # 0.0
math.radians(360) # 6.283... (2pi)
math.radians(90)  # 1.5707...(pi/2)

Using the provided program constants, a call to calculate_velocity() should return the tuple (106.06601717798213, 106.06601717798212) (what happens when you change the INITIAL_VELOCITY and ANGLE_OF_LAUNCH constants?).

For reference, our solution is 5-6 lines ignoring comments. Make sure to use variables to avoid recomputation!

[5]

Next, you'll use your calculate_velocity function to implement calculate_position. This function takes a single parameter dt representing the time elapsed, and returns the (x, y) position (a tuple) of the rocket at dt. We have given you the launch starting position, which we will fix at (0, 0) to keep things simple.

Here are some example calls and the expected results for the provided program constants constants (again, these constants should be used in this function):

[5]

One of the important measurements of a bottle rocket launch is the total time of flight (sometimes referred to TOF). Finish this function to compute the total flight time (which will be in the same units as INITIAL_VELOCITY and GRAVITY). Again, we are assuming the default starting position of (0, 0).

To calculate the total flight time, you'll need to figure out the initial y velocity (use your calculate_velocity function) and the GRAVITY constant. Remember that velocities and gravity in this program have compatible units, both involving seconds. Refer to your physics classwork to determine the total flight time from this information. The time should be returned as a float. For the current program constants, you should expect a call to flight_time() to be 21.62406058674457.

For reference, our solution is 2-3 lines of code and the only constant it references directly is GRAVITY.

[10]

Write a docstring for this function that describes the behavior of the function given the single parameter, including what is returned (do not copy/paste what we wrote above). Follow the same conventions as we've shown in class, including:

• Omitting any implementation details, like loops and any local variables (including local variables that are returned, but you should specify the names of function parameter when describing them)
• Specifying the types of the parameter and return
• Any preconditions/edge cases that the function requires (you don't need to change the implementation; use your docstring to specify any preconditions)

Hint: The most important thing to make sure you understand is the relationship between the local xs and ys variables. Are there any notes about their lengths? Is there a relationship between xs[i] and ys[i] in the context of a rocket launch position?

[5]

ATTEMPT THIS AFTER YOU FINISH A.6, otherwise your VSCode debugger may not work.

We've given you this docstring, but to make sure you are set up for the rest of the assignment, you are required to add replace the 4 TODO comments in to the body of this function with the corresponding value (as a # comment):

• The value of dist_label for the Part A data
• The value of dist_label_coords for the Part A data
• The value of maxh_label for the Part A data
• The value of maxh_label_coords for the Part A data

This requirement is less about documentation, but more to make sure you are able to use the VSCode debugger to determine this information. At this point, we definitely expect you to know how to use the debugger, but if you run into any questions, we're happy to help.

For example, if we were to ask you to do the same thing for the code below, we would expect the TODO replacements in the following format:

# TODO 0: Replace this line with the tuple values of (total_dist, last_y)
(total_dist, last_y) = landing_pt
...
# TODO N: Replace this line with the string value of legend_label
legend_label = f'Launch Trajectory ({tof:.1f}s)'

Replacing the TODOs as described:

# (2293.577981651376, 0.0)
(total_dist, last_y) = landing_pt
...
# 'Launch Trajectory (21.6s)'
legend_label = f'Launch Trajectory ({tof:.1f}s)'

Some notes about A.5.

This function uses the ax.annotate method to specify the following arguments used to annotate a point with text (in this example, no arrow is used but the documentation includes examples using arrows). You can find more about the arguments from the official Matplotlib documentation if you're curious.

Here's a quick summary of the annotation arguments we're using:

• The text is the label.
• The xy keyword argument is the (x, y) tuple associated with the annotation.
• The xytext keyword argument is the (xt, yt) tuple associated with the text of the annotated point. Note that the two offset constants are used to avoid overlapping the text with the annotated point.
• The color of the annotation is the same as the plotted point.
• The horizontalalignment keyword is centered so that we can standardize placement of labels.

In addition to plotting the point and its annotation, you'll see ax.set_xlim and ax.set_ylim to set the x and y axis ranges, respectively. Why do we set these? If you experiment commenting out these lines, you'll notice that the landing point marker will be cropped off at y = 0, and the annotation label above the highest point will be cropped off above the upper-bounds of the plot.

[5]

The rest of the code is given to you; there is nothing for you to add (code or documentation-wise). We've summarized these functions briefly for you.

configure_plot

As mentioned in lecture, our primary source of interaction with Matplotlib is the Axes object(s) returned from plt.subplots(). When you work on data visualization programs, there is more than just plotting your data, and usually there are configurations you will want to override to improve the quality/interpretability of your visualization(s).

This function factors out the configurations specific to the the Figure and Axes and unrelated to the actual lines/points. You'll note that we plot two black points to add to the legend; we use black ('k') to generalize the legend markers for larger visualizations like Part B so we don't have so many legend items.

You'll also see the x and y limits updated here to give some padding to the Figure for the points and annotations to fit. How would one choose these values? Well, in practice you'll want to be considerate of the likelihood of your x and y axis ranges changing (e.g. and an offset of 100 looks much different when the upper-bound is 50 vs. 1000). With more experience, one would be encouraged to use relative offsets with percentages, but for the scope of this assignment we just give you constant values. You are welcome to keep these as-is or be a bit more clever in Part C.

start

Finally, we see the starting point for everything working together! Just like in previous assignments/labs/lecture code, having a short start function is good practice to have good program decomposition. This is where we create the Figure and Axes, and pass ax to any functions that need it (fig isn't used in any other functions, so it shouldn't be passed anywhere).