Relativistic Lagrangian for a free Particle¶

da PowerShell -- jupyter nbconvert --to html notebook.ipynb

Particella in moto a velocità relativistiche¶

L'esercizio ha lo scopo di introdurre alcuni concetti fondamentali della $\textbf{meccanica relativistica}$ attraverso un'implementazione numerica in linguaggio Python. In particolare, vengono analizzate le grandezze dinamiche di una particella libera che si muove a velocità confrontabili con quella della luce.

Fattore di Lorentz¶

A partire dal modulo della velocità $v$, viene calcolato il fattore di Lorentz $$\large \gamma = \frac{1}{\sqrt{1 - \frac{v^2}{c^2}}}, $$ che quantifica gli effetti relativistici dovuti al moto della particella. Tale fattore compare in tutte le principali grandezze dinamiche del sistema.

Momento relativistico¶

Il momento relativistico di una particella di massa a riposo $m$ e velocità vettoriale $\mathbf{v}$ è definito come $$\large \mathbf{p} = \gamma m \mathbf{v}. $$ Il codice calcola questa quantità utilizzando il fattore di Lorentz associato al modulo della velocità, restituendo un vettore momento tridimensionale.

Energia relativistica¶

L'energia totale relativistica della particella è data da $$\large E = \gamma m c^2. $$ Questa espressione include sia l'energia di riposo sia il contributo cinetico relativistico e rappresenta una generalizzazione dell'energia classica valida per alte velocità.

Lagrangiana relativistica¶

Per una particella libera, la lagrangiana relativistica assume la forma $$\large \mathcal{L} =m c^2 \sqrt{1 - \frac{v^2}{c^2}}.$$ Essa dipende unicamente dalla velocità della particella e garantisce l'invarianza relativistica dell'azione.

Azione ed equazione di Eulero--Lagrange

Il codice introduce inoltre il concetto di $\textbf{azione}$ e della sua variazione, calcolata numericamente tramite una differenza finita simmetrica. In questo modo viene approssimata l'equazione di Eulero--Lagrange $$\large \frac{d}{dt} \left( \frac{\partial \mathcal{L}}{\partial \dot{x}} \right)\frac{\partial \mathcal{L}}{\partial x} = 0, $$ che rappresenta la legge fondamentale del moto nel formalismo lagrangiano.

Conclusione¶

L'esercizio mostra come le principali grandezze della relatività ristretta — fattore di Lorentz, momento, energia e lagrangiana — possano essere calcolate numericamente e collegate al principio di minima azione, fornendo un ponte tra formulazione teorica e implementazione computazionale.

In [22]:
import numpy as np 

def lorentz_factor(v, c=3e8):
    """
    Calculate the Lorentz factor.
        :param v: Velocity magnitude.
        :param c: Speed of light.
    :return: 
        Lorentz factor.
    """
    return 1 / np.sqrt(1 - (v**2 / c**2))

def relativistic_momentum(m, v, c=3e8):
    """
    Calculate the relativistic momentum.
        :param m: Rest mass.
        :param v: Velocity vector.
        :param c: Speed of light.
    :return: 
        Momentum vector.
    """
    gamma = lorentz_factor(np.linalg.norm(v), c)
    return gamma * m * v

def relativistic_energy(m, v, c=3e8):
    """
    Calculate the relativistic energy.
        :param m: Rest mass.
        :param v: Velocity magnitude.
        :param c: Speed of light.
    :return: 
        Energy.
    """
    gamma = lorentz_factor(v, c)
    return gamma * m * c**2

def varied_action(x, L_func):
    """
    Calculate the variation of the action for a path.
        :param x: Path coordinates.
        :param L_func: Lagrangian function.
    :return: 
        Variation of action.
    """
    epsilon = 1e-5
    return L_func(x + epsilon) - L_func(x - epsilon) 

def euler_lagrange_equation_rel(L_func, x):
    """
    Solve Euler-Lagrange equation in relativistic mechanics.
        :param L_func: Lagrangian function for the system.
        :param x: Path or coordinate.
    :return: 
        Result of Euler-Lagrange equation.
    """
    return varied_action(x, L_func) / (2 * 1e-5) 

def relativistic_lagrangian(m, x, v, c=3e8):
    """
    Relativistic Lagrangian for a free particle.
        :param m: Mass of the particle.
        :param x: Position vector.
        :param v: Velocity magnitude.
        :param c: Speed of light.
    :return: 
        Lagrangian value.
    """
    return -m * c**2 * np.sqrt(1 - (v**2 / c**2)) 

# Example usage
#m = 1.0e-10 # kg
#x = np.array([1.0, 2.0, 3.0]) # m
#v = np.array([0.7, 0.6, 0.0]) * 3e8 # m/s
m = 9.11e-31  # kg
x = np.array([0.0, 0.0, 0.0])  # m, posizione iniziale
v = np.array([0.1, 0.2, 0.0]) * 3e8  # m/s, tipico velocità relativistica moderata
gamma = lorentz_factor(np.linalg.norm(v))
momentum = relativistic_momentum(m, v)
energy = relativistic_energy(m, np.linalg.norm(v))
lagrangian = relativistic_lagrangian(m, x, np.linalg.norm(v))

print("Lorentz Factor:", gamma)
print("Relativistic Momentum:", momentum)
print("Relativistic Energy:", energy)
print("Relativistic Lagrangian:", lagrangian)

a=1

Lorentz Factor: 1.0259783520851542
Relativistic Momentum: [2.80399884e-23 5.60799767e-23 0.00000000e+00]
Relativistic Energy: 8.41199650874618e-14
Relativistic Lagrangian: -7.991396683308869e-14
In [ ]: