def propagate(self, year, month=1, day=1, hour=0, minute=0, second=0.0):
"""Return a position and velocity vector for a given date and time."""
j = jday(year, month, day, hour, minute, second)
m = (j - self.jdsatepoch) * minutes_per_day
r, v = sgp4(self, m)
return r, v
def propagate(self, year, month=1, day=1, hour=0, minute=0, second=0.0):
"""Return a position and velocity vector for a given date and time."""
j = jday(year, month, day, hour, minute, second)
m = (j - self.jdsatepoch) * minutes_per_day
r, v = sgp4(self, m)
return r, v
def __make_jday_list(self,
start_epoch=datetime.datetime.today(),
propagate_range=10,
delta_t=1,
julian_date=False):
"""Make datetime and julian day list.
Args:
start_epoch (:obj:datetime): Epoch when SGP4 propagation start.
propagate_range (int): SGP4 propagation period in seconds.
telta_t (int): SGP4 propagation interval in seconds.
Returns:
tuple: datetime list and julian day list.
"""
if julian_date == True:
date_list = [
x for x in self.__drange(start_epoch, propagate_range, delta_t)
]
jdays = date_list
else:
# make datetime list
date_list = [
start_epoch + datetime.timedelta(seconds=x)
for x in range(0, propagate_range, delta_t)
]
# make julian day list using jday function in sgp4.ext
jdays = [
jday(j.year, j.month, j.day, j.hour, j.minute, j.second)
for j in date_list
]
return date_list, jdays
def calcTg(date):
jdut1 = jday(date.year, date.month, date.day, date.hour, date.minute,
date.second)
Tg = _gstime(jdut1)
return Tg
def VMS_Time2Julian(reportdate, format='%Y%m%d%H%M%S'):
tFormat = format #"%d-%b-%Y %H:%M:%S"
reportdate = str(reportdate)
try: #see if it is a list
for i in repodatdate:
a = time.strptime(i, tFormat)
aJul = (jday(a.tm_year, a.tm_mon, a.tm_mday, a.tm_hour, a.tm_min,
a.tm_sec))
try:
out.append(aJul)
except:
out = [aJul]
return out
except: #a single shot
a = time.strptime(reportdate, tFormat)
return jday(a.tm_year, a.tm_mon, a.tm_mday, a.tm_hour, a.tm_min,
a.tm_sec)
def time_calc_julianDateFromUtc(self):
#def jday(year, mon, day, hr, minute, sec):
self._julianDate = sgp4_ext.jday(
self._utcTime.year, self._utcTime.month, self._utcTime.day,
self._utcTime.hour, self._utcTime.minute,
self._utcTime.second + self._utcTime.microsecond * 1e-6)
# CALCULATING JULIAN CENTURIES SINCE EPOCH J2000
# julianische jahrhunderte ephemeridenzeit seit der epoche J2000
self._julianCentJ2000 = (self._julianDate - 2451545.0) / 36525.0
def init_date(self):
if self.epoch_yr < 57:
year = self.epoch_yr + 2000
else:
year = self.epoch_yr + 1900
mon, day, hr, minute, sec = days2mdhms(year, self.epoch_day)
sec_whole, sec_frac = divmod(sec, 1.0)
self.date = datetime(year, mon, day, hr, minute, int(sec_whole),
int(sec_frac * 1000000.0 // 1.0), timezone.utc)
self.timestamp = int(time.mktime(self.date.timetuple()))
self.jdate = jday(year, mon, day, hr, minute, sec)
def derived_values(self):
""" Calculate values which are determined from TLE parameters """
self.epoch_string = self.epoch_datetime.isoformat(
timespec='microseconds')
(year, month, day, hour, minute,
second) = self.epoch_datetime.timetuple()[:6]
microseconds = int(self.epoch_datetime.strftime('%f'))
sec_with_microseconds = second + microseconds / 1.0E6
self.jdsatepoch = jday(year, month, day, hour, minute,
sec_with_microseconds)
self.jdSGP4epoch = self.jdsatepoch - 2433281.5
self.inclination_radians = radians(self.inclination_degrees)
self.raan_radians = radians(self.raan_degrees)
self.arg_perigee_radians = radians(self.arg_perigee_degrees)
self.mean_anomaly_radians = radians(self.mean_anomaly_degrees)
self.mean_motion_radians_per_second = 2 * pi * self.mean_motion_orbits_per_day / 86400
xpdotp = 1440.0 / (2.0 * pi) # 229.1831180523293
self.mean_motion_radians_per_minute = self.mean_motion_orbits_per_day / xpdotp
if (self.designation and not self._id_launch_year):
try:
self._id_launch_year = int(self.designation[2:4])
if (self._id_launch_year >= 57):
self._id_launch_year = 1900 + self._id_launch_year
elif (self._id_launch_year < 57):
self._id_launch_year = 2000 + self._id_launch_year
except ValueError:
self._id_launch_year = None
if (self.designation and not self._id_launch_num):
try:
self._id_launch_num = int(self.designation[5:8])
except ValueError:
self._id_launch_num = None
if (self.designation and not self._id_launch_piece_letter):
self._id_launch_piece_letter = self.designation[8:].strip()
self.period = 2 * pi / (self.mean_motion_radians_per_second
) # In seconds
self.semi_major_axis = pow(TruSatellite._GEsqrt /
self.mean_motion_radians_per_second,
2 / 3) # in km
self.perigee = self.semi_major_axis * (
1 - self.eccentricity) - TruSatellite._XKMPER # in km
if (self.perigee < 0):
log.warning("{}: Perigee {:0f} intersects the Earth.".format(
self._tle_source_filename, self.perigee))
self.apogee = self.semi_major_axis * (
1 + self.eccentricity) - TruSatellite._XKMPER # in km
def render(self, t1, t2, odata_list):
if (len(odata_list) == 0) or (t2 <= t1):
return []
next_odata = odata_list[0]
next_time, next_jtime = next_odata.timestamp, next_odata.jdate
dt1 = datetime.fromtimestamp(t1, timezone.utc)
dt2 = datetime.fromtimestamp(t2, timezone.utc)
jt1 = jday(dt1.year, dt1.month, dt1.day,
dt1.hour, dt1.minute, dt1.second)
jt2 = jday(dt2.year, dt2.month, dt2.day,
dt2.hour, dt2.minute, dt2.second)
self.set_steps(next_odata.no)
self.line_list = []
if (next_time < t1) or (next_time > t2):
self.render_border(t1, t2, jt1, jt2, next_odata)
return self.line_list
self.render_border(t1, next_time, jt1, next_jtime, next_odata)
i = 1
imax = len(odata_list)
while i < imax:
prev_odata, prev_time, prev_jtime = next_odata, next_time, next_jtime
next_odata = odata_list[i]
next_time, next_jtime = next_odata.timestamp, next_odata.jdate
self.render_mid(prev_time, next_time, prev_jtime,
next_jtime, prev_odata, next_odata)
i += 1
self.render_border(next_time, t2, next_jtime, jt2, next_odata)
return self.line_list
def sgp4init(self, whichconst, opsmode, satnum, epoch, bstar,
ndot, nddot, ecco, argpo, inclo, mo, no_kozai, nodeo):
whichconst = gravity_constants[whichconst]
y, m, d, H, M, S = invjday(epoch + 2433281.5)
jan0epoch = jday(y, 1, 0, 0, 0, 0.0) - 2433281.5
self.epochyr = y % 1000
self.epochdays = epoch - jan0epoch
self.jdsatepoch, self.jdsatepochF = divmod(epoch, 1.0)
self.jdsatepoch += 2433281.5
sgp4init(whichconst, opsmode, satnum, epoch, bstar, ndot, nddot,
ecco, argpo, inclo, mo, no_kozai, nodeo, self)
def _getPositionX(self, date):
"""
experimental: uses sgp4 library
NOTE: returns TEME coordinates (true equator mean equinox)
:param datetime date:
:rtype: GCRSCoordinates
"""
from sgp4.earth_gravity import wgs72
from sgp4.io import twoline2rv
from sgp4.ext import jday
jdate = jday(date.year, date.month, date.day, date.hour, date.minute,
date.second)
tleCount = len(self.tles) // 2
lo = 0
hi = tleCount
while lo < hi: # equals bisect.bisect_left
mid = (lo + hi) // 2
tle = twoline2rv(self.tles[mid * 2], self.tles[mid * 2 + 1], wgs72)
if tle.jdsatepoch < jdate:
lo = mid + 1
else:
hi = mid
tleIdx = lo - 1 # equals find_lt (rightmost TLE with epoch less than given date)
tle = twoline2rv(self.tles[tleIdx * 2], self.tles[tleIdx * 2 + 1],
wgs72)
if tle.jdsatepoch > jdate:
raise Exception(
"The epoch of the earliest available TLE is AFTER the requested date. "
+ "Are you missing historic TLE data?")
if (jdate - tle.jdsatepoch > 10 * ephem.hour):
warnings.warn('closest TLE epoch is ' +
str((date - tle.jdsatepoch) * 24) +
'h away from photo time')
position, _ = tle.propagate(date.year, date.month, date.day, date.hour,
date.minute, date.second)
x, y, z = units.km.to(units.pc, position)
# FIXME this is wrong, conversion TEME-J2000 is missing
# -> need skyfield library for that, but too heavy currently
# see https://github.com/brandon-rhodes/python-skyfield/issues/31
return np.array([x, y, z])
def envicosmos(tle1,tle2):
whichconst = 'wgs72'
#whichconst = wgs72
f1=open(tle1+'.tle')
f2=open(tle2+'.tle')
out1=open('envi.sal','w+')
out2=open('cosmos.sal','w+')
archivos=[f1,f2]
var=0
for tlefile in archivos:
var = var + 1
tlelines = iter(tlefile.readlines())
for line1 in tlelines:
if not line1.startswith('1'):
continue
line2 = next(tlelines)
satrec = twoline2rv(line1, line2, whichconst) # es un objeto de clase (satelite)
mu = satrec.whichconst.mu
epocatle=satrec.jdsatepoch
print 'epoca del tle [jd] = ', epocatle
jdini=jday(2008,1,9,18,0,0.0)
tini=(jdini-epocatle)*1440.0
print(tini)
tintervalo=np.arange(0,7200,1)
for t1 in tintervalo:
t=tini+t1/60.0
r, v = sgp4(satrec, t)
tjd=epocatle+t/1440.0 # dia juliano correspondiente al t en min.
"""Impresion de salida"""
year, mon, day, hr, minute, sec = invjday(tjd)
fecha = str(year)+'/'+str(mon)+'/'+str(day)+' '+str(hr)+':'+\
str(minute)+':'+str(sec)+' '+str(tjd)+' '+str(r[0])+' '+\
str(r[1])+' '+str(r[2])+' '+str(v[0])+' '+\
str(v[1])+' '+str(v[2])+'\n'
if var == 1:
out1.write(fecha)
else:
out2.write(fecha)
# year2,mon2,day2,hr2,minu2,sec2=invjday(2454475.29201)
# print year2,mon2,day2,hr2,minu2,sec2
"""
def test_jday(self):
print("jday...")
jd = 2454115.05486 # Sunday 14 January 2007 at 13:18:59.9
# Reference Astropy as "answer"
t_astropy = Time(jd, format='jd')
jdF = jd-int(jd)
jd = int(jd)
jday_datetime = jday_to_datetime(jd, jdF)
self.assertRegex(jday_datetime.isoformat(sep=' ',timespec='milliseconds'),t_astropy.iso,msg="jday_to_datetime() failed")
(year, month, day, hour, minute, second) = invjday(jd)
jday_jd = jday(year, month, day, hour, minute, second)
self.assertEqual(jday_jd,jd,"jday() failed")
def _getPositionX(self, date):
"""
experimental: uses sgp4 library
NOTE: returns TEME coordinates (true equator mean equinox)
:param datetime date:
:rtype: GCRSCoordinates
"""
from sgp4.earth_gravity import wgs72
from sgp4.io import twoline2rv
from sgp4.ext import jday
jdate = jday(date.year, date.month, date.day, date.hour, date.minute, date.second)
tleCount = len(self.tles) // 2
lo = 0
hi = tleCount
while lo < hi: # equals bisect.bisect_left
mid = (lo+hi)//2
tle = twoline2rv(self.tles[mid*2], self.tles[mid*2 + 1], wgs72)
if tle.jdsatepoch < jdate:
lo = mid+1
else:
hi = mid
tleIdx = lo-1 # equals find_lt (rightmost TLE with epoch less than given date)
tle = twoline2rv(self.tles[tleIdx*2], self.tles[tleIdx*2 + 1], wgs72)
if tle.jdsatepoch > jdate:
raise Exception("The epoch of the earliest available TLE is AFTER the requested date. " +
"Are you missing historic TLE data?")
if (jdate - tle.jdsatepoch > 10*ephem.hour):
warnings.warn('closest TLE epoch is ' + str((date - tle.jdsatepoch)*24) + 'h away from photo time')
position, _ = tle.propagate(date.year, date.month, date.day, date.hour, date.minute, date.second)
x,y,z = units.km.to(units.pc, position)
# FIXME this is wrong, conversion TEME-J2000 is missing
# -> need skyfield library for that, but too heavy currently
# see https://github.com/brandon-rhodes/python-skyfield/issues/31
return np.array([x,y,z])
from sgp4.propagation import sgp4
from sgp4.ext import jday
### INPUTS
# TLE file
tlefile = 'tle_sample.txt'
linespertle = 3 # lines per object of the TLE file, either two or three
# define desired reference epoch UTC
year = 2020
month = 6
day = 10
hour = 1
minute = 3
second = 0.45
jd_epoch = jday(year, month, day, hour, minute, second) # julianian date
###
# setup for reading TLE file all at once
tles = open(tlefile, 'r')
tlelines = tles.readlines()
nolines = len(tlelines)
tles.close()
satrec = []
# generate satrec, here one for all, but can also do one at a time (satrec1)
startline = linespertle - 2
for i in range(startline, nolines, linespertle):
# create satellite object
satrec1 = twoline2rv(tlelines[i], tlelines[i + 1], wgs84)
def twoline2rv(longstr1, longstr2, whichconst, afspc_mode=False):
"""Return a Satellite imported from two lines of TLE data.
Provide the two TLE lines as strings `longstr1` and `longstr2`,
and select which standard set of gravitational constants you want
by providing `gravity_constants`:
`sgp4.earth_gravity.wgs72` - Standard WGS 72 model
`sgp4.earth_gravity.wgs84` - More recent WGS 84 model
`sgp4.earth_gravity.wgs72old` - Legacy support for old SGP4 behavior
Normally, computations are made using various recent improvements
to the algorithm. If you want to turn some of these off and go
back into "afspc" mode, then set `afspc_mode` to `True`.
"""
opsmode = 'a' if afspc_mode else 'i'
deg2rad = pi / 180.0; # 0.0174532925199433
xpdotp = 1440.0 / (2.0 *pi); # 229.1831180523293
tumin = whichconst.tumin
satrec = Satellite()
satrec.error = 0;
satrec.whichconst = whichconst # Python extension: remembers its consts
line = longstr1.rstrip()
try:
assert line.startswith('1 ')
satrec.satnum = int(line[2:7])
# classification = line[7] or 'U'
assert line[8] == ' '
# intldesg = line[9:17]
two_digit_year = int(line[18:20])
assert line[23] == '.'
satrec.epochdays = float(line[20:32])
assert line[32] == ' '
assert line[34] == '.'
satrec.ndot = float(line[33:43])
assert line[43] == ' '
satrec.nddot = float(line[44] + '.' + line[45:50])
nexp = int(line[50:52])
assert line[52] == ' '
satrec.bstar = float(line[53] + '.' + line[54:59])
ibexp = int(line[59:61])
assert line[61] == ' '
assert line[63] == ' '
# numb = int(line[62])
# elnum = int(line[64:68])
except (AssertionError, IndexError, ValueError):
raise ValueError(error_message.format(1, LINE1, line))
line = longstr2.rstrip()
try:
assert line.startswith('2 ')
satrec.satnum = int(line[2:7]) # TODO: check it matches line 1?
assert line[7] == ' '
assert line[11] == '.'
satrec.inclo = float(line[8:16])
assert line[16] == ' '
assert line[20] == '.'
satrec.nodeo = float(line[17:25])
assert line[25] == ' '
satrec.ecco = float('0.' + line[26:33].replace(' ', '0'))
assert line[33] == ' '
assert line[37] == '.'
satrec.argpo = float(line[34:42])
assert line[42] == ' '
assert line[46] == '.'
satrec.mo = float(line[43:51])
assert line[51] == ' '
satrec.no = float(line[52:63])
#revnum = line[63:68]
except (AssertionError, IndexError, ValueError):
raise ValueError(error_message.format(2, LINE2, line))
# ---- find no, ndot, nddot ----
satrec.no = satrec.no / xpdotp; # rad/min
satrec.nddot= satrec.nddot * pow(10.0, nexp);
satrec.bstar= satrec.bstar * pow(10.0, ibexp);
# ---- convert to sgp4 units ----
satrec.a = pow( satrec.no*tumin , (-2.0/3.0) );
satrec.ndot = satrec.ndot / (xpdotp*1440.0); # ? * minperday
satrec.nddot= satrec.nddot / (xpdotp*1440.0*1440);
# ---- find standard orbital elements ----
satrec.inclo = satrec.inclo * deg2rad;
satrec.nodeo = satrec.nodeo * deg2rad;
satrec.argpo = satrec.argpo * deg2rad;
satrec.mo = satrec.mo * deg2rad;
satrec.alta = satrec.a*(1.0 + satrec.ecco) - 1.0;
satrec.altp = satrec.a*(1.0 - satrec.ecco) - 1.0;
"""
// ----------------------------------------------------------------
// find sgp4epoch time of element set
// remember that sgp4 uses units of days from 0 jan 1950 (sgp4epoch)
// and minutes from the epoch (time)
// ----------------------------------------------------------------
// ---------------- temp fix for years from 1957-2056 -------------------
// --------- correct fix will occur when year is 4-digit in tle ---------
"""
if two_digit_year < 57:
year = two_digit_year + 2000;
else:
year = two_digit_year + 1900;
mon,day,hr,minute,sec = days2mdhms(year, satrec.epochdays);
sec_whole, sec_fraction = divmod(sec, 1.0)
satrec.epochyr = year
satrec.jdsatepoch = jday(year,mon,day,hr,minute,sec);
satrec.epoch = datetime(year, mon, day, hr, minute, int(sec_whole),
int(sec_fraction * 1000000.0 // 1.0))
# ---------------- initialize the orbit at sgp4epoch -------------------
sgp4init(whichconst, opsmode, satrec.satnum, satrec.jdsatepoch-2433281.5, satrec.bstar,
satrec.ecco, satrec.argpo, satrec.inclo, satrec.mo, satrec.no,
satrec.nodeo, satrec)
return satrec
def gstime_from_datetime(when_utc):
timelist = list(when_utc.timetuple()[:6])
timelist[5] = timelist[5] + when_utc.microsecond * 1e-6
return _gstime(jday(*timelist))
def __init__(self, line1, line2):
self._line1 = line1
self._line2 = line2
line = line1.rstrip()
# deg2rad = pi / 180.0; # 0.0174532925199433
# xpdotp = 1440.0 / (2.0 * pi); # 229.1831180523293
# tumin = wgs84.tumin
try:
assert line.startswith('1 ')
self._satnum = int(line[2:7])
assert line[8] == ' '
two_digit_year = int(line[18:20])
assert line[23] == '.'
self.epochdays = float(line[20:32])
assert line[32] == ' '
assert line[34] == '.'
#self.ndot = float(line[33:43])
assert line[43] == ' '
#self.nddot = float(line[44] + '.' + line[45:50])
#nexp = int(line[50:52])
assert line[52] == ' '
#self.bstar = float(line[53] + '.' + line[54:59])
#ibexp = int(line[59:61])
assert line[61] == ' '
assert line[63] == ' '
except (AssertionError, IndexError, ValueError):
raise ValueError(error_message.format(1, LINE1, line))
line = line2.rstrip()
try:
assert line.startswith('2 ')
self._satnum = int(line[2:7]) # TODO: check it matches line 1?
assert line[7] == ' '
assert line[11] == '.'
#self.inclo = float(line[8:16])
assert line[16] == ' '
assert line[20] == '.'
#self.nodeo = float(line[17:25])
assert line[25] == ' '
#self.ecco = float('0.' + line[26:33].replace(' ', '0'))
assert line[33] == ' '
assert line[37] == '.'
#self.argpo = float(line[34:42])
assert line[42] == ' '
assert line[46] == '.'
#self.mo = float(line[43:51])
assert line[51] == ' '
#self.no = float(line[52:63])
#revnum = line[63:68]
except (AssertionError, IndexError, ValueError):
raise ValueError(error_message.format(2, LINE2, line))
# ---- find no, ndot, nddot ----
#self.no = self.no / xpdotp; # rad/min
#self.nddot= self.nddot * pow(10.0, nexp);
#self.bstar= self.bstar * pow(10.0, ibexp);
# ---- convert to sgp4 units ----
#self.a = pow( self.no*tumin , (-2.0/3.0) );
#self.ndot = self.ndot / (xpdotp*1440.0); # ? * minperday
#self.nddot= self.nddot / (xpdotp*1440.0*1440);
# ---- find standard orbital elements ----
#self.inclo = self.inclo * deg2rad;
#self.nodeo = self.nodeo * deg2rad;
#self.argpo = self.argpo * deg2rad;
#self.mo = self.mo * deg2rad;
#self.alta = self.a*(1.0 + self.ecco) - 1.0;
#self.altp = self.a*(1.0 - self.ecco) - 1.0;
if two_digit_year < 57:
year = two_digit_year + 2000;
else:
year = two_digit_year + 1900;
mon,day,hr,minute,sec = days2mdhms(year, self.epochdays);
sec_whole, sec_fraction = divmod(sec, 1.0)
self.epochyr = year
self.jdsatepoch = jday(year,mon,day,hr,minute,sec);
self._epoch = datetime(year, mon, day, hr, minute, int(sec_whole),
int(sec_fraction * 1000000.0 // 1.0), tzinfo=timezone.utc)
def dt2julian(dtobj):
return jday(dtobj.year, dtobj.month, dtobj.day, dtobj.hour, dtobj.minute,
dtobj.second)
def twoline2rv(longstr1, longstr2, whichconst, afspc_mode=False):
"""Return a Satellite imported from two lines of TLE data.
Provide the two TLE lines as strings `longstr1` and `longstr2`,
and select which standard set of gravitational constants you want
by providing `gravity_constants`:
`sgp4.earth_gravity.wgs72` - Standard WGS 72 model
`sgp4.earth_gravity.wgs84` - More recent WGS 84 model
`sgp4.earth_gravity.wgs72old` - Legacy support for old SGP4 behavior
Normally, computations are made using various recent improvements
to the algorithm. If you want to turn some of these off and go
back into "afspc" mode, then set `afspc_mode` to `True`.
"""
opsmode = 'a' if afspc_mode else 'i'
deg2rad = pi / 180.0; # 0.0174532925199433
xpdotp = 1440.0 / (2.0 *pi); # 229.1831180523293
revnum = 0;
elnum = 0;
tumin = whichconst.tumin
satrec = Satellite()
satrec.error = 0;
satrec.whichconst = whichconst # Python extension: remembers its consts
# This is Python, so we convert the strings into mutable lists of
# characters before setting the C++ code loose on them.
longstr1 = [ c for c in longstr1 ]
longstr2 = [ c for c in longstr2 ]
# set the implied decimal points since doing a formated read
# fixes for bad input data values (missing, ...)
for j in range(10, 16):
if longstr1[j] == ' ':
longstr1[j] = '_';
if longstr1[44] != ' ':
longstr1[43] = longstr1[44];
longstr1[44] = '.';
if longstr1[7] == ' ':
longstr1[7] = 'U';
if longstr1[9] == ' ':
longstr1[9] = '.';
for j in range(45, 50):
if longstr1[j] == ' ':
longstr1[j] = '0';
if longstr1[51] == ' ':
longstr1[51] = '0';
if longstr1[53] != ' ':
longstr1[52] = longstr1[53];
longstr1[53] = '.';
longstr2[25] = '.';
for j in range(26, 33):
if longstr2[j] == ' ':
longstr2[j] = '0';
if longstr1[62] == ' ':
longstr1[62] = '0';
if longstr1[68] == ' ':
longstr1[68] = '0';
# Concatenate lists back into real strings.
longstr1 = ''.join(longstr1)
longstr2 = ''.join(longstr2)
(cardnumb,satrec.satnum,classification, intldesg, two_digit_year,
satrec.epochdays,satrec.ndot, satrec.nddot, nexp, satrec.bstar,
ibexp, numb, elnum) = \
sscanf(longstr1,"%2d %5ld %1c %10s %2d %12lf %11lf %7lf %2d %7lf %2d %2d %6ld ",
)
if longstr2[52] == ' ':
(cardnumb,satrec.satnum, satrec.inclo,
satrec.nodeo,satrec.ecco, satrec.argpo, satrec.mo, satrec.no,
revnum) = \
sscanf(longstr2,"%2d %5ld %9lf %9lf %8lf %9lf %9lf %10lf %6ld \n",
)
else:
(cardnumb,satrec.satnum, satrec.inclo,
satrec.nodeo,satrec.ecco, satrec.argpo, satrec.mo, satrec.no,
revnum) = \
sscanf(longstr2,"%2d %5ld %9lf %9lf %8lf %9lf %9lf %11lf %6ld \n",
)
# ---- find no, ndot, nddot ----
satrec.no = satrec.no / xpdotp; # rad/min
satrec.nddot= satrec.nddot * pow(10.0, nexp);
satrec.bstar= satrec.bstar * pow(10.0, ibexp);
# ---- convert to sgp4 units ----
satrec.a = pow( satrec.no*tumin , (-2.0/3.0) );
satrec.ndot = satrec.ndot / (xpdotp*1440.0); # ? * minperday
satrec.nddot= satrec.nddot / (xpdotp*1440.0*1440);
# ---- find standard orbital elements ----
satrec.inclo = satrec.inclo * deg2rad;
satrec.nodeo = satrec.nodeo * deg2rad;
satrec.argpo = satrec.argpo * deg2rad;
satrec.mo = satrec.mo * deg2rad;
satrec.alta = satrec.a*(1.0 + satrec.ecco) - 1.0;
satrec.altp = satrec.a*(1.0 - satrec.ecco) - 1.0;
"""
// ----------------------------------------------------------------
// find sgp4epoch time of element set
// remember that sgp4 uses units of days from 0 jan 1950 (sgp4epoch)
// and minutes from the epoch (time)
// ----------------------------------------------------------------
// ---------------- temp fix for years from 1957-2056 -------------------
// --------- correct fix will occur when year is 4-digit in tle ---------
"""
if two_digit_year < 57:
year = two_digit_year + 2000;
else:
year = two_digit_year + 1900;
mon,day,hr,minute,sec = days2mdhms(year, satrec.epochdays);
sec_whole, sec_fraction = divmod(sec, 1.0)
satrec.epochyr = year
satrec.jdsatepoch = jday(year,mon,day,hr,minute,sec);
satrec.epoch = datetime(year, mon, day, hr, minute, int(sec_whole),
int(sec_fraction * 1000000.0 // 1.0))
# ---------------- initialize the orbit at sgp4epoch -------------------
sgp4init( whichconst, opsmode, satrec.satnum, satrec.jdsatepoch-2433281.5, satrec.bstar,
satrec.ecco, satrec.argpo, satrec.inclo, satrec.mo, satrec.no,
satrec.nodeo, satrec);
return satrec
def propagate(self, year, month=1, day=1, hour=0, minute=0, second=0.0):
j = jday(year, month, day, hour, minute, second)
m = (j - self.jdsatepoch) * minutes_per_day
r, v = sgp4(self, m)
return r, v
def twoline2rv(longstr1, longstr2, whichconst, afspc_mode=False):
deg2rad = pi / 180.0; # 0.0174532925199433
xpdotp = 1440.0 / (2.0 *pi); # 229.1831180523293
tumin = whichconst.tumin
satrec = Satellite()
satrec.error = 0;
satrec.whichconst = whichconst # Python extension: remembers its consts
line = longstr1.rstrip()
# try/except is not well supported by Numba
if (len(line) >= 64 and
line.startswith('1 ') and
line[8] == ' ' and
line[23] == '.' and
line[32] == ' ' and
line[34] == '.' and
line[43] == ' ' and
line[52] == ' ' and
line[61] == ' ' and
line[63] == ' '):
_saved_satnum = satrec.satnum = int(line[2:7])
# classification = line[7] or 'U'
# intldesg = line[9:17]
two_digit_year = int(line[18:20])
satrec.epochdays = float(line[20:32])
satrec.ndot = float(line[33:43])
satrec.nddot = float(line[44] + '.' + line[45:50])
nexp = int(line[50:52])
satrec.bstar = float(line[53] + '.' + line[54:59])
ibexp = int(line[59:61])
# numb = int(line[62])
# elnum = int(line[64:68])
else:
raise ValueError(error_message.format(1, LINE1, line))
line = longstr2.rstrip()
if (len(line) >= 69 and
line.startswith('2 ') and
line[7] == ' ' and
line[11] == '.' and
line[16] == ' ' and
line[20] == '.' and
line[25] == ' ' and
line[33] == ' ' and
line[37] == '.' and
line[42] == ' ' and
line[46] == '.' and
line[51] == ' '):
satrec.satnum = int(line[2:7])
if _saved_satnum != satrec.satnum:
raise ValueError('Object numbers in lines 1 and 2 do not match')
satrec.inclo = float(line[8:16])
satrec.nodeo = float(line[17:25])
satrec.ecco = float('0.' + line[26:33].replace(' ', '0'))
satrec.argpo = float(line[34:42])
satrec.mo = float(line[43:51])
satrec.no = float(line[52:63])
#revnum = line[63:68]
#except (AssertionError, IndexError, ValueError):
else:
raise ValueError(error_message.format(2, LINE2, line))
# ---- find no, ndot, nddot ----
satrec.no = satrec.no / xpdotp; # rad/min
satrec.nddot= satrec.nddot * pow(10.0, nexp);
satrec.bstar= satrec.bstar * pow(10.0, ibexp);
# ---- convert to sgp4 units ----
satrec.a = pow( satrec.no*tumin , (-2.0/3.0) );
satrec.ndot = satrec.ndot / (xpdotp*1440.0); # ? * minperday
satrec.nddot= satrec.nddot / (xpdotp*1440.0*1440);
# ---- find standard orbital elements ----
satrec.inclo = satrec.inclo * deg2rad;
satrec.nodeo = satrec.nodeo * deg2rad;
satrec.argpo = satrec.argpo * deg2rad;
satrec.mo = satrec.mo * deg2rad;
satrec.alta = satrec.a*(1.0 + satrec.ecco) - 1.0;
satrec.altp = satrec.a*(1.0 - satrec.ecco) - 1.0;
if two_digit_year < 57:
year = two_digit_year + 2000;
else:
year = two_digit_year + 1900;
mon,day,hr,minute,sec = days2mdhms(year, satrec.epochdays);
sec_whole, sec_fraction = divmod(sec, 1.0)
satrec.epochyr = year
satrec.jdsatepoch = jday(year,mon,day,hr,minute,sec);
satrec.epoch = datetime(year, mon, day, hr, minute, int(sec_whole),
int(sec_fraction * 1000000.0 // 1.0))
# ---------------- initialize the orbit at sgp4epoch -------------------
sgp4init(whichconst, afspc_mode, satrec.satnum, satrec.jdsatepoch-2433281.5, satrec.bstar,
satrec.ecco, satrec.argpo, satrec.inclo, satrec.mo, satrec.no,
satrec.nodeo, satrec)
return satrec
def gstime_from_datetime(when_utc):
timetuple = timetuple_from_dt(when_utc)
return _gstime(jday(*timetuple))
def gstime_from_datetime(when_utc):
timetuple = when_utc.timetuple()[:6]
return _gstime(jday(*timetuple))
def twoline2rv(longstr1, longstr2, whichconst, afspc_mode=False):
"""Return a Satellite imported from two lines of TLE data.
Provide the two TLE lines as strings `longstr1` and `longstr2`,
and select which standard set of gravitational constants you want
by providing `gravity_constants`:
`sgp4.earth_gravity.wgs72` - Standard WGS 72 model
`sgp4.earth_gravity.wgs84` - More recent WGS 84 model
`sgp4.earth_gravity.wgs72old` - Legacy support for old SGP4 behavior
Normally, computations are made using various recent improvements
to the algorithm. If you want to turn some of these off and go
back into "afspc" mode, then set `afspc_mode` to `True`.
"""
deg2rad = pi / 180.0
# 0.0174532925199433
xpdotp = 1440.0 / (2.0 * pi)
# 229.1831180523293
tumin = whichconst.tumin
satrec = Satellite()
satrec.error = 0
satrec.whichconst = whichconst # Python extension: remembers its consts
line = longstr1.rstrip()
# try/except is not well supported by Numba
if (len(line) >= 64 and line.startswith('1 ') and line[8] == ' '
and line[23] == '.' and line[32] == ' ' and line[34] == '.'
and line[43] == ' ' and line[52] == ' ' and line[61] == ' '
and line[63] == ' '):
_saved_satnum = satrec.satnum = int(line[2:7])
# classification = line[7] or 'U'
# intldesg = line[9:17]
two_digit_year = int(line[18:20])
satrec.epochdays = float(line[20:32])
satrec.ndot = float(line[33:43])
satrec.nddot = float(line[44] + '.' + line[45:50])
nexp = int(line[50:52])
satrec.bstar = float(line[53] + '.' + line[54:59])
ibexp = int(line[59:61])
# numb = int(line[62])
# elnum = int(line[64:68])
else:
raise ValueError(error_message.format(1, LINE1, line))
line = longstr2.rstrip()
line_format_ok = False
if (len(line) >= 69 and line.startswith('2 ') and line[7] == ' '
and line[11] == '.' and line[16] == ' ' and line[20] == '.'
and line[25] == ' ' and line[33] == ' ' and line[37] == '.'
and line[42] == ' ' and line[46] == '.' and line[51] == ' '):
satrec.satnum = int(line[2:7])
if _saved_satnum != satrec.satnum:
raise ValueError('Object numbers in lines 1 and 2 do not match')
satrec.inclo = float(line[8:16])
satrec.nodeo = float(line[17:25])
satrec.ecco = float('0.' + line[26:33].replace(' ', '0'))
satrec.argpo = float(line[34:42])
satrec.mo = float(line[43:51])
satrec.no = float(line[52:63])
#revnum = line[63:68]
#except (AssertionError, IndexError, ValueError):
else:
raise ValueError(error_message.format(2, LINE2, line))
# ---- find no, ndot, nddot ----
satrec.no = satrec.no / xpdotp
# rad/min
satrec.nddot = satrec.nddot * pow(10.0, nexp)
satrec.bstar = satrec.bstar * pow(10.0, ibexp)
# ---- convert to sgp4 units ----
satrec.a = pow(satrec.no * tumin, (-2.0 / 3.0))
satrec.ndot = satrec.ndot / (xpdotp * 1440.0)
# ? * minperday
satrec.nddot = satrec.nddot / (xpdotp * 1440.0 * 1440)
# ---- find standard orbital elements ----
satrec.inclo = satrec.inclo * deg2rad
satrec.nodeo = satrec.nodeo * deg2rad
satrec.argpo = satrec.argpo * deg2rad
satrec.mo = satrec.mo * deg2rad
satrec.alta = satrec.a * (1.0 + satrec.ecco) - 1.0
satrec.altp = satrec.a * (1.0 - satrec.ecco) - 1.0
"""
// ----------------------------------------------------------------
// find sgp4epoch time of element set
// remember that sgp4 uses units of days from 0 jan 1950 (sgp4epoch)
// and minutes from the epoch (time)
// ----------------------------------------------------------------
// ---------------- temp fix for years from 1957-2056 -------------------
// --------- correct fix will occur when year is 4-digit in tle ---------
"""
if two_digit_year < 57:
year = two_digit_year + 2000
else:
year = two_digit_year + 1900
mon, day, hr, minute, sec = days2mdhms(year, satrec.epochdays)
sec_whole, sec_fraction = divmod(sec, 1.0)
satrec.epochyr = year
satrec.jdsatepoch = jday(year, mon, day, hr, minute, sec)
satrec.epoch = datetime(year, mon, day, hr, minute, int(sec_whole),
int(sec_fraction * 1000000.0 // 1.0))
# ---------------- initialize the orbit at sgp4epoch -------------------
sgp4init(whichconst, afspc_mode, satrec.satnum,
satrec.jdsatepoch - 2433281.5, satrec.bstar, satrec.ecco,
satrec.argpo, satrec.inclo, satrec.mo, satrec.no, satrec.nodeo,
satrec)
return satrec
def sat_construct(_epoch,
_ndot,
_nddot,
_bstar,
_inclo,
_nodeo,
_ecco,
_argpo,
_mo,
_no_kozai,
_satnum,
_sat=None,
_whichconst=wgs72,
_opsmode='i'):
#Construct the satellite
if _sat is None:
satrec = Satellite()
else:
satrec = _sat
satrec.satnum = _satnum
satrec.whichconst = _whichconst
satrec.opsmode = _opsmode
dt = julian.from_jd(_epoch, fmt='jd')
y = dt.year - 2000
yjd = jday(dt.year, 1, 1, 0, 0, 0)
satrec.epoch = dt
satrec.epochyr = y
satrec.epochdays = _epoch - yjd + 1
satrec.jdsatepoch = _epoch
satrec.ndot = _ndot
satrec.nddot = _nddot
_MAXB = .99999
if _bstar > _MAXB:
_bstar = _MAXB
if _bstar < -_MAXB:
_bstar = -_MAXB
satrec.bstar = _bstar
satrec.inclo = _inclo
satrec.nodeo = _nodeo
_MINE = .5e-7
if _ecco < _MINE:
_ecco = _MINE
_MAXE = 1. - _MINE
if _ecco > _MAXE:
_ecco = _MAXE
satrec.ecco = _ecco
satrec.argpo = _argpo
satrec.mo = _mo
if _no_kozai < 1e-7:
_no_kozai = 1e-7
satrec.no_kozai = _no_kozai
satrec.error = 0
satrec.error_message = None
# ---------------- initialize the orbit at sgp4epoch -------------------
sgp4init(satrec.whichconst, satrec.opsmode, satrec.satnum,
satrec.jdsatepoch - 2433281.5, satrec.bstar, satrec.ndot,
satrec.nddot, satrec.ecco, satrec.argpo, satrec.inclo, satrec.mo,
satrec.no_kozai, satrec.nodeo, satrec)
return satrec
def date2JD(self, startDate):
date=startDate.split('-')
return jday(int(date[0]),
int(date[1]),
int(date[2]),0,0,0)
def twoline2rv(longstr1, longstr2, whichconst, opsmode='i', satrec=None):
"""Return a Satellite imported from two lines of TLE data.
Provide the two TLE lines as strings `longstr1` and `longstr2`,
and select which standard set of gravitational constants you want
by providing `gravity_constants`:
`sgp4.earth_gravity.wgs72` - Standard WGS 72 model
`sgp4.earth_gravity.wgs84` - More recent WGS 84 model
`sgp4.earth_gravity.wgs72old` - Legacy support for old SGP4 behavior
Normally, computations are made using various recent improvements
to the algorithm. If you want to turn some of these off and go
back into "opsmode" mode, then set `opsmode` to `a`.
"""
deg2rad = pi / 180.0
# 0.0174532925199433
xpdotp = 1440.0 / (2.0 * pi)
# 229.1831180523293
# For compatibility with our 1.x API, build an old Satellite object
# if the caller fails to supply a satrec. In that case we perform
# the necessary import here to avoid an import loop.
if satrec is None:
from sgp4.model import Satellite
satrec = Satellite()
satrec.error = 0
satrec.whichconst = whichconst # Python extension: remembers its consts
line = longstr1.rstrip()
if (len(line) >= 64 and line.startswith('1 ') and line[8] == ' '
and line[23] == '.' and line[32] == ' ' and line[34] == '.'
and line[43] == ' ' and line[52] == ' ' and line[61] == ' '
and line[63] == ' '):
_saved_satnum = satrec.satnum = _alpha5(line[2:7])
satrec.classification = line[7] or 'U'
satrec.intldesg = line[9:17].rstrip()
two_digit_year = int(line[18:20])
satrec.epochdays = float(line[20:32])
satrec.ndot = float(line[33:43])
satrec.nddot = float(line[44] + '.' + line[45:50])
nexp = int(line[50:52])
satrec.bstar = float(line[53] + '.' + line[54:59])
ibexp = int(line[59:61])
satrec.ephtype = line[62]
satrec.elnum = int(line[64:68])
else:
raise ValueError(error_message.format(1, LINE1, line))
line = longstr2.rstrip()
if (len(line) >= 69 and line.startswith('2 ') and line[7] == ' '
and line[11] == '.' and line[16] == ' ' and line[20] == '.'
and line[25] == ' ' and line[33] == ' ' and line[37] == '.'
and line[42] == ' ' and line[46] == '.' and line[51] == ' '):
satrec.satnum = _alpha5(line[2:7])
if _saved_satnum != satrec.satnum:
raise ValueError('Object numbers in lines 1 and 2 do not match')
satrec.inclo = float(line[8:16])
satrec.nodeo = float(line[17:25])
satrec.ecco = float('0.' + line[26:33].replace(' ', '0'))
satrec.argpo = float(line[34:42])
satrec.mo = float(line[43:51])
satrec.no_kozai = float(line[52:63])
satrec.revnum = line[63:68]
#except (AssertionError, IndexError, ValueError):
else:
raise ValueError(error_message.format(2, LINE2, line))
# ---- find no, ndot, nddot ----
satrec.no_kozai = satrec.no_kozai / xpdotp
# rad/min
satrec.nddot = satrec.nddot * pow(10.0, nexp)
satrec.bstar = satrec.bstar * pow(10.0, ibexp)
# ---- convert to sgp4 units ----
satrec.ndot = satrec.ndot / (xpdotp * 1440.0)
# ? * minperday
satrec.nddot = satrec.nddot / (xpdotp * 1440.0 * 1440)
# ---- find standard orbital elements ----
satrec.inclo = satrec.inclo * deg2rad
satrec.nodeo = satrec.nodeo * deg2rad
satrec.argpo = satrec.argpo * deg2rad
satrec.mo = satrec.mo * deg2rad
"""
// ----------------------------------------------------------------
// find sgp4epoch time of element set
// remember that sgp4 uses units of days from 0 jan 1950 (sgp4epoch)
// and minutes from the epoch (time)
// ----------------------------------------------------------------
// ---------------- temp fix for years from 1957-2056 -------------------
// --------- correct fix will occur when year is 4-digit in tle ---------
"""
if two_digit_year < 57:
year = two_digit_year + 2000
else:
year = two_digit_year + 1900
mon, day, hr, minute, sec = days2mdhms(year, satrec.epochdays)
sec_whole, sec_fraction = divmod(sec, 1.0)
satrec.epochyr = year
satrec.jdsatepoch = jday(year, mon, day, hr, minute, sec)
try:
satrec.epoch = datetime(year, mon, day, hr, minute, int(sec_whole),
int(sec_fraction * 1000000.0 // 1.0))
except ValueError:
# Sometimes a TLE says something like "2019 + 366.82137887 days"
# which would be December 32nd which causes a ValueError.
year, mon, day, hr, minute, sec = invjday(satrec.jdsatepoch)
satrec.epoch = datetime(year, mon, day, hr, minute, int(sec_whole),
int(sec_fraction * 1000000.0 // 1.0))
# ---------------- initialize the orbit at sgp4epoch -------------------
sgp4init(whichconst, opsmode, satrec.satnum, satrec.jdsatepoch - 2433281.5,
satrec.bstar, satrec.ndot, satrec.nddot, satrec.ecco,
satrec.argpo, satrec.inclo, satrec.mo, satrec.no_kozai,
satrec.nodeo, satrec)
return satrec
def __init__(self,
whichconst,
satnum,
epoch,
bstar,
inclo,
nodeo,
ecco,
argpo,
mo,
no_kozai,
ndot=0,
nddot=0,
classification='U',
intldesg=None,
elnum=1,
revnum=1,
afspc_mode=False):
"""
:param whichconst: standard set of gravitational constants.
`sgp4.earth_gravity.wgs72` - Standard WGS 72 model
`sgp4.earth_gravity.wgs84` - More recent WGS 84 model
`sgp4.earth_gravity.wgs72old` - Legacy support for old SGP4 behavior
:param satnum: Unique satellite number given in the TLE file.
:param epoch: naive datetime objects with TLE epoch
:param bstar: Ballistic drag coefficient B* in inverse earth radii.
:param inclo: Inclination in radians.
:param nodeo: Right ascension of ascending node in radians.
:param ecco: Eccentricity.
:param argpo: Argument of perigee in radians.
:param mo: Mean anomaly in radians.
:param no_kozai: Mean motion in radians per minute (rad/min).
:param ndot: First time derivative of the mean motion (ignored by SGP4).
:param nddot: Second time derivative of the mean motion (ignored by SGP4).
:param classification: (U=Unclassified, C=Classified, S=Secret)
:param intldesg: International designator (last two digits of launch year,
launch number of the year, piece of the launch)
:param elnum: Element set number. Incremented when a new TLE is generated for this object.
:param revnum: Revolution number at epoch (revolutions)
:param afspc_mode: Normally, computations are made using various recent improvements to the
algorithm. If you want to turn some of these off and go back into "afspc" mode, then set
`afspc_mode` to `True`.
"""
self.whichconst = whichconst
self.satnum = satnum
self.epoch = epoch
self.epochyr = epoch.year
self.jdsatepoch = jday(epoch.year, epoch.month, epoch.day, epoch.hour,
epoch.minute,
epoch.second + 1e-6 * epoch.microsecond)
days_in_the_year = (epoch.date() -
datetime.date(epoch.year, 1, 1)).days + 1
self.epochdays = days_in_the_year + (
epoch.hour + epoch.minute / 60 +
(epoch.second + 1e-6 * epoch.microsecond) / 60 / 60) / 24.0
self.bstar = bstar
self.inclo = inclo
self.nodeo = nodeo
self.ecco = ecco
self.argpo = argpo
self.mo = mo
self.no_kozai = no_kozai
self.a = pow(self.no_kozai * whichconst.tumin, (-2.0 / 3.0))
self.alta = self.a * (1.0 + self.ecco) - 1.0
self.altp = self.a * (1.0 - self.ecco) - 1.0
self.ndot = ndot
self.nddot = nddot
self.classification = classification
if intldesg:
self.intldesg = intldesg
else:
self.intldesg = str(self.epochyr)[:-2] + '001A'
self.elnum = elnum
self.revnum = revnum
self.error = 0
sgp4init(whichconst, afspc_mode, self.satnum,
self.jdsatepoch - 2433281.5, self.bstar, self.ecco,
self.argpo, self.inclo, self.mo, self.no_kozai, self.nodeo,
self)
