Question

Plot a formula for several parameters. Make a program that reads a set of \(v_{0}\) values from the command line and plots the corresponding curves \(y(t)=v_{0} t-0.5 g t^{2}\) in the same figure (set \(g=9.81\) ). Let \(t \in\left[0,2 v_{0} / g\right]\) for each curve, which implies that you need a different vector of \(t\) coordinates for each curve. Name of program file: plot_bal12.py.

Short answer

Use Python with matplotlib to plot the curves for each input initial velocity.

Step-by-step solution

Understanding the problem

We need to write a program named `plot_bal12.py` that takes a list of initial velocity values, \( v_0 \), as input from the command line. For each \( v_0 \), we will plot the trajectory of an object under gravity described by the equation \( y(t) = v_0 t - 0.5 g t^2 \) where \( g = 9.81 \). The time interval \( t \) ranges from 0 to \( 2v_0/g \).

Setting up the environment

Before writing the code, ensure you have Python and a plotting library like matplotlib installed. You can install matplotlib using the command `pip install matplotlib`. This library will be used for plotting the curves.

Writing the script

Create a new Python file named `plot_bal12.py`. This program will need to import necessary modules, accept command line arguments, compute the required values, and plot the graphs.

Importing libraries

In `plot_bal12.py`, import necessary libraries: `matplotlib.pyplot` for plotting and `sys` for command line argument handling: ```python import matplotlib.pyplot as plt import sys ```

Reading command line arguments

Using `sys.argv`, read the initial velocities provided from the command line. Convert these values to a list of floats: ```python v0_values = list(map(float, sys.argv[1:])) ```

Calculating and plotting each curve

Loop over each value of \( v_0 \), creating a time vector \( t \) from 0 to \( 2v_0/g \). Compute \( y(t) \) for each \( t \) and plot the curve:```pythonfor v0 in v0_values: g = 9.81 t_max = 2 * v0 / g t = np.linspace(0, t_max, num=100) y = v0 * t - 0.5 * g * t**2 plt.plot(t, y, label=f'v0={v0}')```

Finishing the plot

Add labels, title, and legend to the plot for clarity, then display it: ```python plt.xlabel('Time (t)') plt.ylabel('Height (y)') plt.title('Projectile Motion for different initial velocities v0') plt.legend() plt.show() ```

Key concepts

Command Line Arguments

Command line arguments are a way to provide input to a program while executing it via the command line interface. In Python, these inputs are accessed using the `sys` module. By using `sys.argv`, you can capture these arguments in your script.

• `sys.argv` is a list where the first element (`sys.argv[0]`) is the name of the script and the subsequent elements are the arguments provided.
• To convert these arguments from strings to a usable numeric format, use type conversion functions like `float` or `int`.

This capability is particularly useful when you need to change the parameters of a program without modifying its code, such as different initial velocities in the projectile motion problem.
For example, you might execute the script `plot_bal12.py` with various velocities by typing: `python plot_bal12.py 10 15 20`. Each number following the script name will be interpreted as an initial velocity.

Matplotlib

Matplotlib is a powerful plotting library in Python that provides a wide array of graphing capabilities. It is particularly well-suited for creating static, interactive, and animated visualizations in Python.

• To use Matplotlib for plotting data, you need to import `matplotlib.pyplot` as it provides the functions needed to create plots.
• Plots can be customized by adding titles, labels, legends, and by adjusting the axes.

To create a plot, you start by defining your data points or equations, like the projectile motion equation in this exercise. Using functions like `plt.plot()`, you can draw your curves onto a graph. After setting up your plot with labels and titles using `plt.xlabel()` and `plt.title()`, the `plt.show()` function will display your final graph. This visualization helps in understanding how different initial velocity values affect the trajectory of a projectile.

Projectile Motion

Projectile motion refers to the motion of an object that is thrown or projected into the air, subject to only the acceleration of gravity. The trajectory or path of such an object is typically a parabola.

• The equation of motion used in this problem \[ y(t) = v_0 t - 0.5 g t^2 \] describes vertical position as a function of time, where:
  • \( y(t) \) is the height at time \( t \).
  • \( v_0 \) is the initial velocity.
  • \( g \) is the acceleration due to gravity, a constant \( 9.81 \ m/s^2 \).
• This formula assumes no air resistance and that only gravity is acting on the object.

Understanding projectile motion is crucial in fields like physics and engineering, as it helps predict the path of an object based on initial conditions. By using different initial velocities in our Python script, we are able to visualize these different paths.

Numerical Calculation

Numerical calculation involves computing values using numerical methods rather than analytical solutions. In this exercise, we use numerical methods to calculate values of \( y(t) \) for various time points.

• The use of `numpy.linspace()` allows us to create a sequence of numbers over a specified interval. For example, it generates the time intervals from 0 to \( 2v_0/g \).
• Calculating \( y(t) \) involves applying the function over all values in this numerical array.

These calculations are essential for plotting because they provide the actual data points that are drawn on the graph. In plots involving physics or motion, such numerical methods are suitable as they allow for precision over discrete points, aiding in visualizing continuous processes or paths like trajectory curves.