<jupyter_start><jupyter_text>Moto di un proiettileUn oggetto viene lanciato con una velocità iniziale $ v_0 $ di $ 6~m/s $. L'angolo che il vettore $ \vec{v}_0 $ forma con la direzione orizzontale è $ \theta_0 = \pi / 6 $.Calcolare la gittata, il tempo di volo e la massima altezza raggiunta. Discussione del problemaTrascurando la resistenza dell'aria e considerando che il moto avviene con accelerazione costante uguale all'accelerazione di gravità $ \vec{g} $, si ottengono le equazioni che descrivono la posizione dell'oggetto, considerato per semplicità come un **punto materiale**, in funzione del tempo. Da queste equazioni si possono ricavare le equazioni per:* La **gittata**:$$ R = \dfrac{v_0^2}{g} \cdot \sin (2 \theta_0) $$* Il **tempo di volo**:$$ t_{volo} = \dfrac{2 \cdot [v_0 \cdot \sin (\theta_0)]}{g} $$* L'**altezza massima**:$$ h = \dfrac{[v_0 \cdot \sin (\theta_0)]^2}{g} $$ Calcoli con PythonPer effettuare i calcoli utilizziamo la libreria **NumPy** mentre per rappresentare graficamente le grandezze che caratterizzano il moto in questo esempio utilizziamo la libreria **Matplotlib**.<jupyter_code># Utilizzato per importare la libreria adoperata per i grafici.
import matplotlib.pyplot as plt
# Utilizzato per importare la libreria adoperata per le strutture e le funzioni matematiche.
import numpy as np


vi = 6 # Velocità iniziale in m/s.
theta0 = np.pi / 4 # Angolo tra il vettore velocità iniziale e la direzione orizzontale in radianti.
g = 9.8 # Accelerazione di gravità in m/s^2.
R = (vi ** 2) * np.sin(2 * theta0) / g # Gittata in m.
tv = 2 * vi * np.sin(theta0) / g # Tempo di volo in s.
h = ((vi * np.sin(theta0)) ** 2) / g # Altezza massima in m.

print("Gittata = {0:0.3f} m".format(R)) # Utilizzato per stampare.
print("Tempo di volo = {0:0.3f} s".format(tv)) # Utilizzato per stampare.
print("Altezza massima = {0:0.3f} m".format(h)) # Utilizzato per stampare.<jupyter_output>Gittata = 3.673 m
Tempo di volo = 0.866 s
Altezza massima = 1.837 m<jupyter_text>Studio del moto: equazioni orarie e traiettoriaLe equazioni orarie forniscono il valore di ciascuna delle coordinate del punto materiale in funzione del tempo. In questo esempio:$$ x(t) = v_{0x} \cdot t $$$$ y(t) = (v_{0y} \cdot t) - (\dfrac{g \cdot t^2}{2}) $$Dove $ v_{0x} $ e $ v_{0y} $ sono le componenti del vettore velocità iniziale $ \vec{v}_0 $ rispetto agli assi cartesiani $ x $ e $ y $.$$ v_{0x} = v_0 \cdot \cos (\theta_0) $$$$ v_{0y} = v_0 \cdot \sin (\theta_0) $$* Possiamo utilizzare le equazioni $ x(t) $ e $ y(t) $ come equazioni parametriche per la **traiettoria**.* Infatti possiamo considerare un **array** di valori di $ t $ compresi tra l'istante iniziale $ t = 0 $ e un istante finale che per semplicità scegliamo coincidente con il *tempo di volo* $ t_v $.    * Per generare l'array di valori distribuiti in modo lineare tra $ 0 $ e $ t_v $ utilizziamo la funzione **linspace()** della           libreria **NumPy**.* Calcoliamo le coordinate $ x $ e $ y $ in corrispondenza a ciascuno dei valori di $ t $ compresi nell'array.* Riportiamo in grafico i punti corripondenti alle coppie di coordinate $ x, y $ per ciascun valore di $ t $ per ottenere così il grafico della traiettoria.     * E' importante che l'asse $ x $ e l'asse $ y $ abbiano la stessa unità di misura e la stessa scala.<jupyter_code># Utilizzato per generare un array di valori distribuiti in modo lineare.
t = np.linspace(0, tv, 128)
x = vi * np.cos(theta0) * t # Equazione per la coordinata x.
y = vi * np.sin(theta0) * t - 0.5 * g * t ** 2 # Equazione per la coordinata y.

