He escrito un código Java para el cálculo de varios tipos de datos de aceleración y etc. Ahora estoy tratando de graficar esos datos para poder obtener datos específicos en una línea de tiempo. Los valores que he recibido a través de mi programa matemático son puramente precisos con varios medios diferentes de verificación de errores. No necesito ayuda para la programación de Java. Lo que necesito son técnicas gráficas precisas para poder obtener los datos apropiados.
fórmula de aceleración
El eje x en eso es la variable de tiempo. El eje y debería ser la distancia, pero obtengo números totalmente falsos. Sé que puedo estar equivocado en mi comprensión de cómo se graficaría.
double D = Double.parseDouble(txtDistance.getText());
double T = Double.parseDouble(txtTime.getText());
double IV = Double.parseDouble(txtIVelocity.getText());
double M = Double.parseDouble(txtMass.getText());
double hd = Distance(D);
double ht = Time(T);
//2.0*(xt/th-v_i)/th
//double A = (2 * (hd - ht * IV)) / (ht * ht);
double A = 2 * (hd/ht - IV)/ht;
double PG = (A / 9.8) * 100;
//IV + A * ht
//double V = hd / ht;
double V = IV + A * ht;
double PL = (V / 299792458) * 100;
double MPH = V * 2.236936;
double F = M * A;
double LBT = F * 0.224809;
DecimalFormat df = new DecimalFormat("####0.0000");
txtVelocity.setText(String.valueOf(df.format(V)));
txtPLight.setText(String.valueOf(df.format(PL)));
txtMph.setText(String.valueOf(df.format(MPH)));
txtAcceleration.setText(String.valueOf(df.format(A)));
txtPGForce.setText(String.valueOf(df.format(PG)));
txtThrust.setText(String.valueOf(df.format(F)));
txtLBThrust.setText(String.valueOf(df.format(LBT)));
Como puede ver, estoy ingresando la distancia, el tiempo, la velocidad inicial y la masa. Y a cambio, calcula y muestra la velocidad final, el porcentaje de velocidad de la luz, millas por hora, aceleración, porcentaje de fuerza G, confianza en newton y libras de empuje.
Data de muestra:
Distancia: 160934400 Km (poco más de una UA) Tiempo: 40 hrs Velocidad inicial: 3070 m/s (órbita terrestre geosíncrona) Masa: 54431 Kg
La nave comienza en órbita terrestre y acelera el 50% de la distancia y desacelera el 50% de la distancia. Esto se calcula con 72000 segundos y 80467200000 metros.
Ejemplo de respuesta:
Velocidad final: 1117600,0000 m/s Porcentaje de luz: 0,3728 % Millas por hora: 2499999,6736 mph (para la comprensión humana de la velocidad para el lector) Aceleración: 30,9592 m/s^2 Porcentaje de fuerza G: 315,9099 % Empuje: 315,9099 N Lbs Empuje: 378834,2788 Lbs (nuevamente para la comprensión humana)
Sé que estos números son tan precisos como pueden ser utilizando las ecuaciones de aceleración constante publicadas anteriormente. Sé que estos números son extremos, pero es una novela de ciencia ficción.
El propósito de todo esto es que estoy escribiendo una novela de ciencia ficción y tengo una historia y una línea de tiempo. Necesito varias velocidades, según el tiempo y la aceleración, etc. Tengo un programa adicional que tomará estos datos y los graficará para que pueda hacer clic en los puntos para obtener los datos apropiados que necesito en el momento dado de la historia.
¿Cuál es el medio apropiado de graficar eso para que pueda obtener números precisos que tengan sentido para mi historia cuando usted, lector potencial, lea el libro?
Aparte de números aún más precisos, necesito saber cómo modificar mis ecuaciones para tener en cuenta la interferencia gravitacional en la aceleración, etc.
Pasé la última semana, más de 80 horas trabajando en esto para que mi libro sea lo más preciso posible. Dicho esto, sería casi imposible para mí incluir todo mi trabajo sobre este tema. Cualquier ayuda que esté dispuesto a ofrecer para que pueda seguir adelante con esta novela sería muy apreciada.
Estoy más familiarizado con la creación de gráficos en Python que en el lenguaje que está utilizando. El siguiente fragmento de código produce el gráfico que está solicitando:
import numpy as np
import matplotlib.pyplot as plt
# sci fi velocity graph
D = 160934400000 # m
v_i = 3070 # m/s
total_time = 40*3600 # seconds: 40 hours
# to cover half the distance in half the time, we solve
# x(t) = x(0) + v_0*t + 0.5*a*t*t
# x(0) = 0
# x(t) = D/2
# t = total_time / 2 = th
th = total_time / 2
xt=D/2
a = 2.0*(xt/th-v_i)/th
print 'acceleration needed is %.2f m/s^2'%a
# this prints out 30.96 m/s^2 - encouraging
# calculate position during acceleration phase - every second:
tm = 20*3600 # time at mid point
x=[]
for t in range(0,tm+1):
x.append(v_i*t + 0.5 * a * t * t)
xm = x[-1] # position at mid point
for t in range(tm+1, 2*tm):
x.append((v_i + tm*a)*(t-tm) - 0.5 * a * (t - tm) * (t - tm) + xm)
time = np.arange(0,2*tm)/3600.0
plt.close('all')
plt.figure()
plt.plot(time, np.array(x)/1000)
plt.xlabel('time (hr)')
plt.ylabel('position (km)')
plt.show()
v_t = np.diff(x)
plt.figure()
plt.plot(np.array(x[:-1])/1000,v_t/1000)
plt.xlabel('position (km)')
plt.ylabel('velocity (km/s)')
plt.show()
plt.figure()
plt.plot(time[:-1], v_t/1000)
plt.xlabel('time (hr)')
plt.ylabel('velocity (km/s)')
plt.show()
Esto produce el siguiente gráfico:
También puede trazar la velocidad en función del tiempo:
O en función de la posición:
kyle kanos
rojoarenosoladrillo
texasman1979
texasman1979
texasman1979
texasman1979