//---------------------------------------------------------------------
//
//---------------------------------------------------------------------
public static double LambdaErr(double t,
CelestialBody arivBody,
CelestialBody destBody,
double phi)
{
Orbit orbit = new Orbit();
double destLambda = 0;
double transTime = get_transfer_orbit(t, arivBody, destBody, phi, ref orbit, ref destLambda);
OrbitPos pos = new OrbitPos();
EclipticPos epos = new EclipticPos();
destBody.get_position(t + transTime, ref pos);
destBody.get_ecliptic_coords(pos.theta, ref epos);
return get_phase(epos.lambda - destLambda);
}
//---------------------------------------------------------------------
// Transfer dV calculation
//---------------------------------------------------------------------
public static void get_depatrure_manuever(CelestialBody depBody,
CelestialBody craft,
double t1,
ref DepManuever manuever)
{
OrbitPos depPos = new OrbitPos();
depBody.get_position(t1, ref depPos);
// Calculation SOI departure velocity
Vector3D Vd = depBody.get_velocity(depPos.theta);
Vector3D Vc = craft.get_velocity(0);
Vector3D Vro = Vc - Vd;
double v_ro = Vro.lenght();
// Depatrure hyperbolic orbit calculation
Vector3D x1 = depBody.get_cartesian_pos(depPos.theta);
double u = 0;
get_transfer_orientation(x1, Vro, ref manuever.orbit.i, ref manuever.orbit.Omega, ref u);
if (manuever.orbit.i > 90.0)
{
manuever.orbit.i = 180.0 - manuever.orbit.i;
manuever.orbit.Omega += 180.0;
if (manuever.orbit.Omega > 360)
manuever.orbit.Omega -= 360;
}
// Eject dV calculation
BodyData depData = new BodyData();
depBody.get_data(ref depData);
double ro = depData.sphereOfInfluence;
double R = depData.radius;
double mu = depData.gravParameter;
double h = manuever.h;
double v0 = Math.Sqrt(2 * mu * (1 / (R + h) - 1 / ro) + v_ro * v_ro);
manuever.dv = v0 - Math.Sqrt(mu / (R + h));
// Time of hyperbolic departure calculation
double vk = Math.Sqrt(mu / (R + h));
manuever.orbit.e = (v0 * v0 / vk / vk - 1);
double p = (R + h) * (1 + manuever.orbit.e);
double cos_theta = (p / ro - 1) / manuever.orbit.e;
double theta = Math.Acos(cos_theta);
manuever.orbit.a = p / (manuever.orbit.e * manuever.orbit.e - 1);
double n = Math.Sqrt(mu / manuever.orbit.a) / manuever.orbit.a;
double thH2 = Math.Sqrt((manuever.orbit.e - 1) / (manuever.orbit.e + 1)) * Math.Tan(theta / 2);
double H = Math.Log((1 + thH2) / (1 - thH2));
double M = manuever.orbit.e * Math.Sinh(H) - H;
double dT = M / n;
manuever.orbit.omega = (Math.Acos(1/manuever.orbit.e) - Math.PI/2) / math.RAD;
// Low orbit wait time calculation
double waitTime = manuever.turns * 2 * Math.PI * (R + h) / vk;
manuever.ejectTime = t1 - dT;
manuever.startTime = t1 - dT - waitTime;
KCalendar.sec_to_date(manuever.ejectTime, ref manuever.ejectDate);
KCalendar.sec_to_date(manuever.startTime, ref manuever.startDate);
}
//---------------------------------------------------------------------
//
//---------------------------------------------------------------------
public static bool get_transfer_date(double t0,
double t1,
CelestialBody depBody,
CelestialBody arrivBody,
double psi,
ref Transfer trans)
{
double t = t0;
double dL0;
double dL1;
double eps = 1e-8;
double dt = 21600.0;
bool ready = false;
do
{
dL0 = LambdaErr(t, depBody, arrivBody, psi);
t += dt;
dL1 = LambdaErr(t, depBody, arrivBody, psi);
if ((dL0 * dL1 < 0) && (Math.Abs(dL1) < 10.0 * math.RAD))
ready = true;
else
ready = false;
} while ( (!ready) && (t <= t1) );
if (t > t1)
return false;
double ta = t - dt;
double tb = t;
double tc = 0;
do
{
tc = (ta + tb) / 2;
dL0 = LambdaErr(ta, depBody, arrivBody, psi);
dL1 = LambdaErr(tc, depBody, arrivBody, psi);
if (dL0 * dL1 >= 0)
ta = tc;
else
tb = tc;
} while (Math.Abs(dL1) >= eps);
trans.depTime = tc;
KCalendar.sec_to_date(tc, ref trans.depDate);
trans.transTime = get_transfer_orbit(tc, depBody, arrivBody, psi, ref trans.orbit, ref trans.destLambda);
trans.arrivTime = tc + trans.transTime;
KCalendar.sec_to_date(trans.arrivTime, ref trans.arrivDate);
return true;
}
//---------------------------------------------------------------------
// Get transfer orbit
//---------------------------------------------------------------------
public static double get_transfer_orbit(double t,
CelestialBody depBody,
CelestialBody arrivBody,
double phi,
ref Orbit orbit,
ref double destLambda)
{
// Is bodies has same reference body
if (depBody.get_ref_body() != arrivBody.get_ref_body())
return -1;
OrbitPos pos = new OrbitPos();
EclipticPos epos = new EclipticPos();
depBody.get_position(t, ref pos);
depBody.get_ecliptic_coords(pos.theta, ref epos);
destLambda = epos.lambda + Math.PI - phi;
destLambda = math.Trunc2PiN(destLambda);
double destTheta = get_dest_theta(arrivBody, destLambda);
Vector3D x1 = depBody.get_cartesian_pos(pos.theta);
Vector3D x2 = arrivBody.get_cartesian_pos(destTheta);
double u = 0;
get_transfer_orientation(x1, x2, ref orbit.i, ref orbit.Omega, ref u);
double r1 = x1.lenght();
double r2 = x2.lenght();
orbit.omega = u / math.RAD;
BodyData data = new BodyData();
arrivBody.get_data(ref data);
double transTime = 0;
double mu = depBody.get_refGravParameter();
double E = 0;
double theta = 0;
theta = x1.angle(x2);
orbit.e = (r2 - r1) / (r1 - r2 * Math.Cos(theta));
if ( (orbit.e > - 1) && (orbit.e < 1) )
{
orbit.a = r1 / (1 - orbit.e);
double n = Math.Sqrt(mu / orbit.a) / orbit.a;
double tgE2 = Math.Sqrt((1 - orbit.e) / (1 + orbit.e)) * Math.Tan(theta / 2);
E = 2 * Math.Atan(tgE2);
double M = E - orbit.e * Math.Sin(E);
transTime = M / n;
}
if (orbit.e == 1)
{
orbit.a = 2*r1;
transTime = r1*Math.Sqrt(2*r1/mu)*(Math.Tan(theta/2) + Math.Pow(Math.Tan(theta/2), 3)/3);
}
if (orbit.e > 1)
{
orbit.a = r1 / (orbit.e - 1);
double n = Math.Sqrt(mu / orbit.a) / orbit.a;
double thE2 = Math.Sqrt((orbit.e - 1) / (orbit.e + 1)) * Math.Tan(theta / 2);
double H = Math.Log((1 + thE2) / (1 - thE2));
double M = orbit.e * Math.Sinh(H) - H;
transTime = M / n;
}
return transTime;
}
//---------------------------------------------------------------------
//
//---------------------------------------------------------------------
public static bool get_launch_params(CelestialBody depBody,
ref DepManuever manuever)
{
BodyData depData = new BodyData();
depBody.get_data(ref depData);
double mu = depData.gravParameter;
double R = depData.radius;
double r0 = R + manuever.h;
double vk = Math.Sqrt(mu / r0);
double i = manuever.orbit.i * math.RAD;
double Omega = manuever.orbit.Omega * math.RAD;
if (i < Math.Abs(manuever.launchLat))
return false;
double sin_A = Math.Cos(i)/Math.Cos(manuever.launchLat);
double A = Math.Asin(sin_A);
double ny = -Math.Cos(A);
double nz = sin_A;
double D = ny * ny + nz * nz * Math.Pow(Math.Sin(manuever.launchLat), 2);
double sin_d = -(nz * Math.Cos(Omega) * Math.Sin(manuever.launchLat) + ny * Math.Sin(Omega)) * Math.Sin(i) / D;
double cos_d = (nz * Math.Sin(Omega) * Math.Sin(manuever.launchLat) - ny * Math.Cos(Omega)) * Math.Sin(i) / D;
double d = math.arg(sin_d, cos_d);
double rotAngle_ref = d - manuever.launchLon;
double omega = 2 * Math.PI / depData.rotationPeriod;
double rotAngle = depBody.get_rotation_angle(manuever.startTime)*math.RAD;
double dT = 0;
if (rotAngle >= rotAngle_ref)
{
dT = (rotAngle - rotAngle_ref) / omega;
}
else
{
dT = 21600 - (rotAngle_ref - rotAngle) / omega;
}
manuever.launchTime = manuever.startTime - dT;
KCalendar.sec_to_date(manuever.launchTime, ref manuever.launchDate);
// Debug
rotAngle = depBody.get_rotation_angle(manuever.launchTime)*math.RAD;
// Relative azimuth calculation
double vs = omega*R*Math.Cos(manuever.launchLat);
double sin_Ar = (vk * sin_A - vs) / Math.Sqrt(vk * vk + vs * vs - 2 * vk * vs * sin_A);
manuever.azimuth = Math.Asin(sin_Ar) / math.RAD;
return true;
}
//----------------------------------------------------------------------
// Get true anomaly from ecliptic position
// (code generated by Maple 18)
//----------------------------------------------------------------------
public static double get_dest_theta(CelestialBody body, double lambda)
{
BodyData data = new BodyData();
body.get_data(ref data);
double i = data.orbit.i * math.RAD;
double Omega = data.orbit.Omega * math.RAD;
double cos_u = sqrt(pow(cos(i), 0.2e1) * (0.2e1 * pow(cos(lambda), 0.2e1) * pow(cos(Omega), 0.2e1) -
0.2e1 * cos(Omega) * cos(lambda) * sin(lambda) * sin(Omega) -
pow(cos(lambda), 0.2e1) - pow(cos(Omega), 0.2e1) + 0.1e1) / (pow(cos(lambda), 0.4e1) * pow(cos(i), 0.2e1) +
0.2e1 * pow(cos(lambda), 0.2e1) * pow(cos(i), 0.2e1) * pow(cos(Omega), 0.2e1) +
pow(cos(i), 0.2e1) * pow(cos(Omega), 0.4e1) - pow(cos(lambda), 0.4e1) -
0.2e1 * pow(cos(lambda), 0.2e1) * pow(cos(i), 0.2e1) - 0.2e1 * cos(Omega) * cos(lambda) * sin(lambda) * sin(Omega) -
0.2e1 * pow(cos(i), 0.2e1) * pow(cos(Omega), 0.2e1) - pow(cos(Omega), 0.4e1) + pow(cos(lambda), 0.2e1) + pow(cos(i), 0.2e1) +
pow(cos(Omega), 0.2e1))) * (cos(lambda) * cos(Omega) + sin(lambda) * sin(Omega));
double sin_u = -sqrt(pow(cos(i), 0.2e1) * (0.2e1 * pow(cos(lambda), 0.2e1) * pow(cos(Omega), 0.2e1) -
0.2e1 * cos(Omega) * cos(lambda) * sin(lambda) * sin(Omega) - pow(cos(lambda), 0.2e1) -
pow(cos(Omega), 0.2e1) + 0.1e1) / (pow(cos(lambda), 0.4e1) * pow(cos(i), 0.2e1) +
0.2e1 * pow(cos(lambda), 0.2e1) * pow(cos(i), 0.2e1) * pow(cos(Omega), 0.2e1) +
pow(cos(i), 0.2e1) * pow(cos(Omega), 0.4e1) - pow(cos(lambda), 0.4e1) -
0.2e1 * pow(cos(lambda), 0.2e1) * pow(cos(i), 0.2e1) - 0.2e1 * cos(Omega) * cos(lambda) * sin(lambda) * sin(Omega) -
0.2e1 * pow(cos(i), 0.2e1) * pow(cos(Omega), 0.2e1) - pow(cos(Omega), 0.4e1) +
pow(cos(lambda), 0.2e1) + pow(cos(i), 0.2e1) +
pow(cos(Omega), 0.2e1))) * (cos(lambda) * sin(Omega) - cos(Omega) * sin(lambda)) / cos(i);
double u = math.arg(sin_u, cos_u);
return u - data.orbit.omega*math.RAD;
}
//---------------------------------------------------------------
//
//---------------------------------------------------------------
private void ReadSystemConfig(string cfg)
{
XmlDocument doc = new XmlDocument();
doc.Load(cfg);
var nodes = doc.GetElementsByTagName("Body");
foreach (XmlNode node in nodes)
{
// Body data structure
BodyData data = new BodyData();
// Read all "Body" nodes
foreach (XmlNode subnode in node.ChildNodes)
{
// Read body parameters
if (subnode.Name == "name")
{
data.name = subnode.InnerText;
}
if (subnode.Name == "id")
{
data.id = int.Parse(subnode.InnerText);
}
if (subnode.Name == "RefBody")
{
data.refBody = subnode.InnerText;
}
if (subnode.Name == "mass")
{
data.mass = double.Parse(subnode.InnerText, CultureInfo.InvariantCulture);
}
if (subnode.Name == "radius")
{
data.radius = double.Parse(subnode.InnerText, CultureInfo.InvariantCulture);
}
if (subnode.Name == "gravParameter")
{
data.gravParameter = double.Parse(subnode.InnerText, CultureInfo.InvariantCulture);
}
if (subnode.Name == "rotationPeriod")
{
data.rotationPeriod = double.Parse(subnode.InnerText, CultureInfo.InvariantCulture);
}
if (subnode.Name == "sphereOfInfluence")
{
if (subnode.InnerText != "Infinity")
data.sphereOfInfluence = double.Parse(subnode.InnerText, CultureInfo.InvariantCulture);
else
data.sphereOfInfluence = 1e50;
}
if (subnode.Name == "initialRotation")
{
data.initialRotation = double.Parse(subnode.InnerText, CultureInfo.InvariantCulture);
}
if (subnode.Name == "Orbit")
{
data.orbit = new Orbit();
// Read body orbit parameters
foreach (XmlNode orb_param in subnode.ChildNodes)
{
if (orb_param.Name == "semiMajorAxis")
{
data.orbit.a = double.Parse(orb_param.InnerText, CultureInfo.InvariantCulture);
}
if (orb_param.Name == "eccentricity")
{
data.orbit.e = double.Parse(orb_param.InnerText, CultureInfo.InvariantCulture);
}
if (orb_param.Name == "epoch")
{
data.orbit.t0 = double.Parse(orb_param.InnerText, CultureInfo.InvariantCulture);
}
if (orb_param.Name == "meanAnomalyAtEpoch")
{
data.orbit.M0 = double.Parse(orb_param.InnerText, CultureInfo.InvariantCulture);
}
if (orb_param.Name == "period")
{
data.orbit.period = double.Parse(orb_param.InnerText, CultureInfo.InvariantCulture);
}
if (orb_param.Name == "argPe")
{
data.orbit.omega = double.Parse(orb_param.InnerText, CultureInfo.InvariantCulture);
}
if (orb_param.Name == "LAN")
{
data.orbit.Omega = double.Parse(orb_param.InnerText, CultureInfo.InvariantCulture);
}
if (orb_param.Name == "inclination")
{
data.orbit.i = double.Parse(orb_param.InnerText, CultureInfo.InvariantCulture);
}
}
}
}
CelestialBody Body = new CelestialBody();
Body.set_data(ref data);
Bodies.Add(Body);
}
// Init reference IDs and radiuses
for (int i = 0; i < Bodies.Count; i++)
{
string refBody = Bodies[i].get_ref_body();
int refId = get_body_index(refBody);
if (refId != -1)
{
Bodies[i].set_refId(refId);
Bodies[i].set_refRadius(Bodies[refId].get_radius());
Bodies[i].set_refGravParameter(Bodies[refId].get_gravParameter());
}
}
}
//---------------------------------------------------------------------
//
//---------------------------------------------------------------------
void DrawTransOrbit(Panel panel, Transfer trans,
CelestialBody arivBody,
CelestialBody destBody,
CelestialBody craft)
{
Graphics graph = panel.CreateGraphics();
graph.Clear(Color.Black);
Pen pen = new Pen(Color.LightGray, 2.0F);
int width = panel.Width;
int height = panel.Height;
float x0 = width / 2;
float y0 = height / 2;
float x = 0;
float y = 0;
float x1 = 0;
float y1 = 0;
float x2 = 0;
float y2 = 0;
double scale = 0;
int Delta = 25;
BodyData ariv_data = new BodyData();
BodyData dest_data = new BodyData();
arivBody.get_data(ref ariv_data);
destBody.get_data(ref dest_data);
double ariv_ra = ariv_data.orbit.a / (1 - ariv_data.orbit.e);
double dest_ra = dest_data.orbit.a / (1 - dest_data.orbit.e);
double r_max = 0;
if (ariv_ra > dest_ra)
r_max = ariv_ra;
else
r_max = dest_ra;
if (width > height)
{
scale = (height / 2 - Delta) / r_max;
}
else
{
scale = (width / 2 - Delta) / r_max;
}
// Arrive Body orbit
Vector3D pos;
OrbitPos orbit_pos = new OrbitPos();
double V0 = 0;
double V = V0;
double V1 = 360.0;
double dV = 5.0;
while (V <= V1)
{
pos = arivBody.get_cartesian_pos(V * RAD);
x1 = x0 + Convert.ToSingle(scale * pos.x);
y1 = y0 - Convert.ToSingle(scale * pos.y);
V += dV;
pos = arivBody.get_cartesian_pos(V * RAD);
x2 = x0 + Convert.ToSingle(scale * pos.x);
y2 = y0 - Convert.ToSingle(scale * pos.y);
if (pos.z >= 0)
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
else
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
graph.DrawLine(pen, x1, y1, x2, y2);
}
// Departure Body orbit
V0 = 0;
V = V0;
V1 = 360.0;
dV = 5.0;
while (V <= V1)
{
pos = destBody.get_cartesian_pos(V * RAD);
x1 = x0 + Convert.ToSingle(scale * pos.x);
y1 = y0 - Convert.ToSingle(scale * pos.y);
V += dV;
pos = destBody.get_cartesian_pos(V * RAD);
x2 = x0 + Convert.ToSingle(scale * pos.x);
y2 = y0 - Convert.ToSingle(scale * pos.y);
if (pos.z >= 0)
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
else
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
graph.DrawLine(pen, x1, y1, x2, y2);
}
V0 = 0;
V = V0;
V1 = Lambert.get_dest_theta(craft, trans.destLambda) / RAD;
dV = 5.0;
pen.Color = Color.Red;
do
{
pos = craft.get_cartesian_pos(V * RAD);
x1 = x0 + Convert.ToSingle(scale * pos.x);
y1 = y0 - Convert.ToSingle(scale * pos.y);
V += dV;
pos = craft.get_cartesian_pos(V * RAD);
x2 = x0 + Convert.ToSingle(scale * pos.x);
y2 = y0 - Convert.ToSingle(scale * pos.y);
if (pos.z >= 0)
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
else
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
graph.DrawLine(pen, x1, y1, x2, y2);
} while (V <= V1);
// Destination body position
SolidBrush brush = new SolidBrush(Color.Blue);
// Draw Planets at departure date
float radius = 5.0F;
destBody.get_position(trans.arrivTime, ref orbit_pos);
pos = destBody.get_cartesian_pos(orbit_pos.theta);
x = x0 + Convert.ToSingle(scale * pos.x);
y = y0 - Convert.ToSingle(scale * pos.y);
float x5 = x;
float y5 = y;
graph.FillEllipse(brush, x - radius, y - radius, 2 * radius, 2 * radius);
arivBody.get_position(trans.arrivTime, ref orbit_pos);
pos = arivBody.get_cartesian_pos(orbit_pos.theta);
x = x0 + Convert.ToSingle(scale * pos.x);
y = y0 - Convert.ToSingle(scale * pos.y);
graph.FillEllipse(brush, x - radius, y - radius, 2 * radius, 2 * radius);
brush.Color = Color.Red;
// Draw Planets at arrival date
destBody.get_position(trans.depTime, ref orbit_pos);
pos = destBody.get_cartesian_pos(orbit_pos.theta);
x = x0 + Convert.ToSingle(scale * pos.x);
y = y0 - Convert.ToSingle(scale * pos.y);
graph.FillEllipse(brush, x - radius, y - radius, 2 * radius, 2 * radius);
arivBody.get_position(trans.depTime, ref orbit_pos);
pos = arivBody.get_cartesian_pos(orbit_pos.theta);
x = x0 + Convert.ToSingle(scale * pos.x);
y = y0 - Convert.ToSingle(scale * pos.y);
float x3 = x;
float y3 = y;
EclipticPos epos = new EclipticPos();
arivBody.get_ecliptic_coords(orbit_pos.theta, ref epos);
epos.lambda += Math.PI;
double opos_theta = Lambert.get_dest_theta(destBody, epos.lambda);
pos = destBody.get_cartesian_pos(opos_theta);
float x4 = x0 + Convert.ToSingle(scale * pos.x);
float y4 = y0 - Convert.ToSingle(scale * pos.y);
graph.FillEllipse(brush, x - radius, y - radius, 2 * radius, 2 * radius);
// Draw Psi angle
pen.Color = Color.LightGray;
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.DashDot;
pen.Width = 1.0F;
graph.DrawLine(pen, x3, y3, x4, y4);
graph.DrawLine(pen, x0, y0, x5, y5);
//
float sunRadius = 10.0F;
if (ariv_data.refBody == "Sun")
brush.Color = Color.Yellow;
else
brush.Color = Color.Blue;
graph.FillEllipse(brush, x0 - sunRadius, y0 - sunRadius, 2 * sunRadius, 2 * sunRadius);
}
//---------------------------------------------------------------------
//
//---------------------------------------------------------------------
private void buttonHomanSearch_Click(object sender, EventArgs e)
{
double t0 = KCalendar.date_to_sec(int.Parse(textBeginYear.Text.ToString()),
int.Parse(comboBeginDay.Text.ToString()),
int.Parse(comboBeginHour.Text.ToString()),
int.Parse(comboBeginMin.Text.ToString()),
int.Parse(comboBeginSec.Text.ToString()));
double t1 = KCalendar.date_to_sec(int.Parse(textEndYear.Text.ToString()),
int.Parse(comboEndDay.Text.ToString()),
int.Parse(comboEndHour.Text.ToString()),
int.Parse(comboEndMin.Text.ToString()),
int.Parse(comboEndSec.Text.ToString()));
int dep_idx = get_body_index(comboHomanArrivList.Text.ToString());
int arr_idx = get_body_index(comboHomanDepList.Text.ToString());
// Check same reference body!!!
if (Bodies[dep_idx].get_ref_body() != Bodies[arr_idx].get_ref_body())
{
labelNoTransfer.Text = "Bodies must have same reference body!\nPlease, change other bodies";
return;
}
Transfer trans = new Transfer();
double psi = Convert.ToDouble(textPsi.Text) * RAD;
bool ready = Lambert.get_transfer_date(t0, t1, Bodies[dep_idx], Bodies[arr_idx], psi, ref trans);
if (!ready)
{
panelHomanRes.Visible = false;
labelNoTransfer.Text = "Transfer is imposible in changed period";
return;
}
labelNoTransfer.Text = "";
panelHomanRes.Visible = true;
KDate deltaDate = new KDate();
KCalendar.DeltaDate(trans.arrivTime - trans.depTime, ref deltaDate);
labelArivDate.Text = trans.depDate.year.ToString() + "y " +
trans.depDate.day.ToString() + "d " +
trans.depDate.hour.ToString() + "h " +
trans.depDate.min.ToString() + "m " +
trans.depDate.sec.ToString() + "s";
labelDepDate.Text = trans.arrivDate.year.ToString() + "y " +
trans.arrivDate.day.ToString() + "d " +
trans.arrivDate.hour.ToString() + "h " +
trans.arrivDate.min.ToString() + "m " +
trans.arrivDate.sec.ToString() + "s";
labelTransTime.Text = deltaDate.year.ToString() + "y " +
deltaDate.day.ToString() + "d " +
deltaDate.hour.ToString() + "h " +
deltaDate.min.ToString() + "m " +
deltaDate.sec.ToString() + "s";
labelSmiMajorAxis.Text = Math.Round(trans.orbit.a, 0).ToString() + " m";
labelEccentricity.Text = Math.Round(trans.orbit.e, 4).ToString();
labelInclination.Text = Math.Round(trans.orbit.i, 4).ToString() + " deg";
labelLAN.Text = Math.Round(trans.orbit.Omega, 4).ToString() + " deg";
labelArgPe.Text = Math.Round(trans.orbit.omega, 4).ToString() + " deg";
CelestialBody craft = new CelestialBody();
BodyData craft_data = new BodyData();
craft_data.name = "Space craft";
craft_data.orbit = trans.orbit;
craft.set_data(ref craft_data);
craft.set_refGravParameter(Bodies[dep_idx].get_refGravParameter());
DepManuever manuever = new DepManuever();
manuever.h = double.Parse(textAltitude.Text)*1000.0;
manuever.turns = int.Parse(textWaitTurns.Text);
Lambert.get_depatrure_manuever(Bodies[dep_idx],
craft,
trans.depTime,
ref manuever);
labelDeltaV.Text = Math.Round(manuever.dv, 2).ToString();
labelInc.Text = Math.Round(manuever.orbit.i, 4).ToString();
labelStartLAN.Text = Math.Round(manuever.orbit.Omega, 4).ToString();
labelEjectDate.Text = manuever.ejectDate.year.ToString() + "y " +
manuever.ejectDate.day.ToString() + "d " +
manuever.ejectDate.hour.ToString() + "h " +
manuever.ejectDate.min.ToString() + "m " +
manuever.ejectDate.sec.ToString() + "s";
double latDeg = double.Parse(textLatDeg.Text);
double latMin = double.Parse(textLatMin.Text);
double latSec = double.Parse(textLatSec.Text);
double lonDeg = double.Parse(textLonDeg.Text);
double lonMin = double.Parse(textLonMin.Text);
double lonSec = double.Parse(textLonSec.Text);
manuever.launchLat = (latDeg + latMin / 60.0 + latSec / 3600.0) * RAD;
manuever.launchLon = (lonDeg + lonMin / 60.0 + lonSec / 3600.0) * RAD;
if (radioButtonSouth.Checked)
manuever.launchLat = -manuever.launchLat;
if (radioButtonWest.Checked)
manuever.launchLon = -manuever.launchLon;
bool flag = Lambert.get_launch_params(Bodies[dep_idx], ref manuever);
if (flag)
{
labelStartDate.Text = manuever.launchDate.year.ToString() + "y " +
manuever.launchDate.day.ToString() + "d " +
manuever.launchDate.hour.ToString() + "h " +
manuever.launchDate.min.ToString() + "m " +
manuever.launchDate.sec.ToString() + "s";
labelAzimuth.Text = Math.Round(manuever.azimuth, 2).ToString();
}
// Draw trajectory
DrawTransOrbit(panelTransOrbit, trans, Bodies[dep_idx], Bodies[arr_idx], craft);
}