# Utilizzato per il grafico.
plt.figure(1, figsize = (15, 15)) # Utilizzato per creare, numerare e dimensionare il grafico.
# Utilizzato per il titolo.
plt.title("Moto di un proiettile - Traiettoria", fontdict = {"fontsize": 17.5}, pad = 10)
# Utilizzato per l'asse x.
plt.xlabel("$ x~(m) $", fontdict = {"fontsize": 12.5})
# Utilizzato per l'asse y.
plt.ylabel("$ y~(m) $", fontdict = {"fontsize": 12.5})
# Utilizzato per rappresentare le coordinate x e y.
plt.plot(x, y, color = "#0075E2")
# Utilizzato per il testo della legenda.
testo = "$ v_i $ = {0:0.3f} $ m/s $".format(vi) + "\n" + r"$ \theta_0 $ = {0:0.3f} $ deg $".format(theta0 * 180 / np.pi)
# Utilizzato per la legenda.
plt.text(R / 2, 0.1, testo, horizontalalignment = "center", verticalalignment = "bottom", fontdict = {"fontsize": 12.5}, bbox = dict(facecolor = "#0075E2"))
# Utilizzato per la griglia.
plt.grid(True)
# Utilizzato per avere gli assi con la stessa scala.
plt.gca().set_aspect("equal", adjustable = "box")
# Utilizzato per mostrare il grafico.
plt.show()<jupyter_output><empty_output><jupyter_text>Dipendenza dall'angolo di lancio $ \theta_0 $Consideriamo la traiettoria che si ottiene in corrispondenza a valori diversi dell'angolo di lancio $ \theta_0 $ mantenendo costante il modulo della velocità iniziale $ v_i $.* Produciamo un array di valori di $ \theta_0 $ utilizzando la funzione **arange()** della libreria **NumPy**.* Riportiamo in grafico le traiettorie corrispondenti a tutti i valori di $ \theta_0 $.<jupyter_code>theta0grad = np.arange(10, 90, 5) # Utilizzato per generare un array.
theta0 = theta0grad * np.pi / 180 # Angolo in radianti.

# Utilizzato per il grafico.
fig = plt.figure(2, figsize = (15, 15)) # Utilizzato per creare, numerare e dimensionare il grafico.
# Utilizzato per il titolo.
plt.title("Moto di un proiettile - Traiettorie con diverse angolazioni", fontdict = {"fontsize": 17.5}, pad = 10)
# Utilizzato per l'asse x.
plt.xlabel("$ x~(m) $", fontdict = {"fontsize": 12.5})
# Utilizzato per l'asse y.
plt.ylabel("$ y~(m) $", fontdict = {"fontsize": 12.5})

# Funzione.
for angle in theta0:
    tv = 2 * vi * np.sin(angle) / g # Tempo di volo in s.
    t = np.linspace(0, tv, 128) # Utilizzato per generare un array di valori distribuiti in modo lineare.
    x = vi * np.cos(angle) * t # Equazione per la coordinata x.
    y = vi * np.sin(angle) * t - 0.5 * g * t ** 2 # Equazione per la coordinata y.
    plt.plot(x, y) # Utilizzato per rappresentare le coordinate x e y.

    '''
    # Utilizzato per stampare i valori numerici.
    R = ((vi ** 2) / g) * (np.sin(2 * angle)) # Gittata in m.
    t = 2 * ((vi * np.sin(angle)) / g) # Tempo di volo in s.
    h = ((vi * np.sin(angle)) ** 2) / (2 * g) # Altezza massima in m.

    print("Angolo di {0:0.1f} gradi".format(np.degrees(angle))) # Utilizzato per stampare.
    print("Gittata = {0:0.3f} m".format(R)) # Utilizzato per stampare.
    print("Tempo di volo = {0:0.3f} s".format(t)) # Utilizzato per stampare.
    print("Altezza massima = {0:0.3f} m \n".format(h)) # Utilizzato per stampare.
    '''

# Utilizzato per la legenda.
plt.text(3.0, 1.50, "$ v_i $ = {0:0.1f} $ m/s $".format(vi), horizontalalignment = "center", verticalalignment = "bottom", fontdict = {"fontsize": 12.5}, bbox = dict(facecolor = "#0075E2"))
# Utilizzato per salvare il grafico in un file.
#plt.savefig("Traiettorie.pdf")
# Utilizzato per la griglia.
plt.grid(True)
# Utilizzato per avere gli assi con la stessa scala.
plt.gca().set_aspect("equal", adjustable = "box")
# Utilizzato per mostrare il grafico.
plt.show()<jupyter_output><empty_output><jupyter_text>Get a feel ofCosa cambia al variare dell'angolo di lancio $ \theta_0 $?* Gittata.* Tempo di volo.* Altezza massima.Angoli complementari (per esempio 30° e 60°) danno la stessa gittata ma il tempo di volo e l'altezza massima sono diversi. Simulazione e previsioneScegliendo di far variare l'angolo $ \theta_0 $ a passi di $ 1 $ grado, si delinea una *curva inviluppo* che delimita la regione i cui punti  non sono raggiunti da nessuna traiettoria , qualunque sia l'angolo di lancio $ \theta_0 $, per una data velocità iniziale $ v_0 $.Questa curva prende il nome di **parabola di sicurezza**, descritta dall'equazione:$$ y = \dfrac{v_0^2}{2 g} - (\dfrac{g \cdot x^2}{2 v_0^2}) $$Nello script seguente produciamo un grafico contenente:* Le varie traiettorie corrispondenti a valori di $ \theta_0 $ incrementati a passi di $ 1 $ grado.* La parabola di sicurezza.<jupyter_code>theta0grad = np.arange(10, 90, 1) # Utilizzato per generare un array.
theta0 = theta0grad * np.pi / 180 # Angolo in radianti.

