LA FÍSICA DEL DEPORTE
Daniel Alonso Gil
Diego Caso Parajón
El tiro parabólico

Nuestro proyecto consiste en el análisis y desarrollo de la trayectoria
que describe un movimiento parabólico de una pelota de baloncesto
lanzada por un jugador, en el estudiamos:

Estudia las características de los lanzamientos que acaban en enceste limpio.

Representa las velocidades iniciales frente al ángulo.

Calcula la velocidad mínima y máxima para encestar la pelota que se
corresponde con el diámetro del aro de baloncesto.

Calcula el área y el punto donde hay mas área de la diferencia de velocidad
máxima y mínima.

Representa un lanzamiento en 2D y 3D con un ángulo aleatorio, para que la
canasta sea perfecta y las dos velocidades.
El tiro parabólico

Las ecuaciones que describen una trayectoria parabólica vienen dadas
por la cinemática Newtoniana:
Esto nos ayuda a:
1. Conseguir una velocidad de lanzamiento
y esfuerzo físico menores que permiten,
por tanto, un lanzamiento más cómodo.
2.
Permitir una mayor tolerancia al error en
el ángulo de lanzamiento.
El tiro parabólico

Desarrollando las ecuaciones del movimiento parabólico llegamos las ecuaciones
que hemos utilizado nosotros:

Omitiremos los aspectos áridos de la deducción de tales fórmulas para no eclipsar
los aspectos fundamentales de carácter cualitativo que conviene destacar aquí.

Estas ecuaciones dependen una serie de constantes.

Nuestra motivación para realizar este proyecto ha sido nuestra pasión por el
deporte, en especial el baloncesto, y nuestra curiosidad por encontrar toda la física
que se esconde detrás.
Función principal

Input de la función principal:

El usuario da al programa la altura de un jugador de baloncesto y la posición
en el campo de dicho jugador.


El programa calcula una serie de cosas que explicaremos a continuación.
Para cada input hay una serie de ángulos con los que se puede encestar.
Representación de velocidad y ángulo

Para cada ángulo hay una velocidad máxima y mínima asociadas, debido al
diámetro de la canasta.

Nuestro programa primero calcula el mayor valor de las velocidades
mínima y máxima.

Y representa las velocidades mínimas y máximas con respecto al ángulo.
Representación de velocidad y ángulo





theta=(-pi/2 : 0.01: pi/2);
L1=norm(r);
L2=norm(r)+(d-rb);
v0min=real(sqrt((g.*L1)./((2.*(cos(theta)).^2).*(tan(theta)-((H-h)./L1)))));
v0max=real(sqrt((g.*L2)./((2.*(cos(theta)).^2).*(tan(theta)-((H-h)./L2)))));

v0min_value=max(real(sqrt((g.*L1)./((2.*(cos(theta)).^2).*(tan(theta)-((H-h)./L1))))))
v0max_value=maxreal(sqrt((g.*L2)./((2.*(cos(theta)).^2).*(tan(theta)-((H-h)./L2))))))

Dv=(v0max-v0min);



positiveDv=find(Dv>0);





subplot(2,2,1)
plot(theta,v0min,theta,v0max)
subplot(2,2,2)
plot(theta(positiveDv),Dv(positiveDv))
Área de velocidades

El programa calcula el punto en el que el la diferencia entre la velocidad
máxima y mínima es mayor.

El área se calcula llamando a la función de la integral dada en clase, que
nosotros hemos llamado “area”.

A continuación el programa representa el área de la diferencia de la
velocidad máxima y mínima, donde los rangos en los que se mueven las
velocidades con respecto al ángulo theta.
Área de velocidades








dif=max(Dv);
i=1;
while dif~=Dv(i)
i=i+1;
end
thetamax=-pi/2+0.01*(i-1)
thetamax_grades=thetamax.*180/pi
[x]=[thetamax,dif]







f1= @(x) sqrt((g.*L1)./((2.*(cos(x)).^2).*(tan(x)-((H-h)./L1))));
f2= @(x) sqrt((g.*L2)./((2.*(cos(x)).^2).*(tan(x)-((H-h)./L2))));
%f3=f2-f1
f3= @(x) (sqrt((g.*L2)./((2.*(cos(x)).^2).*(tan(x)-((H-h)./L2))))sqrt((g.*L1)./((2.*(cos(x)).^2).*(tan(x)-((H-h)./L1)))));
A=abs(real(area(f3,-pi/2+0.01,pi/2-0.01,0.01)))
Ángulo aleatorio

