Mesures de moment magnétique

La théorie est ici : I.1. Calcul du moment magnétique des projectiles.
On veut tracer $$\omega_0^2 = \frac{\mu B}{J}.$$ pour plusieurs valeurs de B, avec J connu pour l'aimant.
Le coefficient directeur nous donnera $\mu$.

Protocole Expérimental

Matériel :

Montage de TP de bobines de Helmhotz
Gaussmètre
Aimants
Etrier
Fil très fin sans torsion

Manip :

Utiliser l'étrier et le fil très fin sans torsion pour suspendre l'aimant entre les 2 bobines. Possible d'attacher le fil autour de l'aimant avec un bout de scotch.
Pendre l'aimant et repérer l'endroit où il tombe, placer la caméra.
Tracer un trait au marqueur sur l'aimant (si c'est une bille) pour repérer plus tard ses oscillations par vidéo
Allumer les bobines, fixer l'intensité, ça fixera le champ B induit
On va faire des vidéos pour différentes valeurs de B, donc avant chaque vidéo, ne pas oublier de mesurer le champ magnétique à l'endroit où sera pendu l'aimant
Allumer la caméra
Laisser descendre lentement l'aimant, une vidéo d'une trentaine de secondes est suffisante

Utilisation de Tracker pour mesurer la période

Ouvrir la vidéo avec Tracker - puis “Create” - “Point of Mass”
Maj-clic pour positionner un point, puis Tracker passe tout seul à la frame suivante
Suivre toujours le même point (on peut s'aider du marqueur tracé sur l'aimant)
Peu à peu la courbe des positions en fonction du temps prend forme, on voit apparaître des oscillations.

Ce n'est pas grave si elles ne sont pas centrées autour d'une valeur constante, tout ce qui nous intéresse est le nombre d'oscillations et la durée totales.

Exploitation des résultats pour extraire $\mu$

On utilise l'IDE Spyder pour coder en pyhton et tracer les graphs. Voici le code utilisé :

import numpy as np
import matplotlib.pyplot as plt
from scipy import optimize
 
#Petit cyclindre
m_pc = 2.442e-3
R_pc = 2.4e-3
h_pc = 17.0e-3
 
J_pc = m_pc/4*(R_pc**2+ h_pc**2/3)
print("J_pc = ", J_pc);
 
 
############    Resultats de Tracker pour le petit cylindre   ######
B = [0.11, 0.23, 0.33, 0.47, 0.60]#en milli testa
T = [10.281-6.255, 7.732-3.140, 7.952-3.560, 7.619 - 2.728, 5.724 - 0.068]
N_osc = [14.0, 24.0, 28.0, 37.0, 49.0]
 
X = []
Y = []
error_array = np.array([])
dT = 0.1 #incertitude pour les mesures de T
 
for (t, n, b) in zip(T, N_osc, B):
    Y.append((2*np.pi*n/t)**2)
    X.append(b*1e-3/J_pc)
    error_array = np.append(error_array, 2*2*np.pi*n*dT/(t**2))
 
X = np.array(X)
Y = np.array(Y)
 
plt.figure('Petit_cylindre')
plt.scatter(X, Y, c='black')
#plt.errorbar(X, Y, yerr=error_array) sert à rien, barres trop petites
plt.xlabel(r'$B / J$')
plt.ylabel(r'$\omega_0^2$')
plt.title("Pulsation caractéristique du petit cylindre dans le champ B")
 
 
def test_func(x, a, b):
    return a * x + b
 
params, params_covariance = optimize.curve_fit(test_func, X, Y, p0=[0,2.0])
plt.plot(X, test_func(X, *params), 'g--', label='fit: a=%5.3f, b=%5.3f' % tuple(params))
plt.legend(loc='best')
plt.show()

On obtient de magnifiques graphiques. Le moment magnétique correspond au coefficient directeur du fit, soit a.
Petite bille :
$\mu = 1.237 Nm/T$

Petit cylindre:
Ici on peut lire $\mu = 0.314 Nm/T$.

Gros cylindre :
$\mu = 1.413 Nm/T$

Accélération des projectiles

Nous allons maintenant mesurer l'accélération de ces 3 projectiles dans des conditions similaires, et voir si elle est proportionnelle au moment magnétique.
Nous avons suivi le protocole suivant I.3. Détermination de la vitesse pour traquer la position de la bille avec Tracker et Python pour en déduire l'accélération.
Voici le code utilisé :

import numpy as np
import matplotlib.pyplot as plt
from scipy import optimize
 
 
def plot_acc(time, pos, proj):
    plt.rc('text', usetex = True)
    plt.rc('font', family = 'serif', weight = 'bold')
 
    plt.figure('acc {0}'.format(proj))
    plt.scatter(time, pos, c='black')
    #plt.errorbar(time, pos, yerr=error_pos)
    plt.xlabel(r'$t$')
    plt.ylabel(r'$pos x$')
    plt.title('Accélération {0}'.format(proj))
 
    #fitting curve    
    params, params_covariance = optimize.curve_fit(func_exp, time, pos,
                                                   p0=[1.0, 0.1],
                                                   maxfev=2000)
    plt.plot(time, func_exp(time, *params), 'g--',
             label='fit: a*exp(b*t)   a=%2.5f, b=%3.3f' % tuple(params))
 
    plt.legend(loc='best')
    plt.show()
 
def func_parabole(t, a, b, c, d):
    return a*(t**3) + b*(t**2) + c*t + d
 
def func_exp(t, a, b):
    return a*np.exp(b*t)
 
############# Acceleration Bille ###################
 
t_bille =[8.908,	8.941,	8.974,	9.008,	9.041,	9.074,	9.108,	9.141]
x_pos_bille = [-4.981E-2, -4.813E-2, -4.543E-2, -4.155E-2, -3.616E-2, -2.520E-2, -1.087E-2, 2.689E-2]
#error_pos = [0.01, 0.04, 0.08, 0.1, 0.12, 0.3, 0.4, 0.5]
 
t_bille = np.array(t_bille)
t_bille = t_bille - 8.908
x_pos_bille = np.array(x_pos_bille)
x_pos_bille = x_pos_bille + 4.981E-2
 
#error_array = np.array([])
 
plot_acc(t_bille, x_pos_bille, 'bille')