APROCEAN

 

Desafiando los límites computacionales en la ciencia: el ejemplo del electromagnetismo

Caso práctico: Simulación para detección electromagnética de minas submarinas con AUV

Autor: Salvador Lechuga Lombos + IA

Resumen de la noticia:

Desafiando los límites computacionales en la ciencia: el ejemplo del electromagnetismo: https://theconversation.com/desafiando-los-limites-computacionales-en-la-ciencia-el-ejemplo-del-electromagnetismo-224657?utm_medium=email&utm_campaign=Novedades%20del%20da%2029%20julio%202025%20en%20The%20Conversation%20-%203469335326&utm_content=Novedades%20del%20da%2029%20julio%202025%20en%20The%20Conversation%20-%203469335326+CID_00a9ba374459769f2e3f08bebee00316&utm_source=campaign_monitor_es&utm_term=Desafiando%20los%20lmites%20computacionales%20en%20la%20ciencia%20el%20ejemplo%20del%20electromagnetismo

Resumen y reflexión basada en el artículo “Desafiando los límites computacionales en la ciencia: el ejemplo del electromagnetismo” (publicado en The Conversation el 30 de julio de 2025):

---

🔬 Resumen del artículo

1. El reto del electromagnetismo:
   La simulación de fenómenos electromagnéticos complejos supera ampliamente la capacidad de resolución analítica. Las ecuaciones de Maxwell en geometrías reales requieren técnicas numéricas avanzadas: elementos finitos (FEM), diferencias finitas (FDTD), método de los momentos (MoM), entre otras X (formerly Twitter)+1Yahoo Noticias+1Wikipedia+1Wikipedia+1.

2. Límites computacionales fundamentales:
   Problemas que requieren procesar cantidades enormes de datos—por encima del límite de Bremermann (~10^93 bits)—son imposibles de resolver incluso con recursos teóricos ilimitados Wikipedia+1Wikipedia+1.

3. Modelos y aproximaciones pragmáticas:
   Se usan modelos cuasiestáticos como el modelo electro‑cuasiestático (EQS) y magneto‑cuasiestático (MQS), y modelos híbridos como el de Darwin, para reducir la complejidad sin perder precisión en frecuencias altas MDPI+1EurekAlert!+1.

4. Sobrecarga de la malla (mesh):
   Cuanto más detallado el mallado, mayor demanda de memoria y procesamiento. Por eso se desarrolla refinamiento adaptativo e implementación paralela (clústeres de alto rendimiento, GPUs) para abordar simulaciones grandes Wikipedia+3X (formerly Twitter)+3elpais.com+3.

5. Ejemplos científicos relevantes:
   El artículo destaca estudios recientes —como un enfoque adaptativo para mejorar la eficiencia de FEM o el uso de técnicas híbridas—que permiten extender el límite práctico de la simulación electromagnética energy.gov+5MDPI+5phys.org+5.

---

Reflexión y contexto más amplio

• ¿Qué implica esto en la ciencia actual?
  El electromagnetismo es un campo donde los límites computacionales se combinan con desafíos físicos: incluso con hardware avanzado, ciertos problemas siguen siendo inalcanzables porque exceden lo que puede procesarse en tiempos razonables.

• El rol de los modelos aproximados:
  Utilizar teorías como EQS, MQS o Darwin permite resolver casos útiles sin resolver el problema completo. Esto demuestra que en ciencia no siempre se busca la precisión absoluta, sino la utilidad práctica dentro de límites razonables.

• Más allá de lo electromagnético:
  Los mismos límites aparecen en otras áreas: simulaciones cuánticas, dinámica molecular, cosmología. Por ejemplo, estudiar sistemas con varios nucleones o moléculas grandes escapa a la capacidad contemporánea por su complejidad exponencial phys.org.

• Cuestiones filosóficas y teóricas:
  La idea de "problemas transcomputacionales" conecta con debates más amplios sobre los límites de la computación y la capacidad de la ciencia para simular el mundo real WikipediaWikipediathequantumrecord.com.

---

🧮 En resumen

• La ciencia computacional en electromagnetismo enfrenta límites imposibles de superar por fuerza bruta debido a la escala astronómica de cálculos necesarios.

• Por ello, se recurre a modelos aproximados, técnicas numéricas avanzadas y HPC (computación de alto rendimiento).

• El artículo de The Conversation destaca cómo estos métodos permiten avanzar en ciencia real sin esperar a una supuesta "solución exacta" que puede no ser computacionalmente alcanzable.

• El enfoque es esencialmente pragmático: medir qué podemos calcular con confianza, no qué sería ideal calcular teóricamente.

Aplicaciones en el medio marino

Las aplicaciones del electromagnetismo computacional en el medio marino son diversas, fundamentales tanto para fines científicos como tecnológicos y de defensa. A continuación te presento un desglose claro, con ejemplos concretos donde se desafían los límites computacionales en entornos oceánicos:

---

⚓ Aplicaciones del electromagnetismo computacional en el medio marino

1. Comunicaciones submarinas electromagnéticas

• Problema: Las ondas electromagnéticas de alta frecuencia no se propagan bien en el agua de mar por su alta conductividad (~4 S/m).

• Aplicación: Simulación de propagación de ondas en muy baja frecuencia (VLF) para submarinos o nodos de sensores.

• Técnicas: Métodos como FDTD (diferencias finitas en el dominio del tiempo) y FEM (elementos finitos) modelan cómo las ondas interactúan con capas de agua, sedimentos y estructuras metálicas.

• Desafíos computacionales: Simular dominio grande (océano), heterogéneo (corteza, agua, aire), con dispersión y pérdida energética.

---

2. Detección y caracterización de objetos sumergidos (imanes, minas, cables)

• Aplicación militar y civil: Localizar minas, cables de comunicaciones, o estructuras hundidas.

• Técnica: Modelos de respuesta electromagnética ante campos alternos (técnicas de inducción electromagnética).

• Simulación: El comportamiento de un campo magnético variable frente a objetos ferromagnéticos o conductores sumergidos se simula con ecuaciones de Maxwell y modelos magneto-cuasiestáticos (MQS).

• Ejemplo: Sonar electromagnético o EM gradiometers en drones submarinos (AUVs).

---

3. Prospección geofísica submarina

• Exploración de recursos: Gas, petróleo, nódulos polimetálicos, acuíferos fósiles.

• Método CSEM (Controlled-Source Electromagnetic):

  • Se emite un campo electromagnético controlado desde un barco o un ROV.

  • Se mide la respuesta para inferir la resistividad de los fondos marinos.

• Simulación FEM/FDTD 3D: Modelos complejos con capas de sedimentos, estructuras geológicas, agua y salmueras.