El programa escoge un ángulo totalmente aleatorio, si para ese
ángulo la velocidad máxima es menor que la mínima (lo cual pasa
con algunos ángulos) coge otro ángulo y deshecha el anterior.

Así hasta que para el ángulo escogido la velocidad mínima sea menor
que la máxima.

Ese ángulo después lo utiliza para dibujar la trayectoria.
Ángulo aleatorio


boolean=true;
while(boolean==true)

aleat=-pi/2+rand()*pi;

vmin=real(feval(f1,aleat));

vmax=real(feval(f2,aleat));
if (vmax>vmin)

boolean=false;

end



end
aleat_grades=aleat*180/pi
Tiro parabólico en 3D

Adapta las ecuaciones del tiro parabólico a unas coordenadas
esféricas para poder dibujar una gráfica de un tiro en tres
dimensiones.
Tiro parabólico en 3D

function [hmax1,hmax2]=tiro3D ( theta,phi,v1,v2, tiempoFinal,ini)










g=9.81;
figure;
t=(0 : 0.0005: tiempoFinal);
x=-ini(1)+v1.*cos(theta).*cos(phi).*t;
y=-ini(2)+v1.*cos(theta).*sin(phi).*t;
z=ini(3)+v1.*sin(theta).*t-0.5.*g.*t.^2;
x2=-ini(1)+v2.*cos(theta).*cos(phi).*t;
y2=-ini(2)+v2.*cos(theta).*sin(phi).*t;
z2=ini(3)+v2.*sin(theta).*t-0.5.*g.*t.^2;







theta2 = (0:0.01:2*pi);
x3=cos(theta2).*0.457;
y3=sin(theta2)*0.457;
n=numel(theta2);
z3(1:n)=3.05;
end
Representación de las funciones restantes

Ahora se dibujan las 3 funciones que faltan:

La trayectoria para la velocidad mínima animada (comet)

La trayectoria para ambas velocidades

La trayectoria en tres dimensiones (implementando el ángulo
lateral phi y llamando a la función tiro 3D, que convierte las
coordenadas en esféricas)
Representación de las funciones restantes
hold off
figure (2)
comet (t,y0min)
xlabel('time(s)')
ylabel('heght(m)')
pause
figure (3)
plot (t,y0max,t,y0min)
xlabel('time(s)')
ylabel('height')
grid on
phi=atan(r(2)/r(1));
phi_grades=phi*180/pi
tiro3D (aleat, phi, vmin,vmax, tiempoFinal,ini)
Método Runge Kutta

















function[ ]=rungekutta4(x0,x1,y0,n,aleat,g,vmax,h,tiempoFinal)
f=h + vmax.*sin(aleat).*tiempoFinal - 0.5.*g.*tiempoFinal.^2;
h1=(x1-x0)/n;
xs=x0:h1:x1;
for i=1:n
it=i-1;
x0=xs(i);
x=x0; y=y0;
k1=h1*f;
x=xs(i+1);
y=y0+k1;
k2=h1*f;
y0=y0+(k1+k2)/2;
%fprintf('\n%2.0f%10.6f%10.6f\n',it,x0,y0); %delete the (%)before the...
%...fprint if you want to see it step by step
end
fprintf('\n El punto aproximado y(x1) es = %8.6f\n',y0);
Método Runge Kutta






function[ ]=testrungekutta(tiempoFinal,t,aleat,g,vmax,h)
x0=0;
x1=tiempoFinal;
n=numel(t);
y0=h;
rungekutta4(x0,x1,y0,n,aleat,g,vmax,h,tiempoFinal)
Reflexión y conclusiones

Lo que, a priori, puede parecer un proyecto sencillo debido a que las
ecuaciones no son excesivamente complejas y la física del problema es
conocida por todos; a nosotros nos ha supuesto un reto analizar a fondo el
tiro parabólico, exprimiendo sus posibilidades.

A modo de resumen, podemos decir que a partir de un problema que
podemos observar en el día a día, hemos introducido todos los conceptos de
matlab dados en clase, entre otros:

Estudio y representación de varias funciones.

Operaciones con vectores y matrices.

Utilización de bucles y sentencias de control.

Llamada a funciones.

Integración numérica y método RungeKutta.
Descargar

Slide 1