LA FÍSICA DEL DEPORTE

1. LA FÍSICA DEL DEPORTE • Daniel Alonso Gil • Diego Caso Parajón

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

3. El tiro parabólico • Las ecuaciones que describen una trayectoria parabólica vienen dadas por la cinemática Newtoniana: • Esto nos ayuda a: • 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. 

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

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

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

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

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

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

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

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

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

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

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

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

16. Método RungeKutta • 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);

17. Método RungeKutta • 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)

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