• Desafío computacional: Requiere mallado adaptativo muy fino y HPC para abarcar escalas grandes con precisión local.

---

4. Protección catódica y corrosión en estructuras submarinas

• Estructuras: Oleoductos, plataformas offshore, cascos de barcos.

• Objetivo: Simular el comportamiento del campo eléctrico aplicado que protege las superficies metálicas contra la corrosión.

• Modelado: Ecuaciones de potencial eléctrico en medios conductivos (agua de mar) y estructuras.

• Software: Simulación electromagnética + química (multifísica).

---

5. Sistemas de energía submarina y transmisión

• Aplicación: Cables de alta tensión submarinos (interconexiones eléctricas entre islas o plataformas).

• Modelos electromagnéticos: Simulación de pérdidas, inductancia mutua, efectos de piel (skin effect), y acoplamiento capacitivo con el agua.

• Optimización: Reducción de pérdidas y mitigación de efectos ambientales.

---

6. Navegación e interferencias magnéticas

• Aplicación: Navegación de submarinos y AUVs mediante magnetómetros.

• Problema: Interferencia del propio sistema, corrientes inducidas, distorsión del campo magnético terrestre por estructuras metálicas.

• Simulación: Modelado de campos magnéticos perturbados para compensar errores y mejorar precisión.

---

🧠 ¿Qué se necesita computacionalmente?

• Dominios gigantescos (cientos de km²) en entornos heterogéneos (agua, sedimentos, estructuras).

• Alta resolución local (p.ej., para modelar un cable, una mina o una interfaz dieléctrica).

• Modelos híbridos EQS/MQS/Darwin para reducir cargas sin perder física esencial.

• Computación paralela y adaptativa, con uso de GPUs, clústeres HPC y refinamiento dinámico de malla.

---

🔧 Ejemplos reales y software empleado

Aplicación	Software común	Técnica numérica
CSEM (exploración geofísica)	COMSOL, PETGEM, SimPEG	FEM, integral de volumen
Comunicación submarina	FEKO, CST, OpenEMS	FDTD, MoM
Protección catódica	ANSYS, SimScale	FEM con multifísica
Minado electromagnético	Custom DoD codes	MQS, simulación acoplada con sensores

Caso concreto y práctico: simulación electromagnética para detección de minas submarinas usando un dron submarino (AUV).

---

Caso práctico: Simulación para detección electromagnética de minas submarinas con AUV

---

1. Contexto y objetivo

• Un AUV (vehículo submarino autónomo) equipado con sensores electromagnéticos (magnetómetros, EM gradiometers) recorre un área para detectar minas enterradas o camufladas bajo el lecho marino.

• La mina es un objeto metálico que genera perturbaciones detectables en el campo magnético local.

• El objetivo es simular la respuesta electromagnética (EM) de la mina y el entorno para:

  • Optimizar la posición y el tipo de sensores en el dron.

  • Evaluar el alcance y la sensibilidad del sistema.

  • Desarrollar algoritmos de interpretación y filtrado de señales.

---

2. Modelo físico

• Ecuaciones: Ecuaciones de Maxwell en estado estacionario o con variación temporal baja (modelo magneto-cuasiestático, MQS), dado que las frecuencias suelen ser bajas para penetrar el agua y sedimentos.

• Materiales:

  • Agua de mar: conductividad σ ≈ 4 S/m, permeabilidad magnética μ ≈ μ0.

  • Sedimentos: conductividad y permeabilidad variable según composición (arcilla, arena, roca).

  • Mina: objeto metálico con alta permeabilidad relativa μr y conductividad alta.

• Dominio: Volumen 3D que incluye el AUV, el agua, sedimentos y mina.

---

3. Técnicas numéricas

• FEM (Elementos Finitos) para discretizar el dominio, ideal para geometrías complejas y heterogéneas.

• Mallado adaptativo: Refinamiento más fino en la zona de la mina y alrededor del AUV, malla más gruesa lejos.

• Solver lineal iterativo (como GMRES o BiCGSTAB) para resolver las grandes matrices.

• Condiciones de frontera: Absorción para simular espacio abierto (perfectly matched layers, PML).

---

4. Parámetros a simular

• Frecuencia del campo aplicado (en Hz) — para explorar penetración y resolución.

• Posición y orientación del sensor respecto a la mina.

• Profundidad de enterramiento de la mina.

• Variación de propiedades de sedimentos (conductividad, permeabilidad).

---

5. Resultados esperados

• Mapas de intensidad y gradiente del campo magnético detectados por el sensor.

• Visualización 3D de la perturbación generada por la mina.

• Perfil de detección (distancia máxima para señal detectable).

• Datos para calibrar el algoritmo de detección del AUV.

---

6. Herramientas y recursos

• Software:

  • COMSOL Multiphysics: potente para simulaciones electromagnéticas con modelos multifísicos.

  • OpenEMS (open source) + MATLAB/Python para postprocesado.

  • FEniCS (Python) para modelos FEM personalizados si se quiere código abierto y flexible.

• Hardware: Clúster HPC o workstation con GPUs para acelerar el cálculo, especialmente con mallas finas.

---

7. Pasos para implementación

1. Crear modelo 3D básico: agua, sedimento, mina (cubo o cilindro metálico) y AUV (representado por un cubo con sensor en posición).

2. Definir propiedades físicas para cada región (σ, μ).

3. Discretizar con malla adaptativa: malla fina en mina y sensor, gruesa en lejanías.

4. Aplicar excitación: campo magnético alterno aplicado o campo terrestre perturbado.

5. Ejecutar simulación para distintas configuraciones (frecuencia, posición sensor).

6. Extraer campo magnético y gradiente en puntos sensores.

7. Analizar resultados para determinar umbral de detección y rango.

---

Esquema simple para simular la detección electromagnética de una mina submarina usando un modelo magneto-cuasiestático básico con Python y FEniCS (un entorno para resolver ecuaciones diferenciales parciales con FEM).

Modelo 2D simplificado para dar una idea de cómo plantearlo. Luego se puede escalar a 3D y complejizarlo en COMSOL o software similar.

---

Simulación básica MQS en 2D con FEniCS

Problema físico simplificado:

Queremos resolver la ecuación para el potencial magnético vectorial 

$\mathbf{A}$$A_z$

$$\nabla \times \left( \frac{1}{\mu} \nabla \times \mathbf{A} \right) + j \omega \sigma \mathbf{A} = \mathbf{J}_s$$

En 2D, esto se reduce a resolver

$$-\nabla \cdot \left(\frac{1}{\mu} \nabla A_z\right) + j \omega \sigma A_z = J_z$$

donde:

• $\sigma$

  $\sigma$: conductividad del medio,

