6.

- Oscilador Amortiguado y Forzado -

Resonancia
H echo por, M anuel L ópez P érez y Raf ael M ayoral H ernández

-Información general

·Fecha: 04/03/2025

·Lugar: Laboratorio de física

·Temperatura: 18.9°C

·Humedad: 54 %

·Presión: 1019.6 HPa

·Grupo 2

Resumen

En esta práctica hemos hecho principalmente dos cosas, comprobar el

ef ecto de resonancia en un muelle forzado mediante un motor, al que habiamos
conectado un generador de funciones (con el que controlabamos la frecuencia de
oscilación); y por otra parte hemos comprobado y cuantificado el efecto del rozamiento en
la resonancia.

En la primera parte de la práctica, pusimos un móvil con la aplicación "phyphox",

anteriormente conectado con nuestro portatil para poder controlarlo remotamente. Con ello
fuimos descargando los datos que ibamos obteniendo con las diferentes frecuencias.

En la segunda parte de la práctica, pusimos un imán en la parte baja de la cesta metálica,

este imán en cada oscilación atravesaba una bobina de cobre, lo que provocaba una
inducción electromagnética (que como ya sabemos produce un campo eléctrico que se
opone al magnético que lo ha generado anteriormente), de esta manera conseguíamos un
freno electromagnético.

T eor a í
Considérese un muelle de masa despreciable, del cual cuelga una masa m. El muelle está
sujeto a un motor, el cual le aplica una fuerza periódica F(t) = FH cos(ωt) de frecuencia
angular ω = 2πv , siendo ν la frecuencia de oscilación del motor. La masa oscilante sufre
además una fuerza de fricción con el medio circundante (por ejemplo, con el aire), que será
proporcional a su velocidad, F f ric = −λv . Teniendo en cuenta la fuerza recuperadora del
muelle, F H ooke
= −kx (siendo x el desplazamiento con respecto a la posición de equilibrio
x0 = 0 ), el movimiento de la masa se rige por la ecuación:

2
d x dx
2
+ 2γ + w x = F0 cos(wt) (1)
0
2
dt dt

donde 2γ = λ/m yw 2
0
= k/m es la frecuencia angular propia de oscilación de la masa,
siendo v 0
= w0 /(2π) la recuencia propia del sistema.

Como resultado, la masa oscilarña siguiendo la ecuación x(t) = A ⋅ sin(wt − δ) . Nótese

que la frecuencia de este movimiento es la que impone el motor, w, y no la natural del
sistema, w . La amplitud de este movimiento viene dada por [véase Alonso y Finn, Física, Vol.
0

1 Mecánica (Fondo Educativo Interamericano, 1970), secciones 12.12 y 12.13, pp. 387-393]:

F0 /m A0
A = = (2)
2 2 2 2 2 1/2 2 2 2 2 2 1/2
[(w − w ) + 4γ w ] [(w − w ) + 4γ w ]
0 0

donde hemos llamado A 0

= F0 /m . Para cierto valor de la frecuencia del motor, próximo a
la frecuencia natural del sistema, w = wmax ≈ w0 , la amplitud de oscilación presentará un
máximo muy pronunciado. Se dice que el sistema ha estado en resonancia. La
representación de A frente a w presentará un pico muy estrecho. Cuanto menor sea el
efecto del rozamiento (cuanto menor sea γ), más afilado será este máximo (tratándose de
una divergencia en el límite γ → 0 ).

Pueden obtenerse la velocidad y la aceleración de la masa oscilante derivando la ecuación

de la posición con respecto al tiempo, v ya . De aquí podemos deducir la
dx dH x
= =
dt dtH

aceleración:
2
a(t) = −Aw sin(wt − δ) = a0 sin(2πvt − δ) (3)

que presenta una amplitud dada por:

2 2
w ⋅ (F0 /m) A0 ⋅ (2πv)
A = = (4)
2 2 2 2 2 1/2 2 2 2 2 2 1/2
[(w − w ) + 4γ w ] [((2πv) − (2πv0 ) ) + 4γ (2πv) ]
0

que también presentará un máximo a una frecuencia w = wmax ≈ w0

El objetivo de la práctica consiste en forzar el movimiento de un muelle (del que cuelga un

teléfono móvil) mediante un motor de frecuencia regulable, para observar el fenómeno de
resonancia. El acelerómetro del móvil registra su aceleración en función del tiempo, lo que
permite cuantificar el fenómeno. La experiencia se realiza con el rozamiento casi inapreciable
del aire, así como con la fricción proporcionada por un freno electromagnético.
 Librerías y funciones necesarias
