FablabSU

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Mesures de moment magnétique ======
La théorie est ici : [[wiki:projet:l3phys2021:lu3py024g1:calcul-moment-magnetique|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 Helmholtz
  * 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.
{{:wiki:projet:l3phys2021:lu3py024g1:tracker_expl.png?nolink&|}}
\\
===== Exploitation des résultats pour extraire $\mu$=====
On utilise l'IDE Spyder pour coder en pyhton et tracer les graphs. Voici le code utilisé : \\

<code python>
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()
</code>

On obtient de magnifiques graphiques. Le moment magnétique correspond au coefficient directeur du fit, soit a.\\
__Petite bille__ :\\
{{:wiki:projet:l3phys2021:lu3py024g1:plot_mmagn_bille.png?nolink|}}
$\mu = 1.237 Nm/T$

__Petit cylindre__:\\
Ici on peut lire $\mu = 0.314 Nm/T$.\\
{{:wiki:projet:l3phys2021:lu3py024g1:plot_moment_magn.png?nolink|}}


__Gros cylindre__ :\\
{{:wiki:projet:l3phys2021:lu3py024g1:plot_mmagn_gros_cylindre.png?nolink|}}
$\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 "Autre détermination numérique de l'accélération" de   [[wiki:projet:l3phys2021:lu3py024g1:calcul-vitesses|I.3. Détermination de la vitesse]] pour traquer la position de la bille avec Tracker, puis scipy pour en déduire l'accélération.\\
Voici le code utilisé :\\
<code python>

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')
</code>

L'allure des graph de x(t) se rapproche d'une fonction exponentielle, nous utiliserons donc un fit de la forme $y(t) = a.exp(bt)$.\\
__Note importante__ : pour faire le fit par une fonction exponentielle, il vaut mieux translater la courbe pour qu'elle démarre à l'origine. Cela augmente considérablement la vitesse d’exécution de l'algorithme de fit de scipy.\\
Voici ce que nous obtenons avec la fonction curve_fit :\\
__Petite bille__:
{{ :wiki:projet:l3phys2021:lu3py024g1:accel_bille.png?nolink |}}
L'accélération est donc : $ a(t) = a.b^2.exp(bt)$.\\
Ce qui nous donne ici : $a(t) \approx 0.38exp(17.8t)$ pour $\mu = 1.237 Nm/T$.\\

__Petit cylindre__:
{{ :wiki:projet:l3phys2021:lu3py024g1:accel_petit_cyl.png?nolink |}}

L'accélération est donc : $a(t) \approx 0.09exp(14t)$ pour $\mu = 0.314 Nm/T$.\\

__Gros cylindre__:
{{ :wiki:projet:l3phys2021:lu3py024g1:accel_gros_cyl.png?nolink |}}

L'accélération est donc : $a(t) \approx 0.01.exp(15t)$ pour $\mu = 1.413 Nm/T$.\\

====== Conclusion ======
Puisque nous voulions étudier l'accélération en fonction de $\mu$ :
  * $\mu_{pc} = 0.314 Nm/T$     |  $a(t) \approx 0.09exp(14t)$
  * $\mu_{bille} = 1.237 Nm/T$  |  $a(t) \approx 0.38exp(17.8t)$
  * $\mu_{gc} = 1.413 Nm/T$     |  $a(t) \approx 0.01.exp(15t)$

- Il semblerait que ce ne soit pas le moment magnétique qui ait l'influence la plus importante sur l'accélération, en effet il est difficile de voir une relation hiérarchique claire à partir de ces 3 valeurs.
Cependant en comparant deux aimants de géométries équivalentes, les deux cylindres, on remarque que c'est le petit qui parcourt $\Delta x=8cm$ le plus vite, malgré un moment magnétique presque 5 fois plus faible, ce qui infirme l'hypothèse de départ (snif).\\
- En revanche il est intéressant de voir que c'est la petite bille qui passe de $x = 0cm$ à $x = 8cm$ le plus rapidement, en $t \approx 230ms$. Nous pensons que l'étude des frottements, qui devraient être minimaux pour la bille, permettra d'expliquer ces graphiques de manière plus probante.
FablabSU

Outils pour utilisateurs

Outils du site

Outils de la page
