[SOLUCIONADO] Problema proyectil

[scuvi96]

Buenas, les explico:

Mi ejercicio es el siguiente:

<<<<<<Descripción: Comparar las órbitas de dos satélites, uno de ellos con
un cohete pequeño que lo acelera:
Parte A: Modificaciones a la clase Satelite
• Añadir un nuevo método similar a avanzaTiempo en el que a la
aceleración se le suma el efecto del cohete:
- vector en la dirección de vector de velocidad, cuyo módulo se pasa
como un nuevo parámetro (en m/s2)>>>>>>


La clase satelite es la siguiente, en esta está implementado el método avanzaTiempo:

public class Satelite
{
/**
* Constructor para objetos de la clase Satelite
*/
double posX;
double posY;
double vx;
double vy;
double G=6.674e-11;
double MT=5.98e24;

/**
* Métodos para valores iniciales del constructor
*/
public Satelite (double vxIni, double vyIni)
{
this.posX=0;
this.posY=15e6;
this.vx=vxIni;
this.vy=vyIni;
}

public double posX()
{
return this.posX;
}

public double posY()
{
return this.posY;
}

public void avanzaTiempo (double t)
{
double ax= ((G*MT)/(posX*posX+posY*posY))*((-posX)/(Math.sqrt(posX*posX+posY*posY)));
double ay= ((G*MT)/(posX*posX+posY*posY))*((-posY)/(Math.sqrt(posX*posX+posY*posY)));
posX= (posX+(vx*t)+(ax*(t*t)/2));
posY= (posY+(vy*t)+(ay*(t*t)/2));
vx= vx+ax*t;
vy= vy+ay*t;
}

public void avanzaTiempoCohete (double t)
{
double ax= ((G*MT)/(posX*posX+posY*posY))*((-posX)/(Math.sqrt(posX*posX+posY*posY)));
double ay= ((G*MT)/(posX*posX+posY*posY))*((-posY)/(Math.sqrt(posX*posX+posY*posY)));
posX= (posX+(vx*t)+(ax*(t*t)/2));
posY= (posY+(vy*t)+(ay*(t*t)/2));
vx= vx+(2*ax*t);
vy= vy+ay*t;
}
}

El simulador que nos dan tiene la siguiente documentacion

Class Simulador
java.lang.Object
Simulador



public class Simuladorextends java.lang.Object
Programa que simula el funcionamiento de un satelite artificial que orbita alrededor de la tierra


Version:
(8 marzo 2012)
Author:
(Michael)


Constructor Summary
Simulador() ***********
*
Method Summary
static*void
main(java.lang.String[]*args) **********Programa principal que hace la simulacion
*
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
*

Constructor Detail

Simulador
public Simulador()


Method Detail

main
public static void main(java.lang.String[]*args)
Programa principal que hace la simulacion


<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>> >>

Os he pasado esta clase Simulador porque la segunda parte del ejercicio es:

<<<<<<<<<Parte B: Modificaciones al main
• observar el código del método main y localizar los puntos en que se
crea el objeto Satelite, se avanza su tiempo y se obtienen sus
posiciones (posX,posY)
• modificar el código del main para añadir un segundo satélite
- el primer satélite tiene el número 1 como identificador
- usar el número 2 como identificador del segundo satélite; así se pintará
de otro color
- el satélite número 2 se acelera durante su órbita, usando el nuevo
método>>>>>>>>>>>>>>>>>>>>>>>>


<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>> >>

Yo he conseguido que me salgan dos satelites orbitando, el original que me piden en partes anteriores del ejercicio y otro que me he inventado, como habeis podido observar necesito que el segundo cumpla las caracteristicas que me imponen.

Muchas gracias de antemano!

[Xerelo]

¿Exactamente qué has hecho tú?

Yo sólo veo que el método avanzaTiempo y avanzaTiempoCohete son iguales, lo que no tiene sentido.

[scuvi96]

Claro el problema es que no sé como crear otro satélite llamado Cohete que tenga las mismas ecuaciones que el satelite original pero se mueva con una propulsion.

[scuvi96]

De todas formas, este es el codigo de la clase simulador:

/**
* Programa que simula el funcionamiento de un satelite artificial
* que orbita alrededor de la tierra
*
* @author (Michael)
* @version (8 marzo 2012)
*/
public class Simulador
{
// Espera un rato haciendo un calculo inutil
private static void esperaUnRato() {
try {
// espera 50 milisegundos
Thread.sleep(50);
} catch (InterruptedException e) {
// ignorar
}
}

/**
* Programa principal que hace la simulacion
*/
public static void main(String[] args) {
// Creamos el primer satelite con velocidad inicial=4000 m/s
// en direccion horizontal
Satelite sat1 = new Satelite(4000.0,0.0);
Satelite sat2 = new Satelite(5000.0,3.0);
// Creamos la ventana para dibujar
Espacio espacio=new Espacio();

// inciamos un bucle que se repite un millón de veces
int contador=0;
while (contador<1e6) {
// cada 50 veces pintamos el satelite
if (contador%50==0) {
espacio.pintaSatelite(sat1.posX(),sat1.posY(),1);
espacio.pintaSatelite(sat2.posX(),sat2.posY(),1);
esperaUnRato();
}
// avanzamos 1 segundo (simuladamente) y esperamos un rato
sat1.avanzaTiempo(1.0);
sat2.avanzaTiempo(1.0);
// cada 100000 veces borramos las trayectorias
if (contador%1e5==0) {
espacio.borra();
}
contador++;
}

}
}