In [1]: from __future__ import print_function
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
from scipy.optimize import curve_fit

Función sinusoidal para la aceleración en función del tiempo, a(t), ec. (3) del guion:

In [2]: # Función seno

def Seno(x, A, nu, delta, y0):
y = A*np.sin(2.0*np.pi*nu*x + delta) + y0
# y = A*np.sin(2*3.1415*nu*x + delta) + y0
return y

Función para la amplitud (en aceleración) del oscilador en función de la frecuencia, a 0

(ν) , ec.
(4) del guion. Nótese la dependencia con la frecuencia y no con la frecuencia angular, ω:

In [3]: # Función resonancia

def Resonancia(x, A0, nu0, gamma):
y = A0*(2.0*np.pi*x)**2/(((2.0*np.pi*x)**2-(2.0*np.pi*nu0)**2)**2+4*gamma**2*(
return y

Inicialización de vectores para las frecuencias ν , las amplitudes a y sus incertidumbres:

0

In [4]: nus = []
As = []
nu_err = []
A_err = []

Experiencia 1

Frecuencia 1.05 Hz
In [5]: datax = np.loadtxt('Raw Data 1.1.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 1.1.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.050, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

 fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.03498 +/- 0.00066 Hz

Amplitud: 0.02704 +/- 0.00033 m/s**2

In [6]: nus = np.append(nus, fit_nu)

As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

Frecuencia 1.10 Hz
In [7]: # Carga del fichero correspondiente de Phyphox. Nótese que está preparado para salt

datax = np.loadtxt('Raw Data 1.2.csv', usecols=0, skiprows=1)

datay = np.loadtxt('Raw Data 1.2.csv', usecols=2, skiprows=1)

# Estimación de la línea base y de la amplitud

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

# Propuesta de parámetros iniciales para el ajuste no lineal

param_inicial = [Ainic, 1.10, 0.0, y0inic]

# Ajuste no lineal por mínimos cuadrados a la ec. (3) del guion

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

# Representación gráfica

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

# Escritura de resultados "medidos"

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.08157 +/- 0.00076 Hz

Amplitud: 0.036782 +/- 0.00050 m/s**2
In [8]: nus = np.append(nus, fit_nu)
As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

In [9]: nus = np.append(nus, fit_nu)

As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

Frecuencia 1.15 Hz
In [10]: datax = np.loadtxt('Raw Data1.3.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data1.3.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.150, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
 u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.13224 +/- 0.00050 Hz

Amplitud: 0.04962 +/- 0.00046 m/s**2

Frecuencia 1.20 Hz
In [11]: datax = np.loadtxt('Raw Data 1.4.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 1.4.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.20, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

 fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.17670 +/- 0.00034 Hz

Amplitud: 0.07087 +/- 0.00045 m/s**2

In [12]: nus = np.append(nus, fit_nu)

As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

Frecuencia 1.25 Hz
In [13]: datax = np.loadtxt('Raw Data 1.5.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 1.5.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.2500, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.22538 +/- 0.00017 Hz

Amplitud: 0.12122 +/- 0.00036 m/s**2
In [14]: nus = np.append(nus, fit_nu)
As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

Frecuencia 1.27 Hz
In [15]: datax = np.loadtxt('Raw Data 1.8.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 1.8.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.27, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

 plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.24915 +/- 0.00010 Hz

Amplitud: 0.18769 +/- 0.00035 m/s**2

In [16]: nus = np.append(nus, fit_nu)

As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

A_err

Out[16]: array([0.0003267 , 0.0004986 , 0.0004986 , 0.0004486 , 0.00036267,

0.0003454 ])

In [17]: nus = np.append(nus, fit_nu)

As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

Frecuencia 1.30 Hz
In [18]: datax = np.loadtxt('Raw Data 2.6.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 2.6.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.300, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.27762 +/- 0.00005 Hz

Amplitud: 0.90370 +/- 0.00078 m/s**2
In [19]: nus = np.append(nus, fit_nu)
As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

Frecuencia 1.40 Hz
In [20]: datax = np.loadtxt('Raw Data 1.7.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 1.7.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.40, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

 plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.37269 +/- 0.00009 Hz

Amplitud: 0.18622 +/- 0.00032 m/s**2

Amplitud frente a frecuencia

In [21]: plt.plot(nus, As, 'o', label='Medidas experimentales')
plt.xlabel("frecuencia (Hz)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

Out[21]: <matplotlib.legend.Legend at 0x224bafa8050>

 Propuesta de parámetros iniciales para el ajuste no lineal por mínimos cuadrados a la ec. (4)
del guion:

In [22]: param_inicial = [0.4, 1.3, 0.1]

In [65]: parameters_reso, covariance_reso = curve_fit(Resonancia, nus, As, p0=param_inicial

In [24]: parameters_reso

Out[24]: array([1.15387301e-02, 1.28575780e+00, 3.07045025e-08])

In [25]: covariance_reso

Out[25]: array([[inf, inf, inf],

[inf, inf, inf],
[inf, inf, inf]])

In [26]: A0 = parameters_reso[0]
nu0 = parameters_reso[1]
gamma = parameters_reso[2]
A0_u = covariance_reso[0,0]
nu0_u = covariance_reso[1,1]
gamma_u = covariance_reso[2,2]

In [27]: nu_fit = np.arange(0.75, 2.25, 0.001)

y_fit = Resonancia(nu_fit, A0, nu0, gamma)
#plt.errorbar(nus, As, xerr=nu_err, yerr=A_err, linestyle='None', marker='o', label
plt.plot(nus, As, 'o', label='Medidas experimentales')
 plt.plot(nu_fit, y_fit, '-', label='Mínimos cuadrados')
plt.xlabel("frecuencia (Hz)")
plt.ylabel("Aceleración (m/s^2)")
plt.yscale("log")
plt.legend()

Out[27]: <matplotlib.legend.Legend at 0x224b9980ce0>

In [28]: print(f"A0: {A0:.8f} +/- {A0_u:.8f} (m/s^2)")

print(f"Frecuencia de resonancia: {nu0:.7f} +/- {nu0_u:.7f} Hz")
print(f"Gamma: {gamma:.8f} +/- {gamma_u:.8f} (s^-2)")

A0: 0.01153873 +/- inf (m/s^2)

Frecuencia de resonancia: 1.2857578 +/- inf Hz
Gamma: 0.00000003 +/- inf (s^-2)

V (Hz) a 0 (m/s )
2

1.05 0.03

1.10 0.04

0.15 0.05

1.20 0.07

1.25 0.1

1.27 0.19

1.30 0.64
 V (Hz) a 0 (m/s )
2

1.40 0.19

Experiencia 2

In [29]: # Función seno

def Seno(x, A, nu, delta, y0):
y = A*np.sin(2.0*np.pi*nu*x + delta) + y0
# y = A*np.sin(2*3.1415*nu*x + delta) + y0
return y

In [30]: # Función resonancia

def Resonancia(x, A0, nu0, gamma):
y = A0*(2.0*np.pi*x)**2/(((2.0*np.pi*x)**2-(2.0*np.pi*nu0)**2)**2+4*gamma**2*(
return y

In [31]: nus = []
As = []
nu_err = []
A_err = []

Frecuecia 1.00 Hz
In [32]: datax = np.loadtxt('Raw Data 2.1.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 2.1.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 0.95, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
 plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 0.98560 +/- 0.00195 Hz

Amplitud: 0.02238 +/- 0.00081 m/s**2

In [33]: nus = np.append(nus, fit_nu)

As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

Frecuencia 1.10 Hz
In [34]: datax = np.loadtxt('Raw Data 2.2.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 2.2.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.05, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
 fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.08101 +/- 0.00157 Hz

Amplitud: 0.03872 +/- 0.00114 m/s**2

In [35]: nus = np.append(nus, fit_nu)

As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

Frecuencia 1.20 Hz
In [36]: datax = np.loadtxt('Raw Data 2.3.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 2.3.csv', usecols=2, skiprows=1)
 y0inic = (datay.max() + datay.min()) / 2
Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.15, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.17765 +/- 0.00028 Hz

Amplitud: 0.08898 +/- 0.00046 m/s**2
In [37]: nus = np.append(nus, fit_nu)
As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

Frecuencia 1.25 Hz
In [38]: datax = np.loadtxt('Raw Data 2.4.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 2.4.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.20, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.22896 +/- 0.00009 Hz

Amplitud: 0.21598 +/- 0.00035 m/s**2
In [39]: nus = np.append(nus, fit_nu)
As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

Frecencia 1.27 Hz
In [40]: datax = np.loadtxt('Raw Data 2.5.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 2.5.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.25, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

 plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.24653 +/- 0.00005 Hz

Amplitud: 0.42882 +/- 0.00043 m/s**2

In [41]: nus = np.append(nus, fit_nu)

As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

Frecuencia 1.30 Hz
In [42]: datax = np.loadtxt('Raw Data 1.6.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 1.6.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.27, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

 fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.28155 +/- 0.00005 Hz

Amplitud: 0.63557 +/- 0.00054 m/s**2

In [43]: nus = np.append(nus, fit_nu)

As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

Frecuencia 1.35 Hz
In [44]: datax = np.loadtxt('Raw Data 2.7.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 2.7.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.30, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.32352 +/- 0.00007 Hz

Amplitud: 0.22522 +/- 0.00029 m/s**2
In [45]: nus = np.append(nus, fit_nu)
As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

Frecuencia 1.40 Hz
In [46]: datax = np.loadtxt('Raw Data 2.8.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 2.8.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.35, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

 plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.37335 +/- 0.00017 Hz

Amplitud: 0.11482 +/- 0.00035 m/s**2

In [47]: nus = np.append(nus, fit_nu)

As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

Frecuencia 1.45 Hz
In [48]: datax = np.loadtxt('Raw Data 2.9.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 2.9.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.40, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

 fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.42062 +/- 0.00021 Hz

Amplitud: 0.08072 +/- 0.00031 m/s**2

In [49]: nus = np.append(nus, fit_nu)

As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

Frecuencia 1.50 Hz
In [50]: datax = np.loadtxt('Raw Data 2.10.csv', usecols=0, skiprows=1)
datay = np.loadtxt('Raw Data 2.10.csv', usecols=2, skiprows=1)

y0inic = (datay.max() + datay.min()) / 2

Ainic = (datay.max() - datay.min()) / 2

param_inicial = [Ainic, 1.45, 0.0, y0inic]

parameters, covariance = curve_fit(Seno, datax, datay, p0=param_inicial)

fit_A = parameters[0]
fit_nu = parameters[1]
fit_delta = parameters[2]
fit_y0 = parameters[3]
u_A = np.sqrt(np.diag(covariance)[0])
u_nu = np.sqrt(np.diag(covariance)[1])
u_delta = np.sqrt(np.diag(covariance)[2])
u_y0 = np.sqrt(np.diag(covariance)[3])

fit_y = Seno(datax, fit_A, fit_nu, fit_delta, fit_y0)

plt.plot(datax, datay, '-o', label='Medidas experimentales')
plt.plot(datax, fit_y, '-', label='Ajuste no lineal')
plt.xlabel("t (s)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

print(f"Frecuencia: {fit_nu:.5f} +/- {u_nu:.5f} Hz")

print(f"Amplitud: {np.absolute(fit_A):.5f} +/- {u_A:.5f} m/s**2")

Frecuencia: 1.47092 +/- 0.00030 Hz

Amplitud: 0.06256 +/- 0.00035 m/s**2
In [51]: nus = np.append(nus, fit_nu)
As = np.append(As, np.absolute(fit_A))
nu_err = np.append(nu_err, u_nu)
A_err = np.append(A_err, u_A)

In [52]: plt.plot(nus, As, 'o', label='Medidas experimentales')

plt.xlabel("frecuencia (Hz)")
plt.ylabel("Aceleración (m/s^2)")
plt.legend()

Out[52]: <matplotlib.legend.Legend at 0x224bc34e900>

In [53]: param_inicial = [0.4, 1.3, 0.1]

In [54]: parameters_reso, covariance_reso = curve_fit(Resonancia, nus, As, p0=param_inicial

In [55]: parameters_reso

Out[55]: array([0.01658309, 1.26872155, 0.06720339])

In [56]: covariance_reso

Out[56]: array([[7.28980157e-07, 4.44641979e-07, 1.05738479e-05],

[4.44641979e-07, 6.99360610e-07, 8.88324960e-06],
[1.05738479e-05, 8.88324960e-06, 1.82304608e-04]])

In [57]: A0 = parameters_reso[0]
nu0 = parameters_reso[1]
gamma = parameters_reso[2]
A0_u = covariance_reso[0,0]
nu0_u = covariance_reso[1,1]
gamma_u = covariance_reso[2,2]

In [58]: nu_fit = np.arange(0.75, 2.25, 0.001)

y_fit = Resonancia(nu_fit, A0, nu0, gamma)
#plt.errorbar(nus, As, xerr=nu_err, yerr=A_err, linestyle='None', marker='o', label
plt.plot(nus, As, 'o', label='Medidas experimentales')
plt.plot(nu_fit, y_fit, '-', label='Mínimos cuadrados')
plt.xlabel("frecuencia (Hz)")
plt.ylabel("Aceleración (m/s^2)")
 plt.yscale("log")
plt.legend()

Out[58]: <matplotlib.legend.Legend at 0x224bc385160>

In [59]: print(f"A0: {A0:.8f} +/- {A0_u:.8f} (m/s^2)")

print(f"Frecuencia de resonancia: {nu0:.7f} +/- {nu0_u:.7f} Hz")
print(f"Gamma: {gamma:.8f} +/- {gamma_u:.8f} (s^2)")

A0: 0.01658309 +/- 0.00000073 (m/s^2)

Frecuencia de resonancia: 1.2687215 +/- 0.0000007 Hz
Gamma: 0.06720339 +/- 0.00018230 (s^2)

V (Hz) a 0 (m/s )
2

1.00 0.02

1.10 0.04

0.20 0.09

1.25 0.22

1.27 0.43

1.30 0.64

1.35 0.23

1.40 0.11

1.45 0.08
 V (Hz) a 0 (m/s )
2

1.50 0.06

Conclusi ón
Conocidas las ecuaciones:

k
2
w = (1)
0
m

w0 = 2π ⋅ v0

de donde sacamos que

w0
v0 = (2)
2π

Según fabricante k = 20 N /m , y nosotros medimos experimentalmente el muelle y el imán.

mmuelle = 303.23 ± 0.01 g ym im n á = 10.83 ± 0.01 g .

In [60]: k = 20
m = 0.30323
m_iman = 0.01083

Usaremos también la fórmula de siempre para hallar el error:

V alor te órico + V alor experimental

Error =
V alor te órico

- Experiencia 1
Frecuencia de resonancia v 0 = 1.2857578

Valor de gamma γ
−8 −2
= 3 ⋅ 10 s

In [61]: w02_experiencia_1 = k/m #(1)

w0_experiencia_1 = np.sqrt(w02_experiencia_1)

v0_experiencia_1 = w0_experiencia_1/(2*np.pi) #(2)

print(f"Frecuencia de resonancia teórica primera experiencia: {v0_experiencia_1:.5f

Frecuencia de resonancia teórica primera experiencia: 1.29256

In [62]: error_experiencia_1 = (v0_experiencia_1+1.2857578)/v0_experiencia_1
error_experiencia_1

Out[62]: 1.9947412349992308

Con esto vemos que hemos tenido un error de tan solo el 2 % al hallar la frecuencia de
resonancia.

Este escaso error es debido a no haber prácticamente frición con el aire, por ello y al no
haber otra resistencia que pudiese alterar la frecuencia de resonancia, los datos nos salen
tan cerca del valor teórico.

- Experiencia 2
Frecuencia de resonancia v 0 = 1.2687215

Valor de gamma γ = 0.06720339 s

−2

In [63]: w02_experiencia_2 = k/(m+m_iman) #(1)

w0_experiencia_2 = np.sqrt(w02_experiencia_2)

v0_experiencia_2 = w0_experiencia_2/(2*np.pi) #(2)

print(f"Frecuencia de resonancia teórica segunda experiencia: {v0_experiencia_2:.5f

Frecuencia de resonancia teórica segunda experiencia: 1.27007

La amplitud de resonancia en un sistema amortiguado debe ser menor que en un sistema no

amortiguado debido a la presencia de fuerzas que disipan (absorben) energía del sistema. En
este caso vemos que 1.27007 < 1.29256.

In [64]: error_experiencia_2 = (v0_experiencia_2+1.2687215)/v0_experiencia_2

error_experiencia_2

Out[64]: 1.9989355827654953

Aunque nos sale un error prácticamente igual (del 2 %), sabemos que este es algo mayor
debido a que en este caso hay más fuerzas disipadoras (el campo que se opone al
movimiento debido a la corriente que induce el imán de la base de la cesta al atravesar la
bobina).