• $\mu$

  $\mu$: permeabilidad magnética,

• $\omega = 2\pi f$

  $\omega =2\pi f$, frecuencia angular,

• $J_z$

  Jz​: corriente fuente (simula el campo aplicado),

• $A_z$

  Az​: potencial magnético (lo que queremos encontrar).

---

Código ejemplo en Python con FEniCS

python

from fenics import *
import numpy as np
import matplotlib.pyplot as plt
# Parámetros físicos
mu0 = 4*np.pi*1e-7        # Permeabilidad magnética en vacío
sigma_water = 4.0         # Conductividad del agua de mar (S/m)
sigma_mina = 1e7          # Conductividad alta para la mina metálica (S/m)
freq = 100.0              # Frecuencia en Hz
omega = 2*np.pi*freq
# Dominio 2D: cuadrado 10m x 10m
length = 10.0
mesh = RectangleMesh(Point(0, 0), Point(length, length), 50, 50)
# Subdominios para materiales (agua y mina)
class Mina(SubDomain):
    def inside(self, x, on_boundary):
        return (3.0 < x[0] < 5.0) and (3.0 < x[1] < 5.0)  # Mina en centro 2x2 m
# Marcamos subdominios
materials = MeshFunction('size_t', mesh, mesh.topology().dim())
materials.set_all(0)
mina = Mina()
mina.mark(materials, 1)
# Función para mu y sigma dependientes del material
mu = Constant(mu0)
sigma = Function(FunctionSpace(mesh, 'DG', 0))
# Asignar conductividades
sigma_values = [sigma_water, sigma_mina]
sigma_array = sigma.vector().get_local()
cells = materials.array()
for i in range(len(cells)):
    sigma_array[i] = sigma_values[cells[i]]
sigma.vector().set_local(sigma_array)
sigma.vector().apply('insert')
# Espacio de funciones para A_z
V = FunctionSpace(mesh, 'P', 1)
# Condiciones de frontera: A_z=0 en todo borde (puede ser adaptado)
def boundary(x, on_boundary):
    return on_boundary
bc = DirichletBC(V, Constant(0), boundary)
# Definimos la función test y trial
A = TrialFunction(V)
v = TestFunction(V)
# Corriente fuente J_z (simula campo aplicado)
# Aplicamos una corriente puntual en la esquina (0,0) para simplificar
J_expr = Expression('exp(-100*((x[0])*(x[0]) + (x[1])*(x[1])))', degree=2)
J = interpolate(J_expr, V)
# Formulación variacional para resolver:
a = (dot(1/mu * grad(A), grad(v)) + 1j*omega*sigma*A*v)*dx
L = J*v*dx
# Resolver sistema complejo (convertir a sistema real 2x2)
from dolfin import as_vector
def split_complex(u):
    return as_vector([u[0], u[1]])
V_c = FunctionSpace(mesh, MixedElement([FiniteElement('P', triangle, 1), FiniteElement('P', triangle, 1)]))
u = TrialFunction(V_c)
v_ = TestFunction(V_c)
sigma_ = sigma
a_c = (dot(1/mu*grad(u[0]), grad(v_[0])) - omega*sigma_*u[1]*v_[0] + dot(1/mu*grad(u[1]), grad(v_[1])) + omega*sigma_*u[0]*v_[1])*dx
L_c = J*v_[0]*dx
A_ = Function(V_c)
solve(a_c == L_c, A_, bc)
# Extraer soluciones real e imag
A_real, A_imag = A_.split()
# Visualización
plt.figure()
p = plot(A_real)
plt.colorbar(p)
plt.title("Potencial magnético A_z (Real)")
plt.show()

---

Explicación y pasos para ampliarlo

• Este código resuelve un problema simple 2D con dos materiales: agua y mina metálica.

• Usa un campo fuente puntual para simular excitación.

• Se resuelve un sistema complejo dividiendo en real e imaginario (FEniCS no soporta complejos directamente).

• El resultado es el potencial magnético 
  $A_z$

---

¿Qué sigue?

• Escalar a 3D para un modelo más realista.

• Introducir geometrías del dron, sensores y su posición dinámica.

• Simular respuesta para diferentes frecuencias y configuraciones.

• Añadir postprocesado para extraer señal detectable y calibrar sensores.

---

Interpretación de el resultado de este modelo:

Interpretar el resultado del modelo simplificado para la simulación electromagnética en 2D.

---

Interpretación del resultado del modelo

---

¿Qué representa el resultado?

El resultado que obtienes en la simulación es el potencial magnético 

$A_z$

• $A_z$

  Az​ es una cantidad relacionada con el campo magnético 
  $\mathbf{B}$

$$\mathbf{B} = \nabla \times \mathbf{A}$$

