Introducción a Magpylib

Modelos simples de una bobina

Laboratorio de Electricidad y Magnetismo

Objetivos de la clase

  • Usar Magpylib en problemas simples de magnetostática.
  • Construir una bobina de dos maneras distintas.
  • Comparar un modelo simplificado con uno más detallado.
  • Visualizar el campo en mapas 2D y sobre el eje.
  • Dejar un ejemplo extra con un imán cilíndrico.

Unidades y cambios respecto de materiales viejos

En Magpylib 5 conviene trabajar en SI:

  • longitud en m
  • corriente en A
  • campo en T

En los gráficos mostraremos a menudo:

  • distancia en mm o cm
  • campo en mT

Además:

  • magpy.current.Loop → magpy.current.Circle
  • magpy.current.Line → magpy.current.Polyline

Entorno recomendado

  • Local: pixi install
  • Notebook: pixi run lab
  • Diapositivas: pixi run render-slides
  • Colab: subir el notebook y ejecutar en orden

Imports

import magpylib as magpy
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

plt.style.use('seaborn-v0_8-whitegrid')
print('Magpylib versión:', magpy.__version__)
Magpylib versión: 5.2.3

Bobina simplificada con Collection

La aproximación más simple consiste en representar la bobina como varias espiras circulares iguales distribuidas sobre el eje z.

corriente = 10.0   # A
diametro = 0.010  # m
largo = 0.016     # m
n_espiras = 16

bobina_simple = magpy.Collection()

for z in np.linspace(-largo/2, largo/2, n_espiras):
    espira = magpy.current.Circle(
        current=corriente,
        diameter=diametro,
        position=(0, 0, z),
    )
    bobina_simple.add(espira)

print('Objeto creado:', bobina_simple)
print('Cantidad de espiras:', len(bobina_simple.children))
Objeto creado: Collection(id=2199025618768)
Cantidad de espiras: 16

Bobina más precisa con Polyline

Ahora representamos el conductor como una hélice.

t = np.linspace(0, n_espiras*2*np.pi, 1200)
radio = diametro/2
z_helice = np.linspace(-largo/2, largo/2, t.size)

vertices = np.c_[
    radio*np.cos(t),
    radio*np.sin(t),
    z_helice,
]

bobina_helicoidal = magpy.current.Polyline(
    current=corriente,
    vertices=vertices,
)

print('Objeto creado:', bobina_helicoidal)
print('Cantidad de vértices usados:', len(vertices))
Objeto creado: Polyline(id=2199025630800)
Cantidad de vértices usados: 1200

Preparar una grilla para comparar ambos modelos

xs = np.linspace(-0.02, 0.02, 41)
zs = np.linspace(-0.02, 0.02, 41)
grid = np.array([[(x, 0, z) for x in xs] for z in zs])

B_simple = magpy.getB(bobina_simple, grid)
B_helice = magpy.getB(bobina_helicoidal, grid)

Bamp_simple = np.linalg.norm(B_simple, axis=2)
Bamp_helice = np.linalg.norm(B_helice, axis=2)

Bamp_simple_norm = Bamp_simple / Bamp_simple.max()
Bamp_helice_norm = Bamp_helice / Bamp_helice.max()

X_mm = grid[:, :, 0] * 1000
Z_mm = grid[:, :, 2] * 1000

Comparación visual en el plano xz

Campo sobre el eje de la bobina

z_eje = np.linspace(-0.03, 0.03, 200)
puntos_eje = np.c_[np.zeros_like(z_eje), np.zeros_like(z_eje), z_eje]

Bz_simple = magpy.getB(bobina_simple, puntos_eje)[:, 2]
Bz_helice = magpy.getB(bobina_helicoidal, puntos_eje)[:, 2]

Perfil axial Bz(z)

Medición en puntos sobre el eje

puntos_medicion = np.array([
    (0.0, 0.0, -0.020),
    (0.0, 0.0, -0.010),
    (0.0, 0.0,  0.000),
    (0.0, 0.0,  0.010),
    (0.0, 0.0,  0.020),
])

B_simple_pts = magpy.getB(bobina_simple, puntos_medicion)
B_helice_pts = magpy.getB(bobina_helicoidal, puntos_medicion)

tabla = pd.DataFrame({
    'z [mm]': puntos_medicion[:, 2]*1000,
    'Bz simple [mT]': B_simple_pts[:, 2]*1000,
    'Bz helicoidal [mT]': B_helice_pts[:, 2]*1000,
})

tabla
z [mm] Bz simple [mT] Bz helicoidal [mT]
0 -20.0 0.401836 0.385087
1 -10.0 4.021168 3.719520
2 0.0 10.168379 10.658014
3 10.0 4.021168 3.719520
4 20.0 0.401836 0.385087

Qué discutir con estos dos modelos

  1. ¿Cuándo alcanza un modelo simplificado?
  2. ¿Qué ganamos y qué perdemos con el modelo helicoidal?
  3. ¿Cómo cambia el campo si aumentamos la corriente?
  4. ¿Qué cambia si modificamos el número de espiras?
  5. ¿Qué efecto tiene usar más o menos vértices en la hélice?

Ejemplo extra: imán cilíndrico

iman = magpy.magnet.Cylinder(
    polarization=(0, 0, 1.2),
    dimension=(0.015, 0.005),
)

print('Objeto creado:', iman)
print('Polarización [T]:', iman.polarization)
print('Dimensiones [m]:', iman.dimension)
print('Posición [m]:', iman.position)
Objeto creado: Cylinder(id=2199047366352)
Polarización [T]: [0.  0.  1.2]
Dimensiones [m]: [0.015 0.005]
Posición [m]: [0. 0. 0.]

Campo del imán sobre su eje

z_iman = np.linspace(0.005, 0.12, 200)
puntos_iman = np.c_[np.zeros_like(z_iman), np.zeros_like(z_iman), z_iman]
B_iman = magpy.getB(iman, puntos_iman)

Perfil axial del imán

Mapa de campo del imán

Cierre

  • Collection permite construir una bobina por superposición de espiras.
  • Polyline permite modelar una geometría más detallada.
  • Los dos enfoques sirven, pero responden a objetivos distintos.
  • La simulación no reemplaza la física: ayuda a pensarla mejor.