Coordinates/CoordinateSharp/Celestial.SolarEclipseCalc.cs

972 lines
36 KiB
C#
Raw Normal View History

2019-06-28 11:14:53 +02:00
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CoordinateSharp
{
//CURRENT ALTITUDE IS SET CONSTANT AT 100M. POSSIBLY NEED TO ADJUST TO ALLOW USER PASS.
//Altitude adjustments appear to have minimal effect on eclipse timing. These were mainly used
//to signify eclipses that had already started during rise and set times on the NASA calculator
//SOME TIMES AND ALTS WERE RETURNED WITH COLOR AND STYLING. DETERMINE WHY AND ADJUST VALUE AS REQUIRED. SEARCH "WAS ITALIC".
//ELLIPSOID ADJUSTMENT
//6378140.0 Ellipsoid is used in the NASA Calculator
//WGS84 Ellipsoid is 6378137.0. Adjustments to the ellipsoid appear to effect eclipse seconds in fractions.
//This can be modified if need to allow users to pass custom number with the Coordinate SetDatum() functions.
//CURRENT RANGE 1601-2600.
internal class SolarEclipseCalc
{
public static List<List<string>> CalculateSolarEclipse(DateTime d, double latRad, double longRad)
{
return Calculate(d, latRad, longRad, null);
}
public static List<SolarEclipseDetails> CalculateSolarEclipse(DateTime d, double latRad, double longRad, double[] events)
{
List<List<string>> evs = Calculate(d, latRad, longRad, events);
List<SolarEclipseDetails> deetsList = new List<SolarEclipseDetails>();
foreach(List<string> ls in evs)
{
SolarEclipseDetails deets = new SolarEclipseDetails(ls);
deetsList.Add(deets);
}
return deetsList;
}
public static List<List<string>> CalculateSolarEclipse(DateTime d, Coordinate coord)
{
return Calculate(d, coord.Latitude.ToRadians(), coord.Longitude.ToRadians(), null);
}
private static List<List<string>> Calculate(DateTime d, double latRad, double longRad, double[] ev)
{
//Declare storage arrays
double[] obsvconst = new double[7];
double[] mid = new double[41];//Check index to see if array needs to be this size
double[] c1 = new double[41];
double[] c2 = new double[41];
double[] c3 = new double[41];
double[] c4 = new double[41];
List<List<string>> events = new List<List<string>>();
double[] el;
if (ev == null)
{
el = Eclipse.SolarData.SolarDateData(d);//Get 100 year solar data;
}
else
{
el = ev;
}
events = new List<List<string>>();
ReadData(latRad, longRad, obsvconst);
for (int i = 0; i < el.Length; i += 28)
{
obsvconst[6] = i;
GetAll(el, obsvconst, mid,c1,c2,c3,c4);
// Is there an event...
if (mid[39] > 0)
{
List<string> values = new List<string>();
values.Add(GetDate(el, mid, obsvconst));
if (mid[39] == 1)
{
values.Add("P");
}
else if (mid[39] == 2)
{
values.Add("A");
}
else
{
values.Add("T");
}
// Partial eclipse start
if (c1[40] == 4)
{
values.Add("-");
values.Add(" ");
}
else
{
// Partial eclipse start time
values.Add(GetTime(el, c1, obsvconst));
values.Add(GetAlt(c1));
}
// Central eclipse time
if ((mid[39] > 1) && (c2[40] != 4))
{
values.Add(GetTime(el, c2, obsvconst));
}
else
{
values.Add("-");
}
//Mid Time
values.Add(GetTime(el, mid, obsvconst));
// Maximum eclipse alt
values.Add(GetAlt(mid));
// Maximum eclipse azi
values.Add(GetAzi(mid));
// Central eclipse ends
if ((mid[39] > 1) && (c3[40] != 4))
{
values.Add(GetTime(el, c3, obsvconst));
}
else
{
values.Add("-");
}
// Partial eclipse ends
if (c4[40] == 4)
{
values.Add("-");
values.Add(" ");
}
else
{
// Partial eclipse ends
values.Add(GetTime(el, c4, obsvconst));
// ... sun alt
values.Add(GetAlt(c4));
}
// Eclipse magnitude
values.Add(GetMagnitude(mid));
// Coverage
values.Add(GetCoverage(mid));
// Central duration
if (mid[39] > 1)
{
values.Add(GetDuration(mid,c2,c3));
}
else
{
values.Add("-");
}
events.Add(values);
}
}
return events;
}
//Populates the obsvcont array
private static void ReadData(double latRad, double longRad, double[] obsvconst)
{
// Get the latitude
obsvconst[0] = latRad;
//// Get the longitude
obsvconst[1] = -1 * longRad; //PASS REVERSE RADIAN.
// Get the altitude
obsvconst[2] = 100; //CHANGE TO ALLOW USER TO PASS.
// Get the time zone
obsvconst[3] = 0; //ALWAYS GMT
// Get the observer's geocentric position
double tmp = Math.Atan(0.99664719 * Math.Tan(obsvconst[0]));
obsvconst[4] = 0.99664719 * Math.Sin(tmp) + (obsvconst[2] / 6378140.0) * Math.Sin(obsvconst[0]);
obsvconst[5] = Math.Cos(tmp) + (obsvconst[2] / 6378140.0 * Math.Cos(obsvconst[0]));
}
// Populate the c1, c2, mid, c3 and c4 arrays
private static void GetAll(double[] elements, double[] obsvconst, double[] mid, double[] c1, double[] c2,double[] c3, double[] c4)
{
GetMid(elements, obsvconst, mid);
MidObservational(obsvconst, mid);
if (mid[37] > 0.0)
{
Getc1c4(elements, obsvconst, mid,c1,c2,c3,c4);
if ((mid[36] < mid[29]) || (mid[36] < -mid[29]))
{
Getc2c3(elements, obsvconst, mid,c2,c3);
if (mid[29] < 0.0)
{
mid[39] = 3; // Total eclipse
}
else
{
mid[39] = 2; // Annular eclipse
}
Observational(c1, obsvconst, mid);
Observational(c2, obsvconst, mid);
Observational(c3, obsvconst, mid);
Observational(c4, obsvconst, mid);
c2[36] = 999.9;
c3[36] = 999.9;
// Calculate how much of the eclipse is above the horizon
double pattern = 0;
if (c1[40] == 0) { pattern += 10000; }
if (c2[40] == 0) { pattern += 1000; }
if (mid[40] == 0) { pattern += 100; }
if (c3[40] == 0) { pattern += 10; }
if (c4[40] == 0) { pattern += 1; }
// Now, time to make sure that all my Observational[39] and Observational[40] are OK
if (pattern == 11110)
{
GetSunset(elements, c4, obsvconst);
Observational(c4, obsvconst, mid);
c4[40] = 3;
}
else if (pattern == 11100)
{
GetSunset(elements, c3, obsvconst);
Observational(c3, obsvconst, mid);
c3[40] = 3;
CopyCircumstances(c3, c4);
}
else if (pattern == 11000)
{
c3[40] = 4;
GetSunset(elements, mid, obsvconst);
MidObservational(obsvconst, mid);
mid[40] = 3;
CopyCircumstances(mid, c4);
}
else if (pattern == 10000)
{
mid[39] = 1;
GetSunset(elements, mid, obsvconst);
MidObservational(obsvconst, mid);
mid[40] = 3;
CopyCircumstances(mid, c4);
}
else if (pattern == 1111)
{
GetSunrise(elements, c1, obsvconst);
Observational(c1, obsvconst, mid);
c1[40] = 2;
}
else if (pattern == 111)
{
GetSunrise(elements, c2, obsvconst);
Observational(c2, obsvconst, mid);
c2[40] = 2;
CopyCircumstances(c2, c1);
}
else if (pattern == 11)
{
c2[40] = 4;
GetSunrise(elements, mid, obsvconst);
MidObservational(obsvconst, mid);
mid[40] = 2;
CopyCircumstances(mid, c1);
}
else if (pattern == 1)
{
mid[39] = 1;
GetSunrise(elements, mid, obsvconst);
MidObservational(obsvconst, mid);
mid[40] = 2;
CopyCircumstances(mid, c1);
}
else if (pattern == 0)
{
mid[39] = 0;
}
// There are other patterns, but those are the only ones we're covering!
}
else
{
mid[39] = 1; // Partial eclipse
double pattern = 0;
Observational(c1, obsvconst, mid);
Observational(c4, obsvconst, mid);
if (c1[40] == 0) { pattern += 100; }
if (mid[40] == 0) { pattern += 10; }
if (c4[40] == 0) { pattern += 1; }
if (pattern == 110)
{
GetSunset(elements, c4, obsvconst);
Observational(c4, obsvconst, mid);
c4[40] = 3;
}
else if (pattern == 100)
{
GetSunset(elements, mid, obsvconst);
MidObservational(obsvconst, mid);
mid[40] = 3;
CopyCircumstances(mid, c4);
}
else if (pattern == 11)
{
GetSunrise(elements, c1, obsvconst);
Observational(c1, obsvconst, mid);
c1[40] = 2;
}
else if (pattern == 1)
{
GetSunrise(elements, mid, obsvconst);
MidObservational(obsvconst, mid);
mid[40] = 2;
CopyCircumstances(mid, c1);
}
else if (pattern == 0)
{
mid[39] = 0;
}
// There are other patterns, but those are the only ones we're covering!
}
}
else
{
mid[39] = 0; // No eclipse
}
// Magnitude for total and annular eclipse is moon/sun ratio
if ((mid[39] == 2) || (mid[39] == 3))
{
mid[37] = mid[38];
}
}
// Calculate mid eclipse
private static void GetMid(double[] elements, double[] obsvconst, double[] mid)
{
double iter, tmp;
mid[0] = 0;
mid[1] = 0.0;
iter = 0;
tmp = 1.0;
TimeLocDependent(elements, mid, obsvconst);
while (((tmp > 0.000001) || (tmp < -0.000001)) && (iter < 50))
{
tmp = (mid[24] * mid[26] + mid[25] * mid[27]) / mid[30];
mid[1] = mid[1] - tmp;
iter++;
TimeLocDependent(elements, mid, obsvconst);
}
}
// Populate the circumstances array with the time and location dependent circumstances
private static double[] TimeLocDependent(double[] elements, double[] circumstances, double[] obsvconst)
{
double index, type;
TimeDependent(elements, circumstances, obsvconst);
index = obsvconst[6];
// Calculate h, sin h, cos h
circumstances[16] = circumstances[7] - obsvconst[1] - (elements[(int)index + 5] / 13713.44);
circumstances[17] = Math.Sin(circumstances[16]);
circumstances[18] = Math.Cos(circumstances[16]);
// Calculate xi
circumstances[19] = obsvconst[5] * circumstances[17];
// Calculate eta
circumstances[20] = obsvconst[4] * circumstances[6] - obsvconst[5] * circumstances[18] * circumstances[5];
// Calculate zeta
circumstances[21] = obsvconst[4] * circumstances[5] + obsvconst[5] * circumstances[18] * circumstances[6];
// Calculate dxi
circumstances[22] = circumstances[13] * obsvconst[5] * circumstances[18];
// Calculate deta
circumstances[23] = circumstances[13] * circumstances[19] * circumstances[5] - circumstances[21] * circumstances[12];
// Calculate u
circumstances[24] = circumstances[2] - circumstances[19];
// Calculate v
circumstances[25] = circumstances[3] - circumstances[20];
// Calculate a
circumstances[26] = circumstances[10] - circumstances[22];
// Calculate b
circumstances[27] = circumstances[11] - circumstances[23];
// Calculate l1'
type = circumstances[0];
if ((type == -2) || (type == 0) || (type == 2))
{
circumstances[28] = circumstances[8] - circumstances[21] * elements[26 + (int)index];
}
// Calculate l2'
if ((type == -1) || (type == 0) || (type == 1))
{
circumstances[29] = circumstances[9] - circumstances[21] * elements[27 + (int)index];
}
// Calculate n^2
circumstances[30] = circumstances[26] * circumstances[26] + circumstances[27] * circumstances[27];
return circumstances;
}
// Populate the circumstances array with the time-only dependent circumstances (x, y, d, m, ...)
private static double[] TimeDependent(double[] elements, double[] circumstances, double[] obsvconst)
{
double type, t, ans;
t = circumstances[1];
int index = (int)obsvconst[6];
// Calculate x
ans = elements[9 + index] * t + elements[8 + index];
ans = ans * t + elements[7 + index];
ans = ans * t + elements[6 + index];
circumstances[2] = ans;
// Calculate dx
ans = 3.0 * elements[9 + index] * t + 2.0 * elements[8 + index];
ans = ans * t + elements[7 + index];
circumstances[10] = ans;
// Calculate y
ans = elements[13 + index] * t + elements[12 + index];
ans = ans * t + elements[11 + index];
ans = ans * t + elements[10 + index];
circumstances[3] = ans;
// Calculate dy
ans = 3.0 * elements[13 + index] * t + 2.0 * elements[12 + index];
ans = ans * t + elements[11 + index];
circumstances[11] = ans;
// Calculate d
ans = elements[16 + index] * t + elements[15 + index];
ans = ans * t + elements[14 + index];
ans = ans * Math.PI / 180.0;
circumstances[4] = ans;
// sin d and cos d
circumstances[5] = Math.Sin(ans);
circumstances[6] = Math.Cos(ans);
// Calculate dd
ans = 2.0 * elements[16 + index] * t + elements[15 + index];
ans = ans * Math.PI / 180.0;
circumstances[12] = ans;
// Calculate m
ans = elements[19 + index] * t + elements[18 + index];
ans = ans * t + elements[17 + index];
if (ans >= 360.0)
{
ans = ans - 360.0;
}
ans = ans * Math.PI / 180.0;
circumstances[7] = ans;
// Calculate dm
ans = 2.0 * elements[19 + index] * t + elements[18 + index];
ans = ans * Math.PI / 180.0;
circumstances[13] = ans;
// Calculate l1 and dl1
type = circumstances[0];
if ((type == -2) || (type == 0) || (type == 2))
{
ans = elements[22 + index] * t + elements[21 + index];
ans = ans * t + elements[20 + index];
circumstances[8] = ans;
circumstances[14] = 2.0 * elements[22 + index] * t + elements[21 + index];
}
// Calculate l2 and dl2
if ((type == -1) || (type == 0) || (type == 1))
{
ans = elements[25 + index] * t + elements[24 + index];
ans = ans * t + elements[23 + index];
circumstances[9] = ans;
circumstances[15] = 2.0 * elements[25 + index] * t + elements[24 + index];
}
return circumstances;
}
// Get the observational circumstances for mid eclipse
private static void MidObservational(double[] obsvconst, double[] mid)
{
Observational(mid, obsvconst, mid);
// Calculate m, magnitude and moon/sun
mid[36] = Math.Sqrt(mid[24] * mid[24] + mid[25] * mid[25]);
mid[37] = (mid[28] - mid[36]) / (mid[28] + mid[29]);
mid[38] = (mid[28] - mid[29]) / (mid[28] + mid[29]);
}
// Get the observational circumstances
private static void Observational(double[] circumstances, double[] obsvconst, double[] mid)
{
double contacttype, coslat, sinlat;
// We are looking at an "external" contact UNLESS this is a total eclipse AND we are looking at
// c2 or c3, in which case it is an INTERNAL contact! Note that if we are looking at mid eclipse,
// then we may not have determined the type of eclipse (mid[39]) just yet!
if (circumstances[0] == 0)
{
contacttype = 1.0;
}
else
{
if ((mid[39] == 3) && ((circumstances[0] == -1) || (circumstances[0] == 1)))
{
contacttype = -1.0;
}
else
{
contacttype = 1.0;
}
}
// Calculate p
circumstances[31] = Math.Atan2(contacttype * circumstances[24], contacttype * circumstances[25]);
// Calculate alt
sinlat = Math.Sin(obsvconst[0]);
coslat = Math.Cos(obsvconst[0]);
circumstances[32] = Math.Asin(circumstances[5] * sinlat + circumstances[6] * coslat * circumstances[18]);
// Calculate q
circumstances[33] = Math.Asin(coslat * circumstances[17] / Math.Cos(circumstances[32]));
if (circumstances[20] < 0.0)
{
circumstances[33] = Math.PI - circumstances[33];
}
// Calculate v
circumstances[34] = circumstances[31] - circumstances[33];
// Calculate azi
circumstances[35] = Math.Atan2(-1.0 * circumstances[17] * circumstances[6], circumstances[5] * coslat - circumstances[18] * sinlat * circumstances[6]);
// Calculate visibility
if (circumstances[32] > -0.00524)
{
circumstances[40] = 0;
}
else
{
circumstances[40] = 1;
}
}
// Get C1 and C4 data
// Entry conditions -
// 1. The mid array must be populated
// 2. The magnitude at mid eclipse must be > 0.0
private static void Getc1c4(double[] elements, double[] obsvconst, double[] mid, double[] c1, double[] c2, double[] c3, double[] c4)
{
double tmp, n;
n = Math.Sqrt(mid[30]);
tmp = mid[26] * mid[25] - mid[24] * mid[27];
tmp = tmp / n / mid[28];
tmp = Math.Sqrt(1.0 - tmp * tmp) * mid[28] / n;
c1[0] = -2;
c4[0] = 2;
c1[1] = mid[1] - tmp;
c4[1] = mid[1] + tmp;
c1c4iterate(elements, c1, obsvconst);
c1c4iterate(elements, c4, obsvconst);
}
// Iterate on C1 or C4
private static double[] c1c4iterate(double[] elements, double[] circumstances, double[] obsvconst)
{
double sign, iter, tmp, n;
TimeLocDependent(elements, circumstances, obsvconst);
if (circumstances[0] < 0)
{
sign = -1.0;
}
else
{
sign = 1.0;
}
tmp = 1.0;
iter = 0;
while (((tmp > 0.000001) || (tmp < -0.000001)) && (iter < 50))
{
n = Math.Sqrt(circumstances[30]);
tmp = circumstances[26] * circumstances[25] - circumstances[24] * circumstances[27];
tmp = tmp / n / circumstances[28];
tmp = sign * Math.Sqrt(1.0 - tmp * tmp) * circumstances[28] / n;
tmp = (circumstances[24] * circumstances[26] + circumstances[25] * circumstances[27]) / circumstances[30] - tmp;
circumstances[1] = circumstances[1] - tmp;
TimeLocDependent(elements, circumstances, obsvconst);
iter++;
}
return circumstances;
}
// Get C2 and C3 data
// Entry conditions -
// 1. The mid array must be populated
// 2. There must be either a total or annular eclipse at the location!
private static void Getc2c3(double[] elements, double[] obsvconst, double[] mid, double[] c2, double[] c3)
{
double tmp, n;
n = Math.Sqrt(mid[30]);
tmp = mid[26] * mid[25] - mid[24] * mid[27];
tmp = tmp / n / mid[29];
tmp = Math.Sqrt(1.0 - tmp * tmp) * mid[29] / n;
c2[0] = -1;
c3[0] = 1;
if (mid[29] < 0.0)
{
c2[1] = mid[1] + tmp;
c3[1] = mid[1] - tmp;
}
else
{
c2[1] = mid[1] - tmp;
c3[1] = mid[1] + tmp;
}
c2c3iterate(elements, c2, obsvconst, mid);
c2c3iterate(elements, c3, obsvconst, mid);
}
// Iterate on C2 or C3
private static double[] c2c3iterate(double[] elements, double[] circumstances, double[] obsvconst, double[] mid)
{
double sign, iter, tmp, n;
TimeLocDependent(elements, circumstances, obsvconst);
if (circumstances[0] < 0)
{
sign = -1.0;
}
else
{
sign = 1.0;
}
if (mid[29] < 0.0)
{
sign = -sign;
}
tmp = 1.0;
iter = 0;
while (((tmp > 0.000001) || (tmp < -0.000001)) && (iter < 50))
{
n = Math.Sqrt(circumstances[30]);
tmp = circumstances[26] * circumstances[25] - circumstances[24] * circumstances[27];
tmp = tmp / n / circumstances[29];
tmp = sign * Math.Sqrt(1.0 - tmp * tmp) * circumstances[29] / n;
tmp = (circumstances[24] * circumstances[26] + circumstances[25] * circumstances[27]) / circumstances[30] - tmp;
circumstances[1] = circumstances[1] - tmp;
TimeLocDependent(elements, circumstances, obsvconst);
iter++;
}
return circumstances;
}
// Get the date of an event
private static string GetDate(double[] elements, double[] circumstances, double[] obsvconst)
{
string[] month = new string[] { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
double t, jd, a, b, c, d, e, index;
string ans = "";
index = obsvconst[6];
// Calculate the JD for noon (TDT) the day before the day that contains T0
jd = Math.Floor(elements[(int)index] - (elements[1 + (int)index] / 24.0));
// Calculate the local time (ie the offset in hours since midnight TDT on the day containing T0).
t = circumstances[1] + elements[1 + (int)index] - obsvconst[3] - (elements[4 + (int)index] - 0.5) / 3600.0;
if (t < 0.0)
{
jd--;
}
if (t >= 24.0)
{
jd++;
}
if (jd >= 2299160.0)
{
a = Math.Floor((jd - 1867216.25) / 36524.25);
a = jd + 1 + a - Math.Floor(a / 4.0);
}
else
{
a = jd;
}
b = a + 1525.0;
c = Math.Floor((b - 122.1) / 365.25);
d = Math.Floor(365.25 * c);
e = Math.Floor((b - d) / 30.6001);
d = b - d - Math.Floor(30.6001 * e);
if (e < 13.5)
{
e = e - 1;
}
else
{
e = e - 13;
}
double year;
if (e > 2.5)
{
ans = c - 4716 + "-";
year = c - 4716;
}
else
{
ans = c - 4715 + "-";
year = c - 4715;
}
string m = month[(int)e - 1];
ans += m + "-";
if (d < 10)
{
ans = ans + "0";
}
ans = ans + d;
//Leap Year Integrity Check
if(m =="Feb" && d ==29 && !DateTime.IsLeapYear((int)year))
{
ans = year.ToString() + "-Mar-01";
}
return ans;
}
// Calculate the time of sunset
private static void GetSunset(double[] elements, double[] circumstances, double[] obsvconst)
{
GetSunriset(elements, circumstances, 1.0, obsvconst);
}
// Calculate the time of sunrise
private static void GetSunrise(double[] elements, double[] circumstances, double[] obsvconst)
{
GetSunriset(elements, circumstances, -1.0, obsvconst);
}
// Calculate the time of sunrise or sunset
private static void GetSunriset(double[] elements, double[] circumstances, double riset, double[] obsvconst)
{
double h0, diff, iter;
diff = 1.0;
iter = 0;
while ((diff > 0.00001) || (diff < -0.00001))
{
iter++;
if (iter == 4) { return; }
h0 = Math.Acos((Math.Sin(-0.00524) - Math.Sin(obsvconst[0]) * circumstances[5]) / Math.Cos(obsvconst[0]) / circumstances[6]);
diff = (riset * h0 - circumstances[16]) / circumstances[13];
while (diff >= 12.0) { diff -= 24.0; }
while (diff <= -12.0) { diff += 24.0; }
circumstances[1] += diff;
TimeLocDependent(elements, circumstances, obsvconst);
}
}
// Copy a set of circumstances
private static void CopyCircumstances(double[] circumstancesfrom, double[] circumstancesto)
{
for (int i = 1; i < 41; i++)
{
circumstancesto[i] = circumstancesfrom[i];
}
}
// Get the local time of an event
private static string GetTime(double[] elements, double[] circumstances, double[] obsvconst)
{
string ans = "";
int index = (int)obsvconst[6];
double t = circumstances[1] + elements[1 + index] - obsvconst[3] - (elements[4 + index] - 0.5) / 3600.0;
if (t < 0.0)
{
t = t + 24.0;
}
if (t >= 24.0)
{
t = t - 24.0;
}
if (t < 10.0)
{
ans = ans + "0";
}
ans = ans + Math.Floor(t) + ":";
t = (t * 60.0) - 60.0 * Math.Floor(t);
if (t < 10.0)
{
ans = ans + "0";
}
ans = ans + Math.Floor(t);
if (circumstances[40] <= 1)
{ // not sunrise or sunset
ans = ans + ":";
t = (t * 60.0) - 60.0 * Math.Floor(t);
if (t < 10.0)
{
ans = ans + "0";
}
ans = ans + Math.Floor(t);
}
if (circumstances[40] == 1)
{
//WAS ITALIC
return ans;
}
else if (circumstances[40] == 2)
{
//Rise (CHANGED FROM NASA CALC THE INDICATES (r) WITH STRING, INVESTIGATE REMOVAL)
return ans;
}
else if (circumstances[40] == 3)
{
//Set (CHANGED FROM NASA CALC THE INDICATES (s) WITH STRING, INVESTIGATE REMOVAL)
return ans;
}
else
{
return ans;
}
}
// Get the altitude
private static string GetAlt(double[] circumstances)
{
double t;
string ans = "";
if (circumstances[40] == 2)
{
return "0(r)";
}
if (circumstances[40] == 3)
{
return "0(s)";
}
if ((circumstances[32] < 0.0) && (circumstances[32] >= -0.00524))
{
// Crude correction for refraction (and for consistency's sake)
t = 0.0;
}
else
{
t = circumstances[32] * 180.0 / Math.PI;
}
if (t < 0.0)
{
ans = "-";
t = -t;
}
else
{
ans = "";
}
t = Math.Floor(t + 0.5);
if (t < 10.0)
{
ans = ans + "0";
}
ans = ans + t;
if (circumstances[40] == 1)
{
//WAS ITALIC
return ans;
}
else
{
return ans;
}
}
// Get the azimuth
private static string GetAzi(double[] circumstances)
{
string ans = "";
double t = circumstances[35] * 180.0 / Math.PI;
if (t < 0.0)
{
t = t + 360.0;
}
if (t >= 360.0)
{
t = t - 360.0;
}
t = Math.Floor(t + 0.5);
if (t < 100.0)
{
ans = ans + "0";
}
if (t < 10.0)
{
ans = ans + "0";
}
ans = ans + t;
if (circumstances[40] == 1)
{
//WAS ITALIC
return ans;
}
else
{
return ans;
}
}
// Get the magnitude
private static string GetMagnitude(double[] mid)
{
double a = Math.Floor(1000.0 * mid[37] + 0.5) / 1000.0;
string ans = a.ToString();
if (mid[40] == 1)
{
return ans;
}
if (mid[40] == 2)
{
ans = a.ToString() + "(r)";
}
if (mid[40] == 3)
{
ans = a.ToString() + "(s)";
}
return ans;
}
// Get the coverage
private static string GetCoverage(double[] mid)
{
double a=0, b, c;
string ans = "";
if (mid[37] <= 0.0)
{
ans = "0.0";
}
else if (mid[37] >= 1.0)
{
ans = "1.000";
}
else
{
if (mid[39] == 2)
{
c = mid[38] * mid[38];
}
else
{
c = Math.Acos((mid[28] * mid[28] + mid[29] * mid[29] - 2.0 * mid[36] * mid[36]) / (mid[28] * mid[28] - mid[29] * mid[29]));
b = Math.Acos((mid[28] * mid[29] + mid[36] * mid[36]) / mid[36] / (mid[28] + mid[29]));
a = Math.PI - b - c;
c = ((mid[38] * mid[38] * a + b) - mid[38] * Math.Sin(c)) / Math.PI;
}
a = Math.Floor(1000.0 * c + 0.5) / 1000.0;
ans = a.ToString();
}
if (mid[40] == 1)
{
//WAS ITALIC
return ans;
}
if (mid[40] == 2)
{
ans = a.ToString() + "(r)";
}
if (mid[40] == 3)
{
ans = a + "(s)";
}
return ans;
}
// Get the duration in mm:ss.s format
// Adapted from code written by Stephen McCann - 27/04/2001
private static string GetDuration(double[] mid, double[] c2, double[] c3)
{
double tmp;
string ans;
if (c3[40] == 4)
{
tmp = mid[1] - c2[1];
}
else if (c2[40] == 4)
{
tmp = c3[1] - mid[1];
}
else
{
tmp = c3[1] - c2[1];
}
if (tmp < 0.0)
{
tmp = tmp + 24.0;
}
else if (tmp >= 24.0)
{
tmp = tmp - 24.0;
}
tmp = (tmp * 60.0) - 60.0 * Math.Floor(tmp) + 0.05 / 60.0;
ans = Math.Floor(tmp) + "m";
tmp = (tmp * 60.0) - 60.0 * Math.Floor(tmp);
if (tmp < 10.0)
{
ans = ans + "0";
}
ans += Math.Floor(tmp) + "s";
return ans;
}
}
}