# Utilizzato per il grafico.
fig = plt.figure(3, figsize = (15, 15)) # Utilizzato per creare, numerare e dimensionare il grafico.
# Utilizzato per il titolo.
plt.title("Moto di un proiettile - Parabola di sicurezza", fontdict = {"fontsize": 17.5}, pad = 10)
# Utilizzato per l'asse x.
plt.xlabel("$ x~(m) $", fontdict = {"fontsize": 12.5})
# Utilizzato per l'asse y.
plt.ylabel("$ y~(m) $", fontdict = {"fontsize": 12.5})

# Funzione.
for angle in theta0:
    tv = 2 * vi * np.sin(angle) / g # Tempo di volo in s.
    t = np.linspace(0, tv, 128) # Utilizzato per generare un array di valori distribuiti in modo lineare.
    x = vi * np.cos(angle) * t # Equazione per la coordinata x.
    y = vi * np.sin(angle) * t - 0.5 * g * t ** 2 # Equazione per la coordinata y.
    plt.plot(x, y) # Utilizzato per rappresentare le coordinate x e y.

# Utilizzato per la legenda.
plt.text(3.0, 1.50, "$ v_0 $ = {0:0.1f} m/s".format(vi), horizontalalignment = "center", verticalalignment = "bottom", fontdict = {"fontsize": 12.5}, bbox = dict(facecolor = "#0075E2"))
# Utilizzato per salvare il grafico in un file.
#plt.savefig("Parabola.pdf")

Rmax = R = (vi ** 2) / g # Gittata massima in m.
xx = np.linspace(0, Rmax, 180) # Utilizzato per generare un array di valori distribuiti in modo lineare per la coordinata x della parabola di sicurezza.
yy = vi * vi / (2 * g) - 0.5 * g * xx * xx / (vi * vi) # Utilizzato per calcolare la coordinata y della parabola di sicurezza.

# Utilizzato per rappresentare le coordinate x e y e per colorare la curva.
plt.plot(xx, yy, linewidth = 4, color = "#0075E2")
# Utilizzato per la griglia.
plt.grid(True)
# Utilizzato per avere gli assi con la stessa scala.
plt.gca().set_aspect("equal", adjustable = "box")
# Utilizzato per mostrare il grafico.
plt.show()<jupyter_output><empty_output><jupyter_text>> Per eseguire il codice Python contenuto in questo **notebook** Jupyter, anche se Python e Notebook Jupyter non sono installati sulla macchina che stai adoperando, puoi utilizzare l'ambiente [**binder**](https://mybinder.org) online.[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/Darkaquon/Physics-with-Open-Source-Software/master?filepath=%2FNotebook%2FMoto_proiettile.ipynb) What we have learned*Python** Generare un array di valori distribuiti uniformemente in un certo intervallo.* Costruire un grafico con le stesse scale per i due assi.* Iterazioni con il ciclo **for**.*Fisica** Parametri che caratterizzano il moto di un proiettile.* Determinazione della traiettoria.* Dipendenza dall'angolo di lancio. References and notes Python1. Matplotlib 3.3.1 documentation on [pyplot.figure](https://matplotlib.org/3.3.1/api/_as_gen/matplotlib.pyplot.figure.html)2. [matplotlib.text](https://matplotlib.org/3.3.1/api/text_api.html) class for including text in a figure.3. [matplotlib.pyplot.xlim](https://matplotlib.org/api/_as_gen/matplotlib.pyplot.xlim.html) get or set the x limits of the current axes.4. [Pyplot documentation](https://matplotlib.org/api/pyplot_api.htmlmatplotlib.pyplot.scatter)5. [Matplotlib tutorials](https://matplotlib.org/tutorials/intermediate/imshow_extent.htmlsphx-glr-tutorials-intermediate-imshow-extent-py) Immagini6. Figura 1. Immagine del volo di una pallina da ping pong ottenuta da un video registrato con uno smartphone Samsung Galaxy S9 in modalità rallentatore ed analizzato con il software [**Tracker**](https://physlets.org/tracker). Grafica notebook<jupyter_code># Utilizzato per importare la libreria adoperata per visualizzare l'HTML con il Python.
from IPython.core.display import HTML


css_file = "Notebook.css" # File CSS.

# Utilizzato per aprire e leggere il file CSS adoperato per modificare la visualizzazione del notebook.
HTML(open(css_file, "r").read())<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1275795805831732, 'fraction_numerical': 0.024563455593616845, 'mean_word_length': 4.229357798165138, 'pattern_counts': {'":': 12, '<': 20, '<?xml version=': 0, '>': 21, 'https://': 9, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '5', 'dir': 'jupyter-structured-clean-dedup', 'id': '307924', 'license': 'BSD-3-Clause', 'n_tokens_mistral': 4615, 'n_tokens_neox': 4419, 'n_words': 1453, 'path': 'Notebook/Moto_proiettile.ipynb', 'repo_name': 'Darkaquon/Tesi', 'size': '11969'}