<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>> >

Todo lo que está en negrita lo he puesto yo en mi intento fallido por crear el cohete

[scuvi96]

Resumiendo el problema; necesito saber que ecuación hay que poner en avanzaTiempoCohete para que el sat2 funcione como si tuviese un cohete implementado

[Xerelo]

¿Lo único que has hecho es instanciar un nuevo satélite?

Si el problema es que no entiendes el enunciado, tienes un profesor y unos compañeros que te podrán ayudar, ten en cuenta que seguramente en clase hayan dado una información más clara que el enunciado que has puesto.

¿Entiendes las ecuaciones del desplazamiento?

Son tres, aplicadas a los ejes x,y

La primera simplemente es la componente de la aceleración en cada eje.
a*sen(@)
a*cos(@)

La segunda es la de desplazamiento, la del colegio de toda la vida
x = x0 + v*t + (1/2)* a*t^2

La tercera la de la velocidad
v = vo +a*t


Si el problema es que no sabes como implementar en código, entonces lo que tienes que hacer es estudiar un poco, porque lo que hay que hacer no tiene ninguna dificultad, simplemente cambiar el módulo de la aceleración.

[scuvi96]

Sé cambiarlo, lo que no sé es lo que hay que poner en el nuevo, es decir, es un problema de fisica

[Xerelo]

Pues entonces ya tienes la solución.

En la dos primeras fórmulas está el cálculo de la aceleración.

ax = a*cos(@)
ay = a*sen(@)

¿Cuál es la aceleración de la gravedad? Aunque deberías saberla, sólo tienes que buscar la fórmula, usa internet.

http://es.wikipedia.org/wiki/Intensi...o_gravitatorio

(G*M)/R^2 ¿Hay algo que se le parece en esa fórmula? Pues ya tienes el módulo.

en el que a la
aceleración se le suma el efecto del cohete:
- vector en la dirección de vector de velocidad, cuyo módulo se pasa
como un nuevo parámetro (en m/s2)

El enunciado te lo dice, suma el módulo de la aceleración del cohete al módulo de la aceleración que ya tienes.

Ahora sólo te falta decidir el signo, depende de hacia dónde quieres que apunte el cohete, eso lo puedes hacer tú.

Si tampoco lo entiendes, échale un vistazo a esto

http://fisica1.fisica.edu.uy/2011/Tr...na2-jueves.pdf

Es física básica, de la que se da en el colegio.

[Xerelo]

La verdad es que tengo una duda, parece que el enunciado dice que el cohete debe empujar en la dirección de la velocidad, que no tiene por qué coincidir con el de la aceleración inicial.

Entonces no es lo que he dicho anteriormente, lo que tienes que hacer es calcular el ángulo de la velocidad para sacar los componentes x e y de la aceleración del cohete, y se los "sumas" a los ax y ay que ya tenías.

Pero como ya he dicho, mejor que preguntes a tu profesor.

lo que no sé es lo que hay que poner en el nuevo, es decir, es un problema de fisica

Esto es un foro de programación

[Kritik]

Empezando porque es un problema de física tenemos 2 cohetes con unas características comunes y otras distintas.

Yo haría una clase con un constructor con las características comunes entre los 2 tipos. Los 2 tienen una aceleración aunque el impulsado sea distinta, tiene una característica que es aceleración. Así pues, aceleración es común e iría en esta clase. La órbita tendrá una fórmula exactamente igual a los 2 cohetes, basada en velocidad, aceleración o lo que sea, y será común a las 2 aunque tenga un resultado distinto por tener distintos valores... igual seguirá teniendo una órbita.

Después haría una clase que herede de esta primera para el primer cohete, usando el contructor heredado con todas las características comunes y a ese mismo constructor le meto las características que hacen diferente al cohete sin propulsor. Si el "sin propulsor" no tiene ninguna nueva característica, entonces no crees esta clase, y en el main instancia directamente en la clase "padre".

Después haría otra clase que herede de la primera para el segundo cohete, el que usa propulsor y le pondría todas las características nuevas. Como el "suplemento_de_aceleracion".

Y en este constructor en el que tenemos "aceleración" y "suplemento_de_aceleracion" haremos los cálculos para calcular la nueva aceleración gracias al suplemento_de_aceleracion".

Así pues, si quieres crear un cohete normal utilizarás el constructor de la primera clase "hijo" o directamente de la clase "padre" (dependiendo de lo anterior explicado), y si quieres crear un cohete con suplemento de aceleración, pues usarás el otro constructor de la segunda clase "hijo".

Como tenemos métodos similares para los 2 cohetes como son "calculo_orbita" que se basan en las mismas características (aceleración, peso, etc) pues estos métodos van en la primera clase que creamos, la clase "padre"... y esos métodos pueden ser usados por las clases "hijo".

Con respecto a los cálculos de las órbitas y tal... eso ya son fórmulas físicas y deberías de acudir a una página dedicada a eso. Aunque si tu profesor de informática te ha puesto este problema... o te ha dado las fórmulas necesarias o te está obligando a que vayas en búsqueda de estas fórmulas de física... y seguramente encuentres en google páginas de física mega-bien explicadas.