En 2D (con solo componente 

$A_z$

$$B_x = \frac{\partial A_z}{\partial y}, \quad B_y = - \frac{\partial A_z}{\partial x}$$

---

¿Qué buscar en el resultado?

1. Regiones de perturbación:
   La mina metálica tiene propiedades muy diferentes (conductividad y permeabilidad) respecto al agua. Esto produce una distorsión local en el campo magnético.
   En el gráfico de 
   $A_z$$(x,y) = (4,4)$$A_z$

2. Gradientes del campo magnético:
   El sensor detecta variaciones del campo magnético, es decir, derivadas de 
   $A_z$

3. Comparación agua vs mina:
   En el área de agua (conductividad baja), 
   $A_z$$A_z$

---

¿Cómo interpretar la gráfica?

• Zonas con colores más intensos o contrastantes indican áreas donde el campo magnético está más perturbado.

• La forma y tamaño de esta perturbación puede ayudarte a:

  • Detectar la presencia de la mina.

  • Estimar la posición y tamaño aproximado.

• Si el campo se ve muy suave y sin cambios, es probable que la mina esté muy profunda o que la frecuencia aplicada no sea adecuada para detectarla.

---

Pasos para análisis práctico

1. Localiza la zona de la mina en la gráfica:
   ¿Se ve una mancha o cambio en 
   $A_z$

2. Calcula gradientes:
   Puedes derivar 
   $A_z$$B_x, B_y$

3. Simula diferentes frecuencias:
   Frecuencias más bajas penetran mejor pero dan menos resolución, y viceversa. Comparar resultados con diferentes frecuencias te ayudará a elegir el óptimo.

4. Simula la señal en el sensor:
   Coloca puntos de muestreo en la posición del sensor (en el dron) y extrae los valores de 
   $A_z$$B$

---

Limitaciones del modelo

• Modelo 2D simplificado, no capta geometrías reales ni efectos tridimensionales.

• No incluye ruido ni interferencias ambientales.

• No simula movimiento del dron ni cambio de posición del sensor.

---

Realización de un script para:

• Calcular los campos magnéticos 
  $B_x, B_y$

• Extraer valores en posiciones de sensores simulados.

• Visualizar la diferencia entre un escenario con y sin mina.

Script ampliado que calcula los campos magnéticos 

$B_x$$B_y$$A_z$

---

Código ampliado para cálculo y extracción de datos sensores

python

from fenics import *
import numpy as np
import matplotlib.pyplot as plt
# Parámetros físicos (igual que antes)
mu0 = 4*np.pi*1e-7
sigma_water = 4.0
sigma_mina = 1e7
freq = 100.0
omega = 2*np.pi*freq
length = 10.0
mesh = RectangleMesh(Point(0, 0), Point(length, length), 50, 50)
class Mina(SubDomain):
    def inside(self, x, on_boundary):
        return (3.0 < x[0] < 5.0) and (3.0 < x[1] < 5.0)
materials = MeshFunction('size_t', mesh, mesh.topology().dim())
materials.set_all(0)
mina = Mina()
mina.mark(materials, 1)
def sigma_func(with_mina=True):
    sigma = Function(FunctionSpace(mesh, 'DG', 0))
    sigma_values = [sigma_water, sigma_mina if with_mina else sigma_water]
    sigma_array = sigma.vector().get_local()
    cells = materials.array()
    for i in range(len(cells)):
        sigma_array[i] = sigma_values[cells[i]]
    sigma.vector().set_local(sigma_array)
    sigma.vector().apply('insert')
    return sigma
V = FunctionSpace(mesh, 'P', 1)
def solve_system(sigma):
    def boundary(x, on_boundary):
        return on_boundary
    bc = DirichletBC(V, Constant(0), boundary)
    J_expr = Expression('exp(-100*((x[0])*(x[0]) + (x[1])*(x[1])))', degree=2)
    J = interpolate(J_expr, V)
    from dolfin import as_vector
    V_c = FunctionSpace(mesh, MixedElement([FiniteElement('P', triangle, 1), FiniteElement('P', triangle, 1)]))
    u = TrialFunction(V_c)
    v_ = TestFunction(V_c)
    a_c = (dot(1/mu0*grad(u[0]), grad(v_[0])) - omega*sigma*u[1]*v_[0] +
           dot(1/mu0*grad(u[1]), grad(v_[1])) + omega*sigma*u[0]*v_[1])*dx
    L_c = J*v_[0]*dx
    A_ = Function(V_c)
    solve(a_c == L_c, A_, bc)
    return A_
def calculate_B_fields(A_func):
    A_real, A_imag = A_func.split()
    V_vec = VectorFunctionSpace(mesh, 'P', 1)
    # Derivadas para campo B (2D)
    Bx_real = project(A_real.dx(1), V)  # dA/dy
    By_real = project(-A_real.dx(0), V) # -dA/dx
    Bx_imag = project(A_imag.dx(1), V)
    By_imag = project(-A_imag.dx(0), V)
    return (Bx_real, By_real, Bx_imag, By_imag)
# Resolver con mina
sigma_with_mina = sigma_func(with_mina=True)
A_with_mina = solve_system(sigma_with_mina)
Bx_r_mina, By_r_mina, Bx_i_mina, By_i_mina = calculate_B_fields(A_with_mina)
# Resolver sin mina (para comparación)
sigma_no_mina = sigma_func(with_mina=False)
A_no_mina = solve_system(sigma_no_mina)
Bx_r_no, By_r_no, Bx_i_no, By_i_no = calculate_B_fields(A_no_mina)
# Puntos sensores simulados en línea fija y variable en x
sensor_y = 1.0  # altura fija
sensor_x_points = np.linspace(0, length, 50)
def sample_at_points(F, points):
    values = []
    for x in points:
        values.append(F(Point(x, sensor_y)))
    return np.array(values)
# Extraemos señales reales para Bx
Bx_signal_with_mina = sample_at_points(Bx_r_mina, sensor_x_points)
Bx_signal_no_mina = sample_at_points(Bx_r_no, sensor_x_points)
# Visualización comparación
plt.figure(figsize=(10,5))
plt.plot(sensor_x_points, Bx_signal_no_mina, label='Sin mina')
plt.plot(sensor_x_points, Bx_signal_with_mina, label='Con mina')
plt.xlabel('Posición sensor (m) en x')
plt.ylabel('Campo Bx (Real)')
plt.title('Señal magnética detectada por sensores simulados')
plt.legend()
plt.grid(True)
plt.show()

---

¿Qué hace este script?

• Resuelve el problema electromagnético con y sin mina.

• Calcula las componentes del campo magnético 
  $B_x, B_y$

• Simula una línea de sensores a una altura fija 
  $y=1m$

• Extrae la señal del campo magnético 
  $B_x$

• Grafica ambas señales para comparar claramente la influencia de la mina.

---

Interpretar la gráfica de salida que obtendrás al ejecutar ese script:

---

Cómo interpretar la gráfica de señal magnética en sensores simulados

---

1. Ejes de la gráfica

• Eje X: Posición del sensor a lo largo de la línea horizontal (en metros).
  Es decir, cómo varía la señal a medida que el dron o los sensores se mueven de un lado al otro.

• Eje Y: Valor del campo magnético 
  $B_x$

---

2. Curvas

• Curva “Sin mina” (línea base):
  Representa el campo magnético en agua sin ninguna perturbación.
  Esta señal será bastante suave y sin picos importantes.

• Curva “Con mina”:
  Representa el campo magnético cuando la mina metálica está presente en el dominio.
  Aquí buscarás picos o cambios abruptos en la señal, indicando la presencia de un objeto metálico que perturba el campo.

---

3. Qué buscar

• Picos o caídas bruscas en la señal “Con mina” comparados con “Sin mina”:
  Estos picos indican la posición aproximada de la mina. El sensor detecta una perturbación en el campo magnético causado por la alta conductividad y permeabilidad de la mina.

• Diferencia entre ambas curvas:
  Cuanto mayor sea la diferencia en ciertas posiciones, más fácil será detectar y localizar la mina.

• Ancho y forma del pico:
  Puede dar información aproximada del tamaño o forma del objeto detectado (aunque para detalles reales necesitarías modelos 3D y más precisión).

---

4. Limitaciones y recomendaciones

• El modelo es 2D y simplificado, por lo que las señales son aproximadas. En la realidad habrá ruido y efectos adicionales.

• Cambia la altura del sensor (valor 
  $y=1m$

• También puedes analizar la componente 
  $B_y$

---

Informe básico tipo reporte para presentar o compartir la interpretación del modelo y la gráfica de detección de la mina mediante señales magnéticas simuladas.

---

Informe de Resultados: Detección de Objeto Metálico en Medio Marino mediante Modelado Electromagnético 2D

---

1. Introducción

El presente informe describe los resultados obtenidos de un modelo electromagnético simplificado en 2D para la detección de un objeto metálico (mina submarina) en un medio marino. Se simula el potencial magnético 

$A_z$$B_x$$B_y$

---

2. Metodología

• Se modeló un dominio cuadrado de 10x10 m, con propiedades eléctricas del agua y de la mina metálica.

• La mina está localizada en el área 
  $[3,5] \times [3,5]$

• Se resolvió el sistema electromagnético usando el método de elementos finitos.

• Se calcularon las componentes del campo magnético 
  $B_x$$B_y$$A_z$

• Se simuló una línea de sensores a 1 m de altura sobre el fondo marino, muestreando la señal 
  $B_x$

• Se compararon las señales con y sin la mina para detectar perturbaciones.

---

3. Resultados

• La señal magnética sin la mina es suave y sin picos relevantes, representando el campo magnético ambiental en agua.

• La presencia de la mina genera un pico significativo en la señal 
  $B_x$

• La diferencia entre ambas señales permite identificar y localizar el objeto metálico.

• La forma y el ancho del pico brindan indicios sobre el tamaño aproximado de la mina.

---

4. Interpretación y Aplicación Práctica

• Los picos en la señal detectada indican perturbaciones causadas por la alta conductividad y permeabilidad del objeto metálico.

• Estos datos pueden ser usados para diseñar algoritmos de detección automática en drones o vehículos submarinos.

• El modelo permite optimizar la frecuencia y la posición de los sensores para mejorar la detección en escenarios reales.

• Se recomienda ampliar el modelo a 3D y agregar simulación de ruido para mayor precisión y aplicabilidad.

---

5. Conclusiones

• El modelo electromagnético simplificado 2D es útil para entender y predecir la perturbación causada por objetos metálicos en el medio marino.

• La comparación entre escenarios con y sin objeto permite extraer señales claras que pueden ser usadas en sistemas reales de detección.

• Este enfoque puede ser base para el desarrollo de sistemas autónomos de detección de minas o estructuras metálicas bajo el agua.

---

Diseñar algoritmos para procesar la señal electromagnética detectada en el dron

Diseñar algoritmos para procesar la señal electromagnética detectada por el dron implica varios pasos para extraer información útil (como la detección y localización de la mina) a partir de las señales brutas de los sensores.

Esquema básico con tres enfoques complementarios para procesar la señal, que se pueden combinar o adaptar según la complejidad y requerimientos:

---

Algoritmos para Procesar Señal Electromagnética en Dron Detectando Minas

---

1. Preprocesamiento de la señal

• Filtrado de ruido:
  Utilizar filtros pasa banda o filtros adaptativos (ej. filtro de Kalman, filtro de mediana) para eliminar ruido ambiental y interferencias.

• Normalización:
  Escalar la señal para que esté en un rango manejable y comparativo.

• Corrección de línea base:
  Restar la señal promedio o de fondo para resaltar perturbaciones.

---

2. Detección de anomalías

• Detección de picos:
  Algoritmos que detectan picos o cambios bruscos en la señal, usando métodos como:

  • Umbral fijo o adaptativo (p. ej., señal supera cierto valor o desviación estándar del ruido)

  • Detección de máximos locales con ventanas deslizantes

• Detección estadística:
  Comparar la señal actual con un modelo esperado sin mina y detectar desviaciones significativas (usando distancia estadística, test de hipótesis).

• Transformada Wavelet o Fourier:
  Detectar cambios en la frecuencia o patrones específicos asociados a la mina.

---

3. Localización y clasificación

• Estimación de posición:
  Basada en la posición del sensor con mayor pico o usando interpolación entre varios sensores.

• Análisis multicanal:
  Combinar señales de varios sensores (en diferentes posiciones o componentes 
  $B_x, B_y$

• Clasificación:
  Usar machine learning (SVM, redes neuronales, árboles de decisión) entrenados con señales simuladas para distinguir minas de otros objetos o falsas alarmas.

---

Ejemplo básico de detección de picos en Python

python

import numpy as np
from scipy.signal import find_peaks
# Supongamos que 'signal' es la señal medida después de preprocesar
# sensor_x_points es el array con las posiciones de los sensores
# Encontrar picos que superen un umbral, por ejemplo 1.5 veces la desviación estándar
threshold = 1.5 * np.std(signal)
peaks, _ = find_peaks(signal, height=threshold)
# Posiciones donde se detectaron picos
positions_peaks = sensor_x_points[peaks]
print("Posiciones detectadas de posibles minas:", positions_peaks)

---

Desarrollar paso a paso un algoritmo básico para procesar la señal electromagnética simulada y detectar posibles minas submarinas con el código en Python.

---

Algoritmo completo para detección y localización de minas con señales electromagnéticas

---

1. Carga y preprocesamiento de la señal

• Filtrado simple con suavizado (media móvil).

• Normalización y corrección de línea base.

2. Detección de picos (anomalías)

• Detectar máximos locales que superen un umbral adaptativo.

3. Localización

• Obtener posiciones de sensores donde se detectan picos.

---

Código en Python paso a paso

python

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import find_peaks
# --- Simulación simple de señales (puedes reemplazar con tu señal real) ---
# sensor_x_points: posiciones horizontales de los sensores
sensor_x_points = np.linspace(0, 10, 100)
# signal_sin_mina: señal base sin objeto
signal_sin_mina = 0.1 * np.sin(sensor_x_points * 2 * np.pi / 10)
# signal_con_mina: señal con perturbación (mina) simulada con un pico gaussiano
mina_pos = 4.0  # posición aproximada de la mina
mina_width = 0.3
peak = np.exp(-((sensor_x_points - mina_pos) ** 2) / (2 * mina_width ** 2))
signal_con_mina = signal_sin_mina + peak
# --- Preprocesamiento ---
def smooth_signal(signal, window_size=5):
    window = np.ones(window_size) / window_size
    return np.convolve(signal, window, mode='same')
# Suavizar señal para eliminar ruido
signal_suave = smooth_signal(signal_con_mina, window_size=5)
# Corrección línea base (restar media)
signal_corr = signal_suave - np.mean(signal_suave)
# Normalizar
signal_norm = signal_corr / np.max(np.abs(signal_corr))
# --- Detección de picos ---
# Definir umbral dinámico para detección
threshold = 0.3  # puedes ajustar según sensibilidad requerida
# Detectar picos que superen el umbral
peaks, properties = find_peaks(signal_norm, height=threshold)
# --- Resultados ---
print("Posiciones detectadas de posibles minas:", sensor_x_points[peaks])
# --- Visualización ---
plt.figure(figsize=(10, 5))
plt.plot(sensor_x_points, signal_norm, label="Señal normalizada y corregida")
plt.plot(sensor_x_points[peaks], signal_norm[peaks], "ro", label="Picos detectados")
plt.xlabel("Posición sensor (m)")
plt.ylabel("Señal electromagnética (normalizada)")
plt.title("Detección de minas por análisis de señal electromagnética")
plt.legend()
plt.grid()
plt.show()

---

Explicación:

• Se simula una señal con una mina representada por un pico gaussiano.

• Se suaviza la señal con una media móvil para reducir ruido.

• Se corrige la línea base restando la media de la señal para resaltar picos.

• Se normaliza para tener valores relativos entre -1 y 1.

• Se detectan picos con altura mayor que un umbral.

• Se muestran las posiciones donde se detectan picos (posible mina).

• Se visualiza la señal y las detecciones.

---

Adaptar este código a las señales reales de FEM

Para adaptar el código a las señales reales que obtienes con FEM (como las que se calciularon con el potencial magnético y las componentes del campo 

$B_x$

Bx​), el flujo general es muy similar, pero hay que seguir algunos pasos importantes para manejar los datos FEM y extraer la señal correcta.

---

Pasos para adaptar el código a señales reales FEM

---

1. Preparar los datos FEM

• Normalmente, el resultado FEM es un array complejo o real para 
  $A_z$$B_x = \frac{\partial A_z}{\partial y}$$B_y = -\frac{\partial A_z}{\partial x}$

• Debes seleccionar la línea o puntos donde tienes sensores virtuales (por ejemplo, a cierta altura fija 
  $y=1$

• Extraer el valor de 
  $B_x$

2. Convertir datos FEM a vector de señal para procesar

• Crear un array con las posiciones de sensores (eje x).

• Crear un array con los valores reales de la señal magnética 
  $B_x$

---

Ejemplo práctico con código adaptado para FEM (asumiendo que tienes variables X, Y, y Bx):

python

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import find_peaks
# Suponemos que tienes las matrices FEM:
# X, Y: coordenadas del dominio (2D)
# Bx: matriz 2D con valores de campo Bx (parte real o módulo)
# --- Definir altura fija para sensores (p.ej., y = 1.0 m) ---
altura_sensor = 1.0
# Encontrar índice en Y más cercano a altura_sensor
indice_y = np.abs(Y[:,0] - altura_sensor).argmin()
# Extraer señal Bx en esa línea de sensores
signal_fem = Bx[indice_y, :]  # fila fija para altura_sensor
# Extraer posiciones X para esa línea
posiciones_sensores = X[indice_y, :]
# --- Preprocesamiento (suavizado, normalización) ---
def smooth_signal(signal, window_size=5):
    window = np.ones(window_size) / window_size
    return np.convolve(signal, window, mode='same')
signal_suave = smooth_signal(signal_fem, window_size=5)
signal_corr = signal_suave - np.mean(signal_suave)
signal_norm = signal_corr / np.max(np.abs(signal_corr))
# --- Detección de picos ---
threshold = 0.3  # ajustar según la señal
peaks, _ = find_peaks(signal_norm, height=threshold)
print("Posiciones detectadas de posibles minas:", posiciones_sensores[peaks])
# --- Visualización ---
plt.figure(figsize=(10, 5))
plt.plot(posiciones_sensores, signal_norm, label="Señal FEM normalizada y corregida")
plt.plot(posiciones_sensores[peaks], signal_norm[peaks], "ro", label="Picos detectados")
plt.xlabel("Posición sensor (m)")
plt.ylabel("Campo magnético Bx (normalizado)")
plt.title("Detección de minas con señales FEM")
plt.legend()
plt.grid()
plt.show()

---

Notas importantes:

• Asegúrate de que Bx contenga los datos reales (parte real, módulo o la componente que quieras analizar).

• El valor de altura_sensor debe coincidir con la altura donde simulas la línea de sensores en tu FEM.

• Ajusta el umbral threshold según la escala y el ruido en tu señal.

• Puedes probar con diferentes componentes 
  $B_x$$B_y$$\sqrt{B_x^2 + B_y^2}$

---

Pasos para adaptar el código a señales reales FEM: 

1. Preparar los datos FEM Normalmente, el resultado FEM es un array complejo o real para 𝐴 𝑧 A z ​ , de donde calculaste 𝐵 𝑥 = ∂ 𝐴 𝑧 ∂ 𝑦 B x ​ = ∂y ∂A z ​ ​ (o 𝐵 𝑦 = − ∂ 𝐴 𝑧 ∂ 𝑥 B y ​ =− ∂x ∂A z ​ ​ ). Debes seleccionar la línea o puntos donde tienes sensores virtuales (por ejemplo, a cierta altura fija 𝑦 = 1 y=1 m). Extraer el valor de 𝐵 𝑥 B x ​ (o la componente que quieras analizar) en esas posiciones

.2. Convertir datos FEM a vector de señal para procesar Crear un array con las posiciones de sensores (eje x). Crear un array con los valores reales de la señal magnética 𝐵 𝑥 B x ​ en esas posiciones. Ejemplo práctico con código adaptado para FEM (asumiendo que tienes variables X, Y, y Bx): python Copiar Editar import numpy as np import matplotlib.pyplot as plt from scipy.signal import find_peaks # Suponemos que tienes las matrices FEM: # X, Y: coordenadas del dominio (2D) # Bx: matriz 2D con valores de campo Bx (parte real o módulo) # --- Definir altura fija para sensores (p.ej., y = 1.0 m) --- altura_sensor = 1.0 # Encontrar índice en Y más cercano a altura_sensor indice_y = np.abs(Y[:,0] - altura_sensor).argmin() # Extraer señal Bx en esa línea de sensores signal_fem = Bx[indice_y, :] # fila fija para altura_sensor # Extraer posiciones X para esa línea posiciones_sensores = X[indice_y, :] # --- Preprocesamiento (suavizado, normalización) --- def smooth_signal(signal, window_size=5): window = np.ones(window_size) / window_size return np.convolve(signal, window, mode='same') signal_suave = smooth_signal(signal_fem, window_size=5) signal_corr = signal_suave - np.mean(signal_suave) signal_norm = signal_corr / np.max(np.abs(signal_corr)) # --- Detección de picos --- threshold = 0.3 # ajustar según la señal peaks, _ = find_peaks(signal_norm, height=threshold) print("Posiciones detectadas de posibles minas:", posiciones_sensores[peaks]) # --- Visualización --- plt.figure(figsize=(10, 5)) plt.plot(posiciones_sensores, signal_norm, label="Señal FEM normalizada y corregida") plt.plot(posiciones_sensores[peaks], signal_norm[peaks], "ro", label="Picos detectados") plt.xlabel("Posición sensor (m)") plt.ylabel("Campo magnético Bx (normalizado)") plt.title("Detección de minas con señales FEM") plt.legend() plt.grid() plt.show() Notas importantes: Asegúrate de que Bx contenga los datos reales (parte real, módulo o la componente que quieras analizar). El valor de altura_sensor debe coincidir con la altura donde simulas la línea de sensores en tu FEM. Ajusta el umbral threshold según la escala y el ruido en tu señal. Puedes probar con diferentes componentes 𝐵 𝑥 B x ​ , 𝐵 𝑦 B y ​ , o el módulo 𝐵 𝑥 2 + 𝐵 𝑦 2 B x 2 ​ +B y 2 ​ ​ .

Procedimiento y  código para adaptar la detección de minas usando señales FEM reales. Resumen bien estructurado y completo:

---

Adaptación del procesamiento a señales reales FEM

---

1. Preparación de datos FEM

• Tienes las matrices 2D:

  • X (coordenadas x)

  • Y (coordenadas y)

  • Bx (campo magnético componente x)

• Selecciona una línea fija de sensores, por ejemplo a una altura fija y = altura_sensor (e.g. 1.0 m).

• Obtén el índice en Y más cercano a esa altura.

• Extrae la fila correspondiente de Bx y X para esa altura.

---

2. Procesamiento de la señal

• Suaviza la señal con media móvil para reducir ruido.

• Corrige la línea base (restar media).

• Normaliza la señal (valores relativos entre -1 y 1).

---

3. Detección de picos

• Usa scipy.signal.find_peaks para encontrar picos que superen un umbral ajustable (threshold).

• Los picos indicarán posibles posiciones de minas o anomalías.

---

4. Visualización y salida

• Grafica la señal normalizada con los picos detectados señalados.

• Imprime las posiciones de los sensores donde se detectan los picos.

---

Código ejemplo completo

python

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import find_peaks
# Datos FEM (ejemplo)
# X, Y: matrices 2D de coordenadas
# Bx: matriz 2D con valores del campo Bx (parte real o módulo)
altura_sensor = 1.0  # altura fija de sensores
# Encontrar índice en Y más cercano a la altura_sensor
indice_y = np.abs(Y[:,0] - altura_sensor).argmin()
# Extraer señal y posiciones en esa altura
signal_fem = Bx[indice_y, :]
posiciones_sensores = X[indice_y, :]
# Suavizado con media móvil
def smooth_signal(signal, window_size=5):
    window = np.ones(window_size) / window_size
    return np.convolve(signal, window, mode='same')
signal_suave = smooth_signal(signal_fem, window_size=5)
# Corrección línea base y normalización
signal_corr = signal_suave - np.mean(signal_suave)
signal_norm = signal_corr / np.max(np.abs(signal_corr))
# Detección de picos
threshold = 0.3  # ajustar según la señal y ruido
peaks, _ = find_peaks(signal_norm, height=threshold)
print("Posiciones detectadas de posibles minas:", posiciones_sensores[peaks])
# Visualización
plt.figure(figsize=(10, 5))
plt.plot(posiciones_sensores, signal_norm, label="Señal FEM normalizada y corregida")
plt.plot(posiciones_sensores[peaks], signal_norm[peaks], "ro", label="Picos detectados")
plt.xlabel("Posición sensor (m)")
plt.ylabel("Campo magnético Bx (normalizado)")
plt.title("Detección de minas con señales FEM")
plt.legend()
plt.grid()
plt.show()

---

Recomendaciones finales

• Calcular también el módulo:

  $$B = \sqrt{B_x^2 + B_y^2}$$

  y analizar esa señal para detección.

• Ajusta la ventana de suavizado y el umbral para optimizar detección según ruido y resolución FEM.

• Si tienes datos complejos (parte real e imaginaria), trabaja con la parte real o el módulo absoluto.

---

Código ejemplo completo python Copiar Editar import numpy as np import matplotlib.pyplot as plt from scipy.signal import find_peaks # Datos FEM (ejemplo) # X, Y: matrices 2D de coordenadas # Bx: matriz 2D con valores del campo Bx (parte real o módulo) altura_sensor = 1.0 # altura fija de sensores # Encontrar índice en Y más cercano a la altura_sensor indice_y = np.abs(Y[:,0] - altura_sensor).argmin() # Extraer señal y posiciones en esa altura signal_fem = Bx[indice_y, :] posiciones_sensores = X[indice_y, :] # Suavizado con media móvil def smooth_signal(signal, window_size=5): window = np.ones(window_size) / window_size return np.convolve(signal, window, mode='same') signal_suave = smooth_signal(signal_fem, window_size=5) # Corrección línea base y normalización signal_corr = signal_suave - np.mean(signal_suave) signal_norm = signal_corr / np.max(np.abs(signal_corr)) # Detección de picos threshold = 0.3 # ajustar según la señal y ruido peaks, _ = find_peaks(signal_norm, height=threshold) print("Posiciones detectadas de posibles minas:", posiciones_sensores[peaks]) # Visualización plt.figure(figsize=(10, 5)) plt.plot(posiciones_sensores, signal_norm, label="Señal FEM normalizada y corregida") plt.plot(posiciones_sensores[peaks], signal_norm[peaks], "ro", label="Picos detectados") plt.xlabel("Posición sensor (m)") plt.ylabel("Campo magnético Bx (normalizado)") plt.title("Detección de minas con señales FEM") plt.legend() plt.grid() plt.show()

Código está muy bien estructurado y funcional para procesar señales FEM y detectar picos que podrían representar minas u otras anomalías. Código formateado y listo para usar con comentarios clave para que lo tengas claro:

python

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import find_peaks
# --- Supuestos iniciales ---
# X, Y: matrices 2D con coordenadas espaciales
# Bx: matriz 2D con valores del campo magnético componente Bx (parte real o módulo)
# Estas matrices deben estar cargadas previamente, por ejemplo desde un archivo FEM
altura_sensor = 1.0  # Altura fija para simular línea de sensores (en metros)
# Encontrar el índice en Y más cercano a la altura_sensor
indice_y = np.abs(Y[:,0] - altura_sensor).argmin()
# Extraer la señal Bx en la línea fija de sensores (fila correspondiente a indice_y)
signal_fem = Bx[indice_y, :]
# Extraer posiciones X correspondientes a esa fila
posiciones_sensores = X[indice_y, :]
# Función para suavizar señal con media móvil
def smooth_signal(signal, window_size=5):
    window = np.ones(window_size) / window_size
    return np.convolve(signal, window, mode='same')
# Aplicar suavizado
signal_suave = smooth_signal(signal_fem, window_size=5)
# Corregir línea base (restar media) y normalizar
signal_corr = signal_suave - np.mean(signal_suave)
signal_norm = signal_corr / np.max(np.abs(signal_corr))
# Detectar picos en la señal normalizada
threshold = 0.3  # Umbral ajustable según señal y ruido
peaks, _ = find_peaks(signal_norm, height=threshold)
print("Posiciones detectadas de posibles minas:", posiciones_sensores[peaks])
# Visualizar resultado
plt.figure(figsize=(10, 5))
plt.plot(posiciones_sensores, signal_norm, label="Señal FEM normalizada y corregida")
plt.plot(posiciones_sensores[peaks], signal_norm[peaks], "ro", label="Picos detectados")
plt.xlabel("Posición sensor (m)")
plt.ylabel("Campo magnético Bx (normalizado)")
plt.title("Detección de minas con señales FEM")
plt.legend()
plt.grid()
plt.show()

---

Recomendación para uso práctico:

• Asegúrate de que X, Y y Bx estén correctamente importados o cargados desde tu simulación FEM (por ejemplo, archivos .mat, .csv u otro formato).

• Puedes ajustar la altura_sensor para analizar diferentes líneas horizontales del campo.

• Modifica threshold para optimizar la sensibilidad de detección.

• Considera probar con otras componentes del campo (By) o el módulo total del campo magnético.

Ejemplo completo, simulando datos tipo FEM para que puedas probar todo el proceso de detección con el código adaptado.

python

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import find_peaks
# --- Simulación de datos tipo FEM ---
# Dominio espacial (X, Y) en m
x = np.linspace(0, 10, 200)
y = np.linspace(0, 5, 100)
X, Y = np.meshgrid(x, y)
# Simulación de campo Bx con "minas" representadas como picos gausianos a distintas posiciones
def gauss(x, mu, sigma, amp=1):
    return amp * np.exp(-(x - mu)**2 / (2 * sigma**2))
Bx = np.zeros_like(X)
# Añadimos picos a distintas posiciones en X, a la altura y=1
pos_minas = [2.0, 4.5, 7.8]  # posiciones de minas
for pos in pos_minas:
    # Pico gaussiano en la fila donde y=1
    fila_y = np.abs(y - 1.0).argmin()
    Bx[fila_y, :] += gauss(x, pos, sigma=0.1, amp=5)
# Añadimos algo de ruido
np.random.seed(42)
Bx += 0.3 * np.random.randn(*Bx.shape)
# --- Código de detección adaptado ---
altura_sensor = 1.0
# Encontrar índice en Y para altura_sensor
indice_y = np.abs(y - altura_sensor).argmin()
# Extraer señal y posiciones para esa altura
signal_fem = Bx[indice_y, :]
posiciones_sensores = X[indice_y, :]
# Suavizado
def smooth_signal(signal, window_size=5):
    window = np.ones(window_size) / window_size
    return np.convolve(signal, window, mode='same')
signal_suave = smooth_signal(signal_fem, window_size=5)
# Corrección y normalización
signal_corr = signal_suave - np.mean(signal_suave)
signal_norm = signal_corr / np.max(np.abs(signal_corr))
# Detección de picos
threshold = 0.3
peaks, _ = find_peaks(signal_norm, height=threshold)
print("Posiciones detectadas de posibles minas:", posiciones_sensores[peaks])
# Visualización
plt.figure(figsize=(10, 5))
plt.plot(posiciones_sensores, signal_norm, label="Señal FEM normalizada y corregida")
plt.plot(posiciones_sensores[peaks], signal_norm[peaks], "ro", label="Picos detectados")
plt.xlabel("Posición sensor (m)")
plt.ylabel("Campo magnético Bx (normalizado)")
plt.title("Detección de minas en señal FEM simulada")
plt.legend()
plt.grid()
plt.show()

---

Con este ejemplo:

• Simulamos un campo magnético Bx con tres picos que representan minas en posiciones conocidas.

• Añadimos ruido para hacerlo más realista.

• Aplicamos suavizado, corrección y detección de picos.

• Imprimimos y graficamos las posiciones donde detectamos minas.

Puedes ejecutar esto tal cual para ver cómo funciona y luego adaptar el mismo flujo a tus datos FEM reales.

Cargar datos FEM reales en Python, lo primero es saber en qué formato tienes esos datos. Los formatos más comunes son:

• Archivos .mat (de MATLAB)

• Archivos CSV o TXT

• Archivos HDF5

• Otros formatos específicos de software FEM

Voy a mostrarte cómo cargar datos de los dos formatos más habituales:

---

1) Cargar datos FEM desde archivo .mat (MATLAB)

python

import scipy.io
import numpy as np
# Ruta del archivo .mat
archivo_mat = 'datos_fem.mat'
# Cargar archivo .mat
datos = scipy.io.loadmat(archivo_mat)
# Explora las claves para saber qué variables contiene
print(datos.keys())
# Supongamos que tus variables se llaman 'X', 'Y' y 'Bx' dentro del .mat
X = datos['X']  # matriz 2D
Y = datos['Y']  # matriz 2D
Bx = datos['Bx']  # matriz 2D (puede ser compleja o real)
print(X.shape, Y.shape, Bx.shape)
# Si Bx es complejo, puedes usar la parte real, módulo, o fase
Bx_real = np.real(Bx)
Bx_mod = np.abs(Bx)

---

2) Cargar datos FEM desde archivo CSV o TXT

Si tienes los datos en archivos planos, normalmente tendrás columnas para las coordenadas y el valor del campo. Por ejemplo:

x (m)	y (m)	Bx (T)
0.0	0.0	0.12
0.05	0.0	0.15
...	...	...

python

import numpy as np
# Cargar datos de archivo CSV
datos = np.loadtxt('datos_fem.csv', delimiter=',')
# Asumiendo columnas: x, y, Bx
x = datos[:, 0]
y = datos[:, 1]
Bx = datos[:, 2]
# Si quieres organizar datos en grillas 2D para usar con matplotlib, puedes hacer:
from scipy.interpolate import griddata
# Definir grilla para interpolar
xi = np.linspace(np.min(x), np.max(x), 200)
yi = np.linspace(np.min(y), np.max(y), 100)
X, Y = np.meshgrid(xi, yi)
# Interpolar Bx en la grilla
Bx_grid = griddata((x, y), Bx, (X, Y), method='cubic')

---

Una vez cargados y organizados los datos (X, Y, Bx_grid), puedes aplicar el código de procesamiento y detección que ya vimos.