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.

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))

Representación de velocidad y ángulo

Á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.

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)))

Área de velocidades

Á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.

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

Ángulo aleatorio

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.

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

Tiro parabólico en 3D

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)

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)

Representación de las funciones restantes

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,tiempo

Final)

Método Runge Kutta

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.