Free Web Site - Free Web Space and Site Hosting - Web Hosting - Internet Store and Ecommerce Solution Provider - High Speed Internet
Search the Web

Lanzamiento de Proyectil en el plano (X, Y, Z)

Se implementó una clase qe simulara el comportamiento espacial de un proyectil lanzado en un espacio de tres dimensiones.

El proyectil puede simular desde lanzamientos con aceleración constante en sus tres ejes (X,Y,Z), hasta movimientos rectilineos de velocidad constante.

Por ejemplo , se hizo un programa de prueba con las siguientes condiciones iniciales :

vector aceleración : { 0.0 , 0.0 , -9.8 }
vector velocidad inicial : { 30.0 , 5.0 , 130.0 }
vector posición inicial : { 2.0 , 1.0 , 0.0 }

Por lo tanto se trata de un lanzamiento desde el punto (2.0 , 1.0 , 0.0) del plano tridimensional , teniendo las características de un lanzamiento con un cierto ángulo con respecto al eje Z.
Es por eso que en el vector aceleración inicial , la componente z simula la constante de gravedad.

Teniendo las condiciones iniciales de aceleración, velocidad y posición , la clase se encarga internamente de obtener los polinomios correspondientes en función del tiempo.

Salida del programa de prueba

Atributos y Métodos de la clase proyectil

Constructor

Inicializa internamente las variables de tipo VectorEspacial (aceleración, velocidad, posición).

public Proyectil( )

Atributos

Cuenta con una constante G que representa la constantede gravedad (9.8) y tres vectores que manejan la aceleración, velocidad y posición del proyectil.

public final static double G = 9.8;

public VectorEspacial aceleracion;
public VectorEspacial velocidad;
public VectorEspacial posicion;

Métodos

Los siguientes métodos permiten formar los polinomios internos de cada vector según las condiciones iniciales que se le pasen.

public void asignarAceleraciones(double acel[ ])
public void calcularVectores(double vel_ini[ ] , double pos_ini[ ])

Ej : Proyectil lanzado en caída libre desde un bombardero
     a 800 mts de altura con una velocidad en el eje X de 120 m/s.

     Proyectil p = new Proyectil( );
     
     /* condiciones iniciales */
     
     double acel_ini[ ] = { 0.0 , 0.0 , -9.8  };
     double vel_ini[ ] = { 120.0 , 0.0 , 0.0 };
     double pos_ini[ ] = { 0.0 , 0.0 , 800.0 };
     
     p.asignarAceleraciones(acel_ini);
     p.calcularVectores(vel_ini , pos_ini);

Por último, se tienen dos métodos que evalúan los polinomios internos del vector velocidad y posición, retornando la referencia del arreglo que contiene los valores de la evaluación.

public double [ ]obtenerVelocidad(double t)
public double [ ]obtenerPosicion(double t) 

Ej : Se quiere saber la posición y la velocidad del proyectil pasado los 10 
     segundos de haberse lanzado desde el bombardero. 

     double vel[ ] = p.obtenerVelocidad(10.0);
     double pos[ ] = p.obtenerPosicion(10.0);
     
     System.out.println(" Velocidad eje Z : " + vel[ p.velocidad.Z ]);
     System.out.println(" Px : " + pos[ p.posicion.X ]);
     System.out.println(" Pz : " + pos[ p.posicion.Z ]);

Implementación de la clase proyectil

class Proyectil
{
    public final static double G = 9.8;

    public VectorEspacial aceleracion;
    public VectorEspacial velocidad;
    public VectorEspacial posicion;    
    
    public Proyectil( )
    {
        aceleracion = new VectorEspacial( );
        velocidad = new VectorEspacial( );
        posicion = new VectorEspacial( );    
    }

    public void asignarAceleraciones(double acel[ ])
    {
        double coef[ ] = new double[1];
    
        for(int i = 0; i < VectorEspacial.DIMENSIONES; i++)
        {
            coef[0] = acel[i];    
            aceleracion.asignarPolinomio(coef,i);
        }
    }

    public void calcularVectores(double vel_ini[ ],double pos_ini[ ])
    {
        velocidad = VectorEspacial.integrar(aceleracion,vel_ini);    
        posicion = VectorEspacial.integrar(velocidad,pos_ini);
    }

    public double [ ]obtenerVelocidad(double t)
    {
        velocidad.evaluar(t);    
        return velocidad.obtenerEvaluacion( );
    }

    public double [ ]obtenerPosicion(double t)
    {
        posicion.evaluar(t);
        return posicion.obtenerEvaluacion( );    
    }

} 

Programa de prueba

Consiste en determinar el tiempo total que un proyectil está en el "aire" , mostrando una tabla de contenga 14 mediciones de tiempo, posición y velocidad.

class prbProyectil
{
    /* Redondea o más bien limita a un número decimal a tener
       un decimal. */
       
    public static double redondear(double num)
    {
        double aux = num * 10;
        int tmp = (int) aux;
    
        return (double) tmp / 10;     
    }    

    /* Dado un proyectil, calcula con los métodos disponibles
       del objeto , el tiempo total de recorrido. */
    
    public static double t_recorrido(Proyectil p)
    {
        p.velocidad.evaluar(0.0);
        double vel[ ] = p.velocidad.obtenerEvaluacion();
        return 2 * vel[p.velocidad.Z] / p.G;
    } 


    public static void main(String arg[ ])
    {
        
        Proyectil p = new Proyectil( );
        
        double arr_acel[ ] = { 0.0 , 0.0 , -9.8  };
    
        p.asignarAceleraciones(arr_acel);
    
        double vel_ini[ ] = { 30.0 , 5.0 , 130.0 };
        double pos_ini[ ] = { 2.0 , 1.0 , 0.0 };
        
        p.calcularVectores(vel_ini , pos_ini);
    
        System.out.println("\n\ttiempo\t\tPosicion\t\t\tVelocidad");    
        System.out.println("\t------\t\t--------\t\t\t---------\n");    
        
        System.out.println("\tt\t\tPx\tPy\tPz\t\tvz\tV\tdif\n");
        
        double t_total = t_recorrido(p);
        double interv = t_total / 14;
        
        double t = 0.0;
        
        while(t <= t_total)
        {
            double pos[ ], vel[ ];
            vel = p.obtenerVelocidad(t);
            pos = p.obtenerPosicion(t);
            
            System.out.print("\t" + redondear(t) + "\t");
            
            for(int k = 0; k < 3; k++)
                System.out.print("\t"+ redondear(pos[k]));
            
            System.out.print("\t\t" + redondear(vel[2]));
            
            double aux_norma = redondear(p.velocidad.norma( ));
            double aux_vz = redondear(vel[2]);
            
            double dif = Math.abs(aux_norma) - Math.abs(aux_vz);
            dif = Math.abs(dif);
            dif = redondear(dif);
            
            System.out.print("\t" + aux_norma);
            System.out.println("\t"+ dif );
        
            t += interv;
        } 
    
        System.out.println( );
    }    

}