Vibración de un Tambor Circular

NotaContexto

Estudiamos las vibraciones de una membrana circular (tambor) cuando la solución no depende del ángulo (caso axisimétrico), reduciendo la ecuación de ondas 2D a un problema de ecuaciones diferenciales ordinarias con la ecuación de Bessel.

Ecuación de Ondas Bidimensional

La vibración de una membrana circular de radio \(a\) se describe mediante la ecuación de ondas:

\[ \frac{\partial^2 u}{\partial t^2} = c^2 \nabla^2 u = c^2 \left(\frac{\partial^2 u}{\partial x^2} + \frac{\partial^2 u}{\partial y^2}\right) \]

donde \(u(x,y,t)\) es el desplazamiento vertical y \(c\) es la velocidad de propagación.

Coordenadas Polares

Para una membrana circular, usamos coordenadas polares \((r, \theta)\):

\[ x = r\cos\theta, \quad y = r\sin\theta \]

El laplaciano en coordenadas polares es:

\[ \nabla^2 u = \frac{\partial^2 u}{\partial r^2} + \frac{1}{r}\frac{\partial u}{\partial r} + \frac{1}{r^2}\frac{\partial^2 u}{\partial \theta^2} \]

Por tanto, la ecuación de ondas se escribe:

\[ \boxed{\frac{\partial^2 u}{\partial t^2} = c^2 \left(\frac{\partial^2 u}{\partial r^2} + \frac{1}{r}\frac{\partial u}{\partial r} + \frac{1}{r^2}\frac{\partial^2 u}{\partial \theta^2}\right)} \]

Caso Axisimétrico

Cuando la membrana vibra con simetría radial (independiente de \(\theta\)), se tiene:

\[ \frac{\partial u}{\partial \theta} = 0 \quad \Rightarrow \quad u = u(r,t) \]

La ecuación de ondas se reduce a:

\[ \boxed{\frac{\partial^2 u}{\partial t^2} = c^2 \left(\frac{\partial^2 u}{\partial r^2} + \frac{1}{r}\frac{\partial u}{\partial r}\right)} \]

con condiciones:

• Borde fijo: \(u(a, t) = 0\)
• Finitud en el centro: \(u(0, t) < \infty\)

---

Separación de Variables

Buscamos soluciones de la forma:

\[ u(r,t) = R(r)T(t) \]

Sustituyendo en la ecuación de ondas:

\[ R(r)T''(t) = c^2\left(R''(r)T(t) + \frac{1}{r}R'(r)T(t)\right) \]

Dividiendo por \(R(r)T(t)\):

\[ \frac{T''(t)}{c^2 T(t)} = \frac{R''(r)}{R(r)} + \frac{1}{r}\frac{R'(r)}{R(r)} = -\lambda \]

donde \(\lambda\) es la constante de separación (autovalor).

Ecuación Temporal

\[ \boxed{T''(t) + \lambda c^2 T(t) = 0} \]

Solución (para \(\lambda > 0\)):

\[ T(t) = A\cos(\omega t) + B\sin(\omega t), \quad \omega = c\sqrt{\lambda} \]

Representa oscilaciones armónicas con frecuencia \(\omega\).

Ecuación Radial (Ecuación de Bessel)

\[ r^2 R''(r) + r R'(r) + \lambda r^2 R(r) = 0 \]

Definiendo \(k = \sqrt{\lambda}\) y haciendo el cambio \(\rho = kr\):

\[ \boxed{\rho^2 R''(\rho) + \rho R'(\rho) + \rho^2 R(\rho) = 0} \]

Esta es la ecuación de Bessel de orden cero \(J_0(\rho)\).

Solución general:

\[ R(\rho) = C_1 J_0(\rho) + C_2 Y_0(\rho) \]

donde:

• \(J_0\) es la función de Bessel de primera especie
• \(Y_0\) es la función de Bessel de segunda especie (singular en \(\rho = 0\))

Condición de finitud: Como \(Y_0(0) \to -\infty\), se requiere \(C_2 = 0\):

\[ R(r) = C_1 J_0(kr) \]

---

Condición de Frontera y Autovalores

La condición de borde fijo \(u(a,t) = 0\) implica:

\[ R(a) = J_0(ka) = 0 \]

Autovalores: Los valores \(k_n\) son las raíces de la función de Bessel:

\[ J_0(k_n a) = 0, \quad n = 1, 2, 3, \ldots \]

Numéricamente, las primeras raíces de \(J_0(x)\) son:

\[ \begin{aligned} x_1 &\approx 2.4048 \\ x_2 &\approx 5.5201 \\ x_3 &\approx 8.6537 \\ x_4 &\approx 11.7915 \\ &\vdots \end{aligned} \]

Por tanto:

\[ k_n = \frac{x_n}{a}, \quad \lambda_n = k_n^2 = \left(\frac{x_n}{a}\right)^2 \]

Frecuencias Naturales

Las frecuencias de vibración son:

\[ \boxed{\omega_n = ck_n = c\frac{x_n}{a}} \]

Interpretación:

• El tambor vibra con frecuencias discretas (cuantizadas)
• Las frecuencias no son múltiplos enteros (a diferencia de una cuerda)
• Dependen inversamente del radio: tambores grandes suenan más grave

---

Modos Normales de Vibración

La solución general es una superposición de modos:

\[ \boxed{u(r,t) = \sum_{n=1}^{\infty} J_0(k_n r)\left[A_n\cos(\omega_n t) + B_n\sin(\omega_n t)\right]} \]

Modo \(n\)-ésimo:

\[ u_n(r,t) = J_0(k_n r)\cos(\omega_n t) \]

Características de los Modos

Modo	\(k_n a\)	Nodos (círculos)	Frecuencia relativa
\(n=1\)	\(2.40\)	0 (solo el borde)	\(f_1\)
\(n=2\)	\(5.52\)	1 círculo interno	\(2.30 f_1\)
\(n=3\)	\(8.65\)	2 círculos internos	\(3.60 f_1\)
\(n=4\)	\(11.79\)	3 círculos internos	\(4.90 f_1\)

Nodos: Círculos de radio \(r\) donde \(J_0(k_n r) = 0\), que permanecen en reposo.

Visualizador Interactivo de Modos de Vibración

PrecauciónVisualizador 3D de Modos del Tambor

zeros_J0 = [2.4048, 5.5201, 8.6537, 11.7915]

// Función de Bessel J_0 (aproximación)
function besselJ0(x) {
  if (Math.abs(x) < 8) {
    const y = x * x;
    const ans1 = 57568490574.0 + y * (-13362590354.0 + y * (651619640.7 +
      y * (-11214424.18 + y * (77392.33017 + y * (-184.9052456)))));
    const ans2 = 57568490411.0 + y * (1029532985.0 + y * (9494680.718 +
      y * (59272.64853 + y * (267.8532712 + y * 1.0))));
    return ans1 / ans2;
  } else {
    const z = 8.0 / Math.abs(x);
    const y = z * z;
    const xx = Math.abs(x) - 0.785398164;
    const ans1 = 1.0 + y * (-0.1098628627e-2 + y * (0.2734510407e-4 +
      y * (-0.2073370639e-5 + y * 0.2093887211e-6)));
    const ans2 = -0.1562499995e-1 + y * (0.1430488765e-3 +
      y * (-0.6911147651e-5 + y * (0.7621095161e-6 - y * 0.934935152e-7)));
    return Math.sqrt(0.636619772 / Math.abs(x)) * 
      (Math.cos(xx) * ans1 - z * Math.sin(xx) * ans2) * (x < 0 ? -1 : 1);
  }
}

// Selector de modo
viewof modo = Inputs.range([1, 4], {
  label: "Modo de vibración (n):",
  value: 1,
  step: 1
})

// Botón de animación
viewof animando = Inputs.toggle({
  label: "Animar",
  value: true
})

// Control de tiempo con animación
viewof tiempo = {
  const input = Inputs.range([0, 2 * Math.PI], {
    label: "Fase temporal (ωt):",
    value: 0,
    step: 0.05
  });
  
  const view = input;
  
  let interval;
  
  function updateAnimation() {
    if (animando) {
      if (!interval) {
        interval = setInterval(() => {
          view.value = (view.value + 0.13) % (2 * Math.PI);
          view.dispatchEvent(new Event("input", {bubbles: true}));
        }, 50);
      }
    } else {
      if (interval) {
        clearInterval(interval);
        interval = null;
      }
    }
  }
  
  // Observar cambios en el toggle
  const observer = setInterval(updateAnimation, 100);
  
  view.addEventListener("input", () => {
    if (interval) {
      clearInterval(interval);
      interval = null;
    }
  });
  
  return view;
}

// Parámetros
a = 1.0  // Radio del tambor
k_n = zeros_J0[modo - 1] / a
amplitud = 1  // Amplitud que decrece con el modo

// Generar datos 3D para vista superior
datos3D = {
  const n_points = 50;
  const r_vals = Array.from({length: n_points}, (_, i) => i * a / (n_points - 1));
  const theta_vals = Array.from({length: 60}, (_, i) => i * 2 * Math.PI / 59);
  
  let data = [];
  for (let r of r_vals) {
    for (let theta of theta_vals) {
      const x = r * Math.cos(theta);
      const y = r * Math.sin(theta);
      const z = amplitud * besselJ0(k_n * r) * Math.cos(tiempo);
      data.push({x, y, z});
    }
  }
  return data;
}

// Generar datos para vista lateral (corte transversal)
datosLateral = {
  const n_points = 100;
  const r_vals = Array.from({length: n_points}, (_, i) => i * a / (n_points - 1));
  
  return r_vals.map(r => ({
    r: r,
    z: amplitud * besselJ0(k_n * r) * Math.cos(tiempo)
  }));
}

Plotly = require("https://cdn.plot.ly/plotly-2.26.0.min.js")

html`<div id="plotly-container-tambor" style="width: 100%;"></div>`

{
  // Generar malla 3D
  const n_r = 50;
  const n_theta = 60;
  
  let x = [];
  let y = [];
  let z = [];
  
  for (let i = 0; i < n_r; i++) {
    let x_row = [];
    let y_row = [];
    let z_row = [];
    
    const r = i * a / (n_r - 1);
    
    for (let j = 0; j < n_theta; j++) {
      const theta = j * 2 * Math.PI / (n_theta - 1);
      x_row.push(r * Math.cos(theta));
      y_row.push(r * Math.sin(theta));
      z_row.push(amplitud * besselJ0(k_n * r) * Math.cos(tiempo));
    }
    
    x.push(x_row);
    y.push(y_row);
    z.push(z_row);
  }
  
  const data = [{
    type: 'surface',
    x: x,
    y: y,
    z: z,
    colorscale: 'RdYlBu',
    reversescale: true,
    showscale: true,
    colorbar: {
      title: 'Desplazamiento',
      len: 0.7
    },
    cmin: -1,
    cmax: 1
  }];
  
  const layout = {
    title: `Modo ${modo}: Vista 3D del Tambor (ωt = ${(tiempo).toFixed(2)})`,
    autosize: true,
    height: 400,
    scene: {
      xaxis: {title: 'x', range: [-1.2, 1.2]},
      yaxis: {title: 'y', range: [-1.2, 1.2]},
      zaxis: {title: 'z (desplazamiento)', range: [-1.2, 1.2]},
      camera: {
        eye: {x: .7, y: .7, z: 0.5}
      },
      aspectmode: 'cube'
    }
  };
  
  const config = {
    responsive: true,
    displayModeBar: true
  };
  
  Plotly.react('plotly-container-tambor', data, layout, config);
  
  return html`<div></div>`;
}

html`<div id="plotly-container-lateral" style="width: 100%; margin-top: 30px;"></div>`

{
  const r_vals = Array.from({length: 200}, (_, i) => (i / 199) * 2 * a - a);
  const z_vals = r_vals.map(r => amplitud * besselJ0(k_n * Math.abs(r)) * Math.cos(tiempo));
  
  const data = [{
    type: 'scatter',
    x: r_vals,
    y: z_vals,
    mode: 'lines',
    line: {
      color: 'steelblue',
      width: 3
    },
    name: 'Membrana'
  }, {
    type: 'scatter',
    x: [-a, a],
    y: [0, 0],
    mode: 'markers+lines',
    line: {
      color: 'black',
      width: 2,
      dash: 'dash'
    },
    marker: {
      color: 'red',
      size: 8
    },
    name: 'Bordes fijos'
  }];
  
  const layout = {
    title: `Modo ${modo}: Vista Lateral (Corte Transversal) - ωt = ${(tiempo).toFixed(2)}`,
    autosize: true,
    height: 400,
    xaxis: {
      title: 'Radio (r)',
      range: [-1.3, 1.3],
      zeroline: true,
      zerolinecolor: 'rgba(0,0,0,0.3)',
      gridcolor: 'rgba(0,0,0,0.1)'
    },
    yaxis: {
      title: 'Desplazamiento vertical (z)',
      range: [-1.3, 1.3],
      zeroline: true,
      zerolinecolor: 'rgba(0,0,0,0.3)',
      gridcolor: 'rgba(0,0,0,0.1)'
    },
    showlegend: true,
    legend: {
      x: 0.02,
      y: 0.98,
      xanchor: 'left',
      yanchor: 'top'
    },
    margin: {t: 60, r: 40, b: 60, l: 60}
  };
  
  const config = {
    responsive: true,
    displayModeBar: true
  };
  
  Plotly.react('plotly-container-lateral', data, layout, config);
  
  return html`<div></div>`;
}

Los círculos nodales son visibles como anillos donde el color no cambia en la vista superior

---

Figuras de Chladni: Visualizando las Vibraciones

En la segunda mitad de 1700, el físico alemán Ernst Chladni descubrió un método para visualizar los patrones de vibración: espolvorear arena fina sobre una placa o membrana vibrante. La arena se acumula en las líneas nodales (donde no hay movimiento), revelando los patrones geométricos de cada modo.

¿Por qué se forman estos patrones?

• Las zonas que vibran intensamente agitan y expulsan la arena
• Los nodos (puntos en reposo) actúan como refugios donde la arena se deposita
• El resultado: patrones geométricos que corresponden exactamente a las soluciones matemáticas

Patrones de Chladni para el Caso Axisimétrico

Los modos que hemos estudiado (\(n = 1, 2, 3, 4\)) producen patrones de círculos concéntricos:

{
  const width = 730;
  const height = 250;
  const radius = 80;
  const spacing = 180;
  
  const svg = d3.create("svg")
    .attr("width", width)
    .attr("height", height)
    .attr("viewBox", [0, 0, width, height]);
  
  // Función auxiliar para encontrar ceros de Bessel
  const zerosJ0 = [0, 2.4048, 5.5201, 8.6537, 11.7915];
  
  for (let n = 1; n <= 4; n++) {
    const g = svg.append("g")
      .attr("transform", `translate(${spacing/2 + (n-1) * spacing}, ${height/2})`);
    
    // Círculo exterior
    g.append("circle")
      .attr("r", radius)
      .attr("fill", "none")
      .attr("stroke", "black")
      .attr("stroke-width", 2);
    
    // Círculos nodales internos
    for (let i = 1; i < n; i++) {
      const r_nodal = radius * zerosJ0[i] / zerosJ0[n];
      g.append("circle")
        .attr("r", r_nodal)
        .attr("fill", "none")
        .attr("stroke", "#e74c3c")
        .attr("stroke-width", 2.5)
        .attr("stroke-dasharray", "3,3");
    }
    
    // Etiqueta
    g.append("text")
      .attr("y", radius + 25)
      .attr("text-anchor", "middle")
      .attr("font-size", "14px")
      .attr("font-weight", "bold")
      .text(`n = ${n}`);
  }
  
  return svg.node();
}

Videos: Figuras de Chladni en Acción

Observa estos experimentos reales donde se forman los patrones de Chladni:

NotaChladni circular

NotaChladni circular - nuevos modos

NotaExperimento con placa de Chladni

Aplicaciones modernas

Las figuras de Chladni tienen aplicaciones en muchas areas:

• Ingeniería acústica: diseño de instrumentos musicales
• Control de calidad: detección de defectos en materiales
• Nanotecnología: manipulación de partículas microscópicas
• Arte sonoro: instalaciones que visualizan música en tiempo real

---

© Licencia Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional (CC BY-NC-SA 4.0)