def test_bad_second_line(self):
with self.assertRaisesRegexp(ValueError, re.escape("""TLE format error
The Two-Line Element (TLE) format was designed for punch cards, and so
is very strict about the position of every period, space, and digit.
Your line does not quite match. Here is the official format for line 2
with an N where each digit should go, followed by the line you provided:
2 NNNNN NNN.NNNN NNN.NNNN NNNNNNN NNN.NNNN NNN.NNNN NN.NNNNNNNNNNNNNN
2 00005 34 .268234 8.7242 1859667 331.7664 19.3264 10.82419157413667""")):
io.twoline2rv(good1, good2.replace(' 34', '34 '), wgs72)
def test_bad_first_line(self):
with self.assertRaisesRegexp(ValueError, re.escape("""TLE format error
The Two-Line Element (TLE) format was designed for punch cards, and so
is very strict about the position of every period, space, and digit.
Your line does not quite match. Here is the official format for line 1
with an N where each digit should go, followed by the line you provided:
1 NNNNNC NNNNNAAA NNNNN.NNNNNNNN +.NNNNNNNN +NNNNN-N +NNNNN-N N NNNNN
1 00005U 58002B 00179.78495062 .000000234 00000-0 28098-4 0 4753""")):
io.twoline2rv(good1.replace('23 ', '234'), good2, wgs72)
def propagate(self, date_from, date_to, sample=300):
'''Предсказывает положение спутника в заданный промежуток времени и с
заданной периодичностью
@param: date_from Дата начала расчета.
@param: date_to Дата окончания расчета.
@param: sample Период вычислений в секундах (по умолчанию: 300 сек).
'''
assert (date_from >= self.epoch), 'Дата начала расчета произошла раньше эпохи'
assert (date_to > date_from), 'Дата окончания произошла раньше даты начала'
line1, line2 = self.to_tle().split('\n')[1:]
satmodel = twoline2rv(line1, line2, wgs84)
ts_locations = []
for sec in range(0, int((date_to-date_from).total_seconds()), sample):
ts_locations.append(
tuple([sec] +
[1000*x for x in satmodel.propagate(*tuple((
date_from +
timedelta(seconds=sec)).timetuple()[:-3]))[0]]))
return ts_locations
def main():
lines = open('../sat23839.txt','r').read().splitlines()
satellite = twoline2rv(lines[7], lines[8], wgs72)
times = []
report = csv.DictReader(open('atsb-report.csv', 'r'))
for r in report:
time = r['Time']
hours = int(time[0:2])
minutes = int(time[3:5])
seconds = int(time[6:8])
day = 7 if (hours > 12) else 8
times.append([2014, 3, day, hours, minutes, seconds])
w = csv.writer(open('sgp4-positions.csv', 'w'), lineterminator='\n')
w.writerow(['x', 'y','z', 'dx','dy', 'dz'])
for time in times:
position, velocity = satellite.propagate(*time)
jd = julian_date(*time)
velocity = numpy.asarray(velocity) * 24.0 * 60.0 * 60.0
p,v = TEME_to_ITRF(jd, position, velocity.tolist())
v = v / (24.0 * 60.0 * 60.0)
p = ["%0.1f" % i for i in p]
v = ["%0.5f" % i for i in v]
w.writerow([ p[0],p[1],p[2],v[0],v[1],v[2] ])
def state_satellite(dateTime,tle):
year, month, day, hour, minute, second = dateTime
#ISS
#line1 = ('1 25544U 98067A 08264.51782528 .00002182 00000-0 -11606-4 0 2927')
#line2 = ('2 25544 51.6416 247.4627 0006703 130.5360 325.0288 15.72125391563537')
#line1 = ('1 00005U 58002B 00179.78495062 .00000023 00000-0 28098-4 0 4753')
#line2 = ('2 00005 34.2682 348.7242 1859667 331.7664 19.3264 10.82419157413667')
# similar to hiakasat orbit
#line1 = ('1 39143U 13016B 13112.53874487 -.00003669 11601-4 00000+0 0 49')
#line2 = ('2 39143 091.6094 306.9444 0018244 348.7202 11.3600 16.10627010 119')
#2 39143 91.6094 306.9444 0018244 348.7202 11.3600 16.10627010 119
#2 25544 51.6416 247.4627 0006703 130.5360 325.0288 15.72125391563537
satellite = twoline2rv(tle.line1, tle.line2, wgs72)
#position and velocity are given in ECI True Equator Mean Equinox (TEME) frame
position, velocity = satellite.propagate(year, month, day, hour, minute, second)
# convert TEME to a standard frame,
# suggestion: rotate to Pseudo Earth Fixed (PEF) using
# Greenwich Mean Sideral Time (GMST) and then rotate to other standard frame
# reference: http://www.centerforspace.com/downloads/files/pubs/AIAA-2008-6770.pdf Appendix B
return position, velocity
def api_calculate():
if request.headers['Content-Type'] == 'application/json':
satellite = twoline2rv(request.json['line1'], request.json['line2'], wgs72)
result = satellite.propagate(request.json['year'], request.json['month'], request.json['day'], request.json['hour'], request.json['minute'], request.json['second'])
return jsonify(position=result[0],velocity=result[1]);
else:
return "415 Unsupported Media Type ;)"
def Position_and_Velocity(self, time): '''This function generates the barycentric position and velocity of the orbital body at a specified time with the use of the SGP4 propogator.''' #The time to find the position and velocity at t = time #The first line of the orbital body's TLE line1 = self.TLE_line1 #The second line of the orbital body's TLE line2 = self.TLE_line2 #Fictitiously instantiate a SGP4 satellite object sat = twoline2rv(line1, line2, gravity_constant) #Convert Julian date to conventional time_conv = invjday(time) #Compute the geocentric position and velocity of the orbital body p, v = sat.propagate(*time_conv) #Turn the tuples into arrays p = np.asarray(p) v = np.asarray(v) #Convert km to m p = p * 1e3 #Convert km/s to m/s v = v * 1e3 #Compute the barycentric position and velocity of the attracting body P, V = self.attracting_body.Position_and_Velocity(time) #Compute the barycentric position of the orbital body p = p + P #compute the barycentric velocity of the orbital body v = v + V return p, v
def generate_test_output(whichconst):
"""Generate lines like those in the test file tcppver.out.
This iterates through the satellites in "SGP4-VER.TLE", which are
each supplemented with a time start/stop/step over which we are
supposed to print results.
"""
whichconst = wgs72
tlepath = os.path.join(thisdir, 'SGP4-VER.TLE')
with open(tlepath) as tlefile:
tlelines = iter(tlefile.readlines())
for line1 in tlelines:
if not line1.startswith('1'):
continue
line2 = next(tlelines)
satrec = twoline2rv(line1, line2, whichconst)
yield '%ld xx\n' % (satrec.satnum,)
for line in generate_satellite_output(satrec, line2):
yield line
def __init__(self, lines, earth):
sat = twoline2rv(*lines[-2:], whichconst=wgs72)
self._sgp4_satellite = sat
self._earth = earth
# TODO: Drat. Where should this Timescale come from?
# Should they have to pass it in?
self.epoch = Timescale().utc((sat.epochyr, 1, sat.epochdays))
def main():
lines = open('../sat23839.txt','r').read().splitlines()
satellite = twoline2rv(lines[7], lines[8], wgs72)
times = []
report = csv.DictReader(open('../inmarsat-su-log-redacted.csv', 'r'))
for r in report:
if r['Frequency Offset (Hz)'] != '':
t = datetime.datetime.now().strptime(r['Time'],"%d/%m/%Y %H:%M:%S.%f")
times.append(t)
w = csv.writer(open('python.csv', 'w'), lineterminator='\n')
w.writerow(['Time','x', 'y','z', 'dx','dy', 'dz'])
for t in times:
time = [t.year, t.month, t.day, t.hour, t.minute, t.second]
position, velocity = satellite.propagate(*time)
jd = julian_date(*time)
velocity = numpy.asarray(velocity) * 24.0 * 60.0 * 60.0
p,v = TEME_to_ITRF(jd, position, velocity.tolist())
v = v / (24.0 * 60.0 * 60.0)
# p = ["%0.1f" % i for i in p]
# v = ["%0.5f" % i for i in v]
w.writerow([ t,p[0],p[1],p[2],v[0],v[1],v[2] ])
def __init__(self, lines, earth):
sat = twoline2rv(*lines[-2:], whichconst=wgs72)
self._sgp4_satellite = sat
self._earth = earth
if EarthSatellite.timescale is None:
from skyfield import api
EarthSatellite.timescale = api.load.timescale()
self.epoch = EarthSatellite.timescale.utc(sat.epochyr, 1, sat.epochdays)
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 UpdateTLE():
#Solo me traigo el tle si hace un dia que no me lo traigo
try:
param = Parameter.objects.get(_Key="LastTLEDownload")
except Parameter.DoesNotExist:
param = None
if param==None:
param = Parameter()
param._Key = "LastTLEDownload"
param._Value = (datetime.utcnow() - timedelta(days=1)).strftime("%B %d, %Y")
param._Module = "OrbitDynamic"
param.save()
lastTLEDownload = datetime.strptime(param._Value, "%B %d, %Y")
dg = lastTLEDownload.date()
da = datetime.utcnow().date()
if dg<da:
print("Actualizando TLE...")
loginURL = Parameter.objects.get(_Key="NoradLoginURL")
username = Parameter.objects.get(_Key="NoradUserName")
password = Parameter.objects.get(_Key="NoradPassword")
data = {'identity': username._Value , 'password': password._Value}
s = session()
rp = s.post(loginURL._Value, data)
satellites = list(Satellite.objects.all())
for sat in satellites:
fquery = "https://www.space-track.org/basicspacedata/query/class/tle_latest/ORDINAL/1/NORAD_CAT_ID/" + str(sat._noradId) + "/orderby/TLE_LINE1 ASC/format/tle"
# print(s.cookies)
rg = s.get(fquery)
TLE = rg.text.split("\n")
sgp4sat = twoline2rv(TLE[0], TLE[1], wgs72) # es un objeto de clase (satelite)
tle = Tle()
tle._satellite = sat
tle._datetime = datetime.utcnow()
tle._tleDateTime = sgp4sat.epoch
tle._tle = rg.text
print("Salvando TLE")
tle.save()
param._Value = (datetime.utcnow()).strftime("%B %d, %Y")
param.save()
def init(self,*args,**kwargs):
super(KeplerOrbit,self).init(*args,**kwargs)
line0,line1,line2 = kwargs.get("tle").split("\n")
name = self._data_graph.node[("name",)]["obj"]
name.value = line0
body = self._data_graph.node[("body",)]["obj"]
self.value = twoline2rv(line1,line2,body.gravity)
def geojson():
# Test TLE for Hubble Space Telescope
line1 = ('1 20580U 90037B 14101.16170949 '
'.00002879 00000-0 18535-3 0 4781')
line2 = ('2 20580 028.4694 117.6639 0002957 '
'290.9180 143.6730 15.05140277114603')
satellite = twoline2rv(line1, line2, wgs72)
date = datetime(2000, 6, 29, 12, 46, 19)
delta = timedelta(minutes=1)
# empty array for GeoJSON LineString for groundtrack plotting
points = []
# Loop in one-minute steps to calculate track
for n in range(0, 90):
#print date
position, velocity = satellite.propagate(date.year, date.month, date.day,
date.hour, date.minute, date.second)
#print position
#print velocity
lat, gmra, alt = groundtrack(position)
#print str(lat)
#print str(gmra)
#print str(alt)
gmst = utcDatetime2gmst(date)
#print gmst
lon = (gmst * 15.0) - gmra
lon = ((lon + 180.0) % 360.0) - 180.0
#print lon
# add current point coordinates to GeoJSON LineString array
points.append([lon, lat])
date = date+delta
# Generate GeoJSON LineString for groundtrack
line = {"type": "LineString", "coordinates": points}
# Bottle function returns dict as JSON
return line
def __init__(self, line1, line2, name=None, ts=None):
ts = ts or _ts
self.name = None if name is None else name.strip()
sat = twoline2rv(line1, line2, whichconst=wgs72)
self.model = sat
self.epoch = ts.utc(sat.epochyr, 1, sat.epochdays)
self.target = object() # TODO: make this more interesting
self.target_name = 'Satellite{0} {1}'.format(
self.model.satnum,
' ' + repr(self.name) if self.name else '',
)
def L_para(T_E):
L1 = parser.get('mission_parameters', 'TLE_Line1')
L2 = parser.get('mission_parameters', 'TLE_Line2')
satellite = twoline2rv(L1, L2, wgs72)
position, velocity = satellite.propagate(T_E[0],T_E[1],T_E[2],T_E[3],T_E[4],T_E[5])
Re= [(x/6371.2) for x in position]
spaco = spc.Coords(Re, 'GEI', 'car')
spaco.ticks=spt.Ticktock([T_E[6]], 'ISO')
q=[90]
# q=spaco.convert('SM','sph') #default value of 90 is used as it returns the most data-points, other values of q have more instances when the value returned is NaN
# q=q.data[0][1]
L=ir.get_Lm(spaco.ticks,spaco,q,extMag='T01STORM',intMag='IGRF')
return satellite.alta*6371,satellite.altp*6371,math.degrees(satellite.inclo),L.items()[2][1][0][0]
def test_december_32():
# ISS [Orbit 606], whose date is 2019 plus 366.82137887 days.
# The core SGP4 routines handled this fine, but my hamfisted
# attempt to provide a Python datetime for "convenience" ran
# into an overflow.
sat = io.twoline2rv(
'1 25544U 98067A 19366.82137887 .00016717 00000-0 10270-3 0 9129',
'2 25544 51.6392 96.6358 0005156 88.7140 271.4601 15.49497216 6061',
wgs72,
)
assertEqual(
dt.datetime(2020, 1, 1, 19, 42, 47, 134367),
sat.epoch,
)
def twoline2rv(cls, line1, line2, whichconst=WGS72):
whichconst = gravity_constants[whichconst]
self = cls()
twoline2rv(line1, line2, whichconst, 'i', self)
# Expose the same attribute types as the C++ code.
self.ephtype = int(self.ephtype.strip() or '0')
self.revnum = int(self.revnum)
# Install a fancy split JD of the kind the C++ natively supports.
# We rebuild it from the TLE year and day to maintain precision.
year = self.epochyr
days, fraction = divmod(self.epochdays, 1.0)
self.jdsatepoch = year * 365 + (year - 1) // 4 + days + 1721044.5
self.jdsatepochF = round(fraction, 8) # exact number of digits in TLE
# Remove the legacy datetime "epoch", which is not provided by
# the C++ version of the object.
del self.epoch
# Undo my non-standard 4-digit year
self.epochyr %= 100
return self
def _createSatByID(self, identifier, file=None):
''' creates a satellite by its ID
code provided by david vallado (twoline2rv) '''
n, l1, l2 = getSatTLE(identifier, file)
if (l1 == None):
# If no TLE with that ID is found
self._successID = False
return None
else:
sat = sgp4_io.twoline2rv(l1, l2, sgp4_earth_gravity.wgs72)
sat.satname = n
return sat
def TLE_propagation_TEME(line1, line2, jd_ut1, wgs='72'):
'''Convert Two-line element to TEME coordinates at a specific Julian date.
:param str line1: TLE line 1
:param str line2: TLE line 2
:param float/numpy.ndarray jd_ut1: Julian Date UT1 to propagate TLE to.
:param str wgs: The used WGS standard, options are :code:`'72'` or :code:`'84'`.
:return: (6,len(jd_ut1)) numpy.ndarray of Cartesian states [SI units]
'''
if wgs == '72':
from sgp4.earth_gravity import wgs72 as wgs_sys
elif wgs == '84':
from sgp4.earth_gravity import wgs84 as wgs_sys
else:
raise Exception('WGS standard "{}" not recognized.'.format(wgs))
satellite = twoline2rv(line1, line2, wgs_sys)
if isinstance(jd_ut1, np.ndarray):
if len(jd_ut1.shape) > 1:
raise Exception(
'Only 1-D date array allowed: jd_ut1.shape = {}'.format(
jd_ut1.shape))
else:
if isinstance(jd_ut1, float):
jd_ut1 = np.array([jd_ut1], dtype=np.float)
states = np.empty((6, jd_ut1.size), dtype=np.float)
for jdi in range(jd_ut1.size):
year, month, day, hour, minute, second, usec = dpt.npdt2date(
dpt.mjd2npdt(dpt.jd_to_mjd(jd_ut1[jdi])))
position, velocity = satellite.propagate(
year=year,
month=month,
day=day,
hour=hour,
minute=minute,
second=second + usec * 1e-6,
)
state = np.array(position + velocity, dtype=np.float)
state *= 1e3 #km to m
states[:, jdi] = state
return states
def test_tle_export():
"""Check `export_tle()` round-trip using all the TLEs in the test file.
This iterates through the satellites in "SGP4-VER.TLE",
generates `Satrec` objects and exports the TLEs. These exported
TLEs are then compared to the original TLE, closing the loop (or
the round-trip).
"""
data = get_data(__name__, 'SGP4-VER.TLE')
tle_lines = iter(data.decode('ascii').splitlines())
# Skip these lines, known errors
# Resulting TLEs are equivalent (same values in the Satrec object), but they are not the same
# 25954: BSTAR = 0 results in a negative exp, not positive
# 29141: BSTAR = 0.13519 results in a negative exp, not positive
# 33333: Checksum error as expected on both lines
# 33334: Checksum error as expected on line 1
# 33335: Checksum error as expected on line 1
expected_errs_line1 = set([25954, 29141, 33333, 33334, 33335])
expected_errs_line2 = set([33333, 33335])
if accelerated:
# Non-standard: omits the ephemeris type integer.
expected_errs_line1.add(11801)
for line1 in tle_lines:
if not line1.startswith('1'):
continue
line2 = next(tle_lines)
# trim lines to normal TLE string size
line1 = line1[:69]
line2 = line2[:69]
satrec = Satrec.twoline2rv(line1, line2)
satrec_old = io.twoline2rv(line1, line2, wgs72)
# Generate TLE from satrec
out_line1, out_line2 = export_tle(satrec)
out_line1_old, out_line2_old = export_tle(satrec_old)
if satrec.satnum not in expected_errs_line1:
assertEqual(out_line1, line1)
assertEqual(out_line1_old, line1)
if satrec.satnum not in expected_errs_line2:
assertEqual(out_line2, line2)
assertEqual(out_line2_old, line2)
def calc(self):
line1 = ('1 00005U 58002B 00179.78495062 '
'.00000023 00000-0 28098-4 0 4753')
line2 = ('2 00005 34.2682 348.7242 1859667 '
'331.7664 19.3264 10.82419157413667')
satellite = twoline2rv(line1, line2, wgs84)
position, velocity = satellite.propagate(2000, 6, 29, 12, 50, 19)
print(satellite.error) # nonzero on error 0
print(satellite.error_message) # None
print(position)
#print('5576.056952..., -3999.371134..., -1521.957159...')
print(velocity)
def read_tles(tles: str, rgbs):
raw_tle = []
sats = []
i = 1
for line in tles.splitlines():
raw_tle.append(line)
if i % 3 == 0:
tle_object = twoline2rv(raw_tle[1], raw_tle[2], wgs72)
sats.append(Satellite(raw_tle, tle_object, rgbs.get_next_color()))
raw_tle = []
i += 1
return sats
def __init__(self, lines):
self.name = None if len(lines) < 3 else lines[0].strip()
sat = twoline2rv(*lines[-2:], whichconst=wgs72)
self._sgp4_satellite = sat
if EarthSatellite.timescale is None:
from skyfield import api
EarthSatellite.timescale = api.load.timescale()
self.epoch = EarthSatellite.timescale.utc(sat.epochyr, 1,
sat.epochdays)
self.target = object() # TODO: make this more interesting
self.target_name = 'Satellite{0} {1}'.format(
self._sgp4_satellite.satnum,
' ' + repr(self.name) if self.name else '',
)
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 states_to_lightcurve(times, states, pass_obj, quats=False):
lightcurve = []
spacecraft = twoline2rv(pass_obj['TLE'][0], pass_obj['TLE'][1], wgs84)
telescope_ecef = AF.lla_to_ecef(LAT, LON, ALT, geodetic=True)
utc0 = pass_obj['EPOCH']
for time, state in zip(times, states):
now = utc0 + datetime.timedelta(seconds=time)
sun_vec = AF.vect_earth_to_sun(now)
sc_eci, _ = spacecraft.propagate(now.year, now.month, now.day,
now.hour, now.minute, now.second)
sc_eci = asarray(sc_eci)
# if AF.shadow(sc_eci,sun_vec):
# #if the spacecraft is in shadow its brightness is zero
# print("IN SHADOW")
# lightcurve.append(0)
# continue
lst = AF.local_sidereal_time(now, LON)
telescope_eci = AF.Cz(lst) @ telescope_ecef
obs_vec = telescope_eci - sc_eci
if quats:
eta = state[0]
eps = state[1:4]
dcm_body2eci = R.from_quat(hstack([eps, eta])).as_dcm().T
else:
eulers = state[:3]
dcm_body2eci = R.from_euler(ROTATION, eulers).as_dcm().T
power = 0
for facet, area in zip(FACETS, AREAS):
normal = dcm_body2eci @ facet
if dot(normal, sun_vec) > 0 and dot(normal, obs_vec) > 0:
power += phong_brdf(obs_vec, sun_vec, normal, area)
lightcurve.append(power)
lightcurve = hstack(lightcurve)
return lightcurve
def L_para(T_E):
L1 = parser.get('mission_parameters', 'TLE_Line1')
L2 = parser.get('mission_parameters', 'TLE_Line2')
satellite = twoline2rv(L1, L2, wgs72)
position, velocity = satellite.propagate(T_E[0], T_E[1], T_E[2], T_E[3],
T_E[4], T_E[5])
Re = [(x / 6371.2) for x in position]
spaco = spc.Coords(Re, 'GEI', 'car')
spaco.ticks = spt.Ticktock([T_E[6]], 'ISO')
q = [90]
# q=spaco.convert('SM','sph') #default value of 90 is used as it returns the most data-points, other values of q have more instances when the value returned is NaN
# q=q.data[0][1]
L = ir.get_Lm(spaco.ticks, spaco, q, extMag='T01STORM', intMag='IGRF')
return satellite.alta * 6371, satellite.altp * 6371, math.degrees(
satellite.inclo), L.items()[2][1][0][0]
def read_tles(tle_file_name, rgbs):
tle_src = open(tle_file_name, 'r')
raw_tle = []
sats = []
i = 1
for line in tle_src:
raw_tle.append(line)
if i % 3 == 0:
tle_object = twoline2rv(raw_tle[1], raw_tle[2], wgs72)
sats.append(Satellite(raw_tle, tle_object, rgbs.get_next_color()))
raw_tle = []
i += 1
return sats
def calc(self):
line1 = ('1 00005U 58002B 00179.78495062 '
'.00000023 00000-0 28098-4 0 4753')
line2 = ('2 00005 34.2682 348.7242 1859667 '
'331.7664 19.3264 10.82419157413667')
satellite = twoline2rv(line1, line2, wgs84)
position, velocity = satellite.propagate(2000, 6, 29, 12, 50, 19)
print(satellite.error) # nonzero on error 0
print(satellite.error_message) # None
print(position)
#print('5576.056952..., -3999.371134..., -1521.957159...')
print(velocity)
#print('4.772627..., 5.119817..., 4.275553...')
def __init__(self, line1, line2, name=None, ts=None):
self.name = None if name is None else name.strip()
sat = twoline2rv(line1, line2, whichconst=wgs72)
self.model = sat
if ts is None:
if EarthSatellite.timescale is None:
from skyfield.api import load
EarthSatellite.timescale = load.timescale()
ts = EarthSatellite.timescale
self.epoch = ts.utc(sat.epochyr, 1, sat.epochdays)
self.target = object() # TODO: make this more interesting
self.target_name = 'Satellite{0} {1}'.format(
self.model.satnum,
' ' + repr(self.name) if self.name else '',
)
def tle2eci(l1, l2, year, month, day, hour, minute, secunde):
"""
Function takes first and second line of tle data and returns
ECI position (x, y, z) of the satellite at current UTC time.
For parsing TLE data and getting current location I am using
spg4 library
"""
satellite = twoline2rv(l1, l2, wgs84)
#a_date = ephem.now()
#global y, mn, d, h, min, sec
#(y, mn, d, h, min, sec) = a_date.tuple()
position, velocity = satellite.propagate(year, month, day, hour, minute,
secunde)
#print "tle2eci", position
#print position
return position
def get_satellite_orbit(raw_tle, sim_start_time, sim_end_time, czml_file_name):
sat_name = raw_tle[0]
tle_sgp4 = twoline2rv(raw_tle[1], raw_tle[2], wgs72)
sat = Satellite(raw_tle, tle_sgp4, DEFAUlead_times_RGBA)
doc = create_czml_file(sim_start_time, sim_end_time)
if DEBUGGING:
print()
print('Satellite Name: ', sat.satName)
print('TLE Epoch: ', sat.tleEpoch)
print('Orbit time in Minutes: ', sat.orbitalTimeInMinutes)
print()
sat_packet = create_satellite_packet(sat.sat_name, sat.tle_object, sat.orbital_time_in_minutes, sim_start_time, sim_end_time, sat.rgba)
doc.packets.append(sat_packet)
doc.write(czml_file_name)
def orbit(self, orbit):
"""Initialize the propagator
Args:
orbit (Orbit)
"""
self._orbit = orbit
tle = Tle.from_orbit(orbit)
lines = tle.text.splitlines()
if len(lines) == 3:
_, line1, line2 = lines
else:
line1, line2 = lines
self.tle = twoline2rv(line1, line2, wgs72)
def __init__(self,
gps_tle_file,
rx_sv_list=('PRN 03', 'PRN 09', 'PRN 22', 'PRN 26'),
ref_lla=(38.8454167, -104.7215556, 1903.0),
ts=1.0):
"""
Parameters
----------
gps_tle_file : A text file extracted from Celestrak Web Site
ref_lla : A 3 element tuple of lat(deg), lon(deg), and ele(m)
Returns
-------
None : This is the constructor method
Notes
-----
Default lla is CosmicAES COS office
"""
self.ref_lla = ref_lla
self.GPS_TLE_file = gps_tle_file
self.Rx_sv_list = rx_sv_list
"""
Perform coordinate conversion
"""
# convert from llh (or lla) to earth centric fixed
self.ref_ecef = self.llh2ecef(self.ref_lla)
"""
Read GPS TLEs into dictionary
"""
self.GPS_sv_dict = self.get_gps_sv(self.GPS_TLE_file)
"""
Initialize Four SGP4 satellite objects in tuple satellite
"""
self.satellite = []
for k in range(4):
PRN = self.Rx_sv_list[k]
self.satellite.append(
twoline2rv(self.GPS_sv_dict[PRN][0], self.GPS_sv_dict[PRN][1],
wgs84))
"""
Time offset relative to satellite propagation start time
"""
self.Ts = ts
self.t_delta = np.array([0])
self.N_sim_steps = 0
def orbit(self, orbit):
"""Initialize the propagator
Args:
orbit (Orbit)
"""
self._orbit = orbit
tle = Tle.from_orbit(orbit)
lines = tle.text.splitlines()
if len(lines) == 3:
_, line1, line2 = lines
else:
line1, line2 = lines
self.tle = twoline2rv(line1, line2, wgs72)
def sgp4_tracs(request, *args, **kw):
"""Sat. orbit tracs by SGP4 module."""
from sgp4.earth_gravity import wgs84
from sgp4.io import twoline2rv
import datetime, math
tledata = [
[
'ISS (ZARYA)',
'1 25544U 98067A 12138.83290882 .00011789 00000-0 17152-3 0 5727',
'2 25544 51.6409 274.1861 0010682 328.0828 128.1508 15.56173799773289'
],
[
'MOLNIYA 1-90',
'1 24960U 97054A 04104.60038411 -.00000148 00000-0 10000-3 0 8467',
'2 24960 64.1699 306.8439 7209074 272.6281 14.3196 2.00635799 48072'
],
[
'COSMOS 158 R/B',
'1 02802U 67045B 04105.12224913 .00000082 00000-0 32618-4 0 5785',
'2 02802 74.0096 111.2339 0069038 241.3647 118.0552 14.42132256935013'
]
]
utc = list(args)
for i, arg in enumerate(utc):
utc[i] = int(arg)
# loop tledata
ret = []
for x in tledata:
pos = []
try:
satellite = twoline2rv(x[1], x[2], wgs84)
ps = 2.0 * math.pi * 1 / satellite.no * 60.0
utc1 = utc2 = datetime.datetime(*utc)
# by 2 mean motion ago
delta = datetime.timedelta(0, ps)
step = delta.total_seconds() / 10.0
while (utc1 - utc2 < delta):
p, v = satellite.propagate(*utc2.timetuple()[:6])
utc2 = utc2 - datetime.timedelta(0, step)
pos += [p]
break
ret += [[x[0], pos]]
except:
pass
return HttpResponse(str(ret))
def main():
tle_list = []
with open('data/zarya_tle', 'rb') as tlefile:
for _ in range(50):
line1 = tlefile.readline()
line2 = tlefile.readline()
tle_list.append((line1, line2))
x_file.write('dttm,value,label\n')
y_file.write('dttm,value,label\n')
z_file.write('dttm,value,label\n')
prev_sat = None
prev_tle = None
prev_date = None
for tle in tle_list:
line1, line2 = tle
# Initialize the satellite propagation model
satellite = twoline2rv(line1, line2, wgs84)
date = date_from_jds(satellite.jdsatepoch)
if prev_tle is None:
prev_tle = tle
prev_sat = satellite
prev_date = date
continue
time_delta_minutes = (date - prev_date).total_seconds()/60
time_delta_half = time_delta_minutes / 2
# First we catch the previous satellite up to the midway point
propogate_over_range(prev_sat, prev_date, 0, int(time_delta_half))
# Then we run the current satellite backwards to th halfway point
propogate_over_range(satellite, date, -int(time_delta_half), 0)
prev_tle = tle
prev_sat = satellite
prev_date = date
x_file.close()
y_file.close()
z_file.close()
def get_satellite_orbit(raw_tle, sim_start_time, sim_end_time, czml_file_name):
'returns orbit of the satellite'
tle_sgp4 = twoline2rv(raw_tle[1], raw_tle[2], wgs72)
sat = Satellite(raw_tle, tle_sgp4, DEFAULT_RGBA)
doc = create_czml_file(sim_start_time, sim_end_time)
if DEBUGGING:
print()
print('Satellite Name: ', sat.get_satellite_name)
print('TLE Epoch: ', sat.tle_epoch)
print('Orbit time in Minutes: ', sat.orbital_time_in_minutes)
print()
sat_packet = create_satellite_packet(sat, sim_start_time, sim_end_time)
doc.packets.append(sat_packet)
with open(czml_file_name, 'w') as file:
file.write(str(doc))
def Position_and_Velocity_Satellite(satellite, time):
# The first line of the TLE
line1 = satellite.line1
# The second line
line2 = satellite.line2
# Fictitious SGP4 satellite object
sat = twoline2rv(line1, line2, grav_const)
# Convert Julian date to conventional
time_conv = invjday(time)
# The position and velocity of the satellite
pv = np.asarray(sat.propagate(*time_conv))
# Convert km to m and km/s to m/s
pv = np.multiply(pv, 1e3)
# The attracting body ephemeris
PV = satellite.attracting_body.Position_and_Velocity(time)
# Convert from geocentric to barycentric frame
pv = np.add(pv, PV)
return pv
def test_december_32():
# ISS [Orbit 606], whose date is 2019 plus 366.82137887 days.
# The core SGP4 routines handled this fine, but my hamfisted
# attempt to provide a Python datetime for "convenience" ran
# into an overflow.
a = '1 25544U 98067A 19366.82137887 .00016717 00000-0 10270-3 0 9129'
b = '2 25544 51.6392 96.6358 0005156 88.7140 271.4601 15.49497216 6061'
correct_epoch = dt.datetime(2020, 1, 1, 19, 42, 47, 134368)
# Legacy API.
sat = io.twoline2rv(a, b, wgs72)
assertEqual(sat.epoch, correct_epoch)
correct_epoch = correct_epoch.replace(tzinfo=conveniences.UTC)
# Modern API.
sat = Satrec.twoline2rv(a, b)
assertEqual(conveniences.sat_epoch_datetime(sat), correct_epoch)
def load_tle_data():
now = datetime.now()
with open('tle.txt', 'r') as f:
while True:
try:
line1 = f.readline()
line2 = f.readline()
debris = twoline2rv(line1, line2, wgs84)
position, velocity = debris.propagate(now.year, now.month,
now.day, now.hour + 1)
d = {
'satellite': debris,
'position': position,
'velocity': velocity
}
satellites.append(d)
except:
return
def sgp4_step(line1, line2, mjd, model=wgs84):
"""
Function: sgp4_step
Returns position and velocity in ECI from SGP4 propagation.
Inputs:
line1: first line of TLE (string)
line2: second line of TLE (string)
mjd time to propagate to (mjd)
model: Earth gravity model to use (default=wgs84)
Outputs:
rECI: position in ECI
vECI: velocity in ECI
"""
sgp4 = twoline2rv(line1, line2, model)
dt = julian.from_jd(mjd, fmt='mjd')
sec = dt.second + dt.microsecond / 1e6
return sgp4.propagate(dt.year, dt.month, dt.day, dt.hour, dt.minute, sec)
def TLE_read(sat, TLEfile1in=False):
norad_id = norad(sat)
if norad_id == 0: return 0
if TLEfile1in:
TLEfile1 = TLEfile1in
else:
TLEfile1 = "sarsat.txt"
with open(TLEfile1) as TLE:
for line in TLE:
#print(sats)
if norad_id in line[2:7]:
TLEout = []
if int(line[0]) == 1:
TLEout1 = line[:]
elif int(line[0]) == 2:
TLEout2 = line[:]
if TLEout1 == None: return 0
satellite = twoline2rv(TLEout1, TLEout2, wgs72)
return satellite
def propagaTLE(self, date=None):
"""
Devuelve las coordenadas cartesianas x,y,z. !! EN TEME!!
Si no se introduce una fecha, devuelve las coordenadas correspondientes
a la fecha y hora del TLE.
Si se le introduce una fecha y hora, propaga hasta ese momento y devuelve
las coordenadas de la propagacion.
"""
whichconst = wgs84
satrec = twoline2rv(self.linea1, self.linea2, whichconst)
if date == None:
ffin = satrec.epoch
r, v = satrec.propagate(ffin.year, ffin.month, ffin.day, ffin.hour,
ffin.minute, ffin.second)
else:
segundos = date.second + date.microsecond / 1000000.0
r, v = satrec.propagate(date.year, date.month, date.day, date.hour,
date.minute, segundos) #date.second
return r, v
def get_sat(tle_string):
'''
Construct a satellite instance (`sgp4.io.Satellite`) from TLE string.
Parameters
----------
tle_string : str
Two-line elements (TLE) as 3-line string
Returns
-------
satname : str
Name (identifier) of satellite
satellite : `sgp4.io.Satellite` instance
Satellite object filled from TLE
Notes
-----
TLE string must be of the form:
.. code-block:: none
ISS (ZARYA)
1 25544U 98067A 13165.59097222 .00004759 00000-0 88814-4 0 47
2 25544 51.6478 121.2152 0011003 68.5125 263.9959 15.50783143834295
'''
try:
import sgp4
from sgp4.earth_gravity import wgs72
from sgp4.io import twoline2rv, Satellite
except ImportError:
raise ImportError(
'The "sgp4" package is necessary to use this function.'
)
tle_string_list = tle_string.split('\n')
satname = tle_string_list[0]
if satname[0:2] == '0 ': # remove leading 0 if present
satname = satname[2:]
satellite = twoline2rv(tle_string_list[1], tle_string_list[2], wgs72)
return satname, satellite
def test_eci_position_vs_sgp4(self):
from sgp4.earth_gravity import wgs72
from sgp4.io import twoline2rv
sat2 = twoline2rv(self.tle_tup[1], self.tle_tup[2], wgs72)
pos2, vel2 = sat2.propagate(*self.dt_tup[:-2],
self.dt_tup[-2] + self.dt_tup[-1] / 1e6)
sat = Satellite(self.tle, self.effbg_observer, self.pydt)
eci_pos = sat.eci_pos()
print(eci_pos.loc)
print(pos2)
print(eci_pos.vel)
print(vel2)
assert_allclose(eci_pos.loc, pos2, atol=1e-2)
assert_allclose(eci_pos.vel, vel2, atol=1e-5)
def createTLE(self, date):
"""
Creates a new TLE for the received date.
Parameters
----------
date : datetime
Date used to obtain the epoch of the TLE.
"""
rad2deg = 180/pi
self.updateEpoch(date)
aux="{:+.9f}".format(self.ndot)
ndot = "{}{}".format(aux[0],aux[2:-1])
#aux = "{:+.6f}".format(self.bstar*10000)
#BSTAR = "{}{}-4".format(aux[0],aux[3:-1])
aux="{:+.6f}".format(self.B*2.461*10**(-5)*6378.135*0.5*100)
BSTAR = "{}{}-2".format(aux[0],aux[3:-1])
aux="{:.8f}".format(self.e)
e = "{}".format(aux[2:-1])
tle_num = "{:4d}".format(self.element_number)
epoch_year = self.epoch_year - 2000
line1 = "1 {}U {:9}{}{:012.8f} {} +{} {} 0 {}7".format(self.satnumber,
self.id_launch_data,
epoch_year,
self.epoch_day,
ndot,
"00000-0",
BSTAR,
tle_num)
line2 = "2 {} {:8.4f} {:8.4f} {} {:8.4f} {:08.4f} {:02.8f}{}7".format(self.satnumber,
self.incl*rad2deg,
self.RAAN*rad2deg,
e,
self.w*rad2deg,
self.MA*rad2deg,
86400/self.getPeriod(),
" 0")
checksum1 = self.checksum(line1)
checksum2 = self.checksum(line2)
line1 = "{}{}".format(line1[0:-1], checksum1)
line2 = "{}{}".format(line2[0:-1], checksum2)
self.sat_model = twoline2rv(line1, line2, wgs72)
return self.name, line1, line2
def tle2eci(l1, l2):
"""
Function takes first and second line of tle data and returns
ECI position (x, y, z) of the satellite at current UTC time.
For parsing TLE data and getting current location I am using
spg4 library
"""
satellite = twoline2rv(l1, l2, wgs84)
ljubljana = timezone('Europe/Ljubljana')
lj_time = datetime.datetime.now(ljubljana)
a_date = ephem.Date(lj_time.strftime('%Y/%m/%d %H:%M:%S'))
#print "Time in Ljubljana: ", a_date
(year, month, day, hour, minute, secunde) = a_date.tuple()
position, velocity = satellite.propagate(year, month, day, hour - 2,
minute, secunde)
#print "ECI position: ", position
return position
def TLE_to_TEME(line1, line2, wgs='72'):
'''Convert Two-line element to TEME coordinates and a Julian date epoch.
Here it is assumed that the TEME frame uses:
The Cartesian coordinates produced by the SGP4/SDP4 model have their z
axis aligned with the true (instantaneous) North pole and the x axis
aligned with the mean direction of the vernal equinox (accounting for
precession but not nutation). This actually makes sense since the
observations are collected from a network of sensors fixed to the
earth's surface (and referenced to the true equator) but the position
of the earth in inertial space (relative to the vernal equinox) must
be estimated.
:param str line1: TLE line 1
:param str line2: TLE line 2
:param str wgs: The used WGS standard, options are :code:`'72'` or :code:`'84'`.
:return: tuple of (6-D numpy.ndarray Cartesian state [SI units], epoch in Julian Date UT1)
'''
year, month, day, hour, minute, second, usec = tle_date(line1)
if wgs == '72':
from sgp4.earth_gravity import wgs72 as wgs_sys
elif wgs == '84':
from sgp4.earth_gravity import wgs84 as wgs_sys
else:
raise Exception('WGS standard "{}" not recognized.'.format(wgs))
satellite = twoline2rv(line1, line2, wgs_sys)
position, velocity = satellite.propagate(
year=year,
month=month,
day=day,
hour=hour,
minute=minute,
second=second,
)
state = np.array(position + velocity, dtype=np.float)
state *= 1e3 #km to m
return state, tle_jd(line1)
def get_sat(tle_string):
'''
Construct a satellite instance (`sgp4.io.Satellite`) from TLE string.
Parameters
----------
tle_string : str
Two-line elements (TLE) as 3-line string
Returns
-------
satname : str
Name (identifier) of satellite
satellite : `sgp4.io.Satellite` instance
Satellite object filled from TLE
Notes
-----
TLE string must be of the form:
.. code-block:: none
ISS (ZARYA)
1 25544U 98067A 13165.59097222 .00004759 00000-0 88814-4 0 47
2 25544 51.6478 121.2152 0011003 68.5125 263.9959 15.50783143834295
'''
try:
import sgp4
from sgp4.earth_gravity import wgs72
from sgp4.io import twoline2rv, Satellite
except ImportError:
raise ImportError(
'The "sgp4" package is necessary to use this function.')
tle_string_list = tle_string.split('\n')
satname = tle_string_list[0]
if satname[0:2] == '0 ': # remove leading 0 if present
satname = satname[2:]
satellite = twoline2rv(tle_string_list[1], tle_string_list[2], wgs72)
return satname, satellite
def get_nustar_location(checktime, line1, line2):
'''
Code to determine the spacecraft location from the TLE.
Inputs are a datetime object and the two lines of the TLE you want to use.
Returns a tuple that has the X, Y, and Z geocentric coordinates (in km).
'''
from sgp4.earth_gravity import wgs72
from sgp4.io import twoline2rv
from astropy.coordinates import EarthLocation
satellite = twoline2rv(line1, line2, wgs72)
position, velocity = satellite.propagate(
checktime.year, checktime.month, checktime.day,
checktime.hour, checktime.minute, checktime.second)
return position
def sgp4_tracs(request, *args, **kw):
"""Sat. orbit tracs by SGP4 module."""
from sgp4.earth_gravity import wgs84
from sgp4.io import twoline2rv
import datetime, math
tledata = [[ 'ISS (ZARYA)',
'1 25544U 98067A 12138.83290882 .00011789 00000-0 17152-3 0 5727',
'2 25544 51.6409 274.1861 0010682 328.0828 128.1508 15.56173799773289' ],
[ 'MOLNIYA 1-90',
'1 24960U 97054A 04104.60038411 -.00000148 00000-0 10000-3 0 8467',
'2 24960 64.1699 306.8439 7209074 272.6281 14.3196 2.00635799 48072' ],
[ 'COSMOS 158 R/B',
'1 02802U 67045B 04105.12224913 .00000082 00000-0 32618-4 0 5785',
'2 02802 74.0096 111.2339 0069038 241.3647 118.0552 14.42132256935013' ]]
utc = list(args)
for i, arg in enumerate(utc):
utc[i] = int(arg)
# loop tledata
ret = []
for x in tledata:
pos = []
try:
satellite = twoline2rv(x[1], x[2], wgs84)
ps = 2.0 * math.pi * 1/satellite.no * 60.0
utc1 = utc2 = datetime.datetime(*utc)
# by 2 mean motion ago
delta = datetime.timedelta(0, ps)
step = delta.total_seconds() / 10.0
while (utc1 - utc2 < delta):
p, v = satellite.propagate(*utc2.timetuple()[:6])
utc2 = utc2 - datetime.timedelta(0, step)
pos += [p]
break
ret += [[x[0], pos]]
except:
pass
return HttpResponse(str(ret))
def __init__(self, local_path, jansky, name_list=None):
self.jansky = jansky
self.satellites = []
f = open(local_path, "r")
lines = f.readlines()
for i, l in enumerate(lines):
#print(i, l)
if (i % 3 == 0):
name = l.strip()
if (i % 3 == 1):
line1 = l.strip()
if (i % 3 == 2):
line2 = l.strip()
sv = twoline2rv(line1, line2, wgs84)
if name_list is None:
self.satellites.append(Sp4Ephemeris(name, sv))
else:
# Check that name is in the list.
for n in name_list:
if n in name:
self.satellites.append(Sp4Ephemeris(name, sv))
def getPosition(self, mnow = datetime.utcnow()):
"""
Retorna la posicion actual del satelite en funcion del ultimo TLE, no utiliza las
propagaciones previamente armadas aunque seria una buena alternativa
Retorna x, y, z y velocity
Utiliza SGP4 para propagar
"""
#Como busco dentro de los tles del satelite????
try:
tleo = self.tle_set.all().filter(_tleDateTime__range=[mnow-timedelta(days=30), mnow])
tleo = tleo[0]
TLE = tleo._tle.split("\n")
#sgp4sat = twoline2rv(TLE[0], TLE[1], wgs72) # es un objeto de clase (satelite)
sat = twoline2rv(TLE[0], TLE[1], wgs72) # es un objeto de clase (satelite)
position, velocity = sat.propagate( mnow.year, mnow.month, mnow.day, mnow.hour , mnow.minute, mnow.second)
except Tle.DoesNotExists:
#Lanzar excepcion
position = None
velocity = None
return position, velocity
lat = atan2((z+ep*ep*b*pow(sin(th),3)), (p-e*e*a*pow(cos(th),3)))
n = a/sqrt(1-e*e*pow(sin(lat),2))
alt = p/cos(lat)-n
lat = (lat*180)/pi
lon = (lon*180)/pi
return (lat, lon, alt)
# Test TLE for Hubble Space Telescope
line1 = ('1 20580U 90037B 14101.16170949 '
'.00002879 00000-0 18535-3 0 4781')
line2 = ('2 20580 028.4694 117.6639 0002957 '
'290.9180 143.6730 15.05140277114603')
satellite = twoline2rv(line1, line2, wgs72)
date = datetime(2000, 6, 29, 12, 46, 19)
delta = timedelta(minutes=1)
position, velocity = satellite.propagate(date.year, date.month, date.day, date.hour, date.minute, date.second)
print position
print velocity
lat, gmra, alt = groundtrack(position)
print str(lat)
print str(gmra)
# Read and store TLE catalog
###################################################################################################
# Read in catalog and store lines in list.
fileHandle = open(tleCatalogFilePath)
catalogLines = fileHandle.readlines()
fileHandle.close()
# Strip newline and return carriage characters.
for i in xrange(len(catalogLines)):
catalogLines[i] = catalogLines[i].strip('\r\n')
# Parse TLE entries and store debris objects.
debrisObjects = []
for tleEntry in xrange(0, len(catalogLines), tleEntryNumberOfLines):
debrisObjects.append(twoline2rv(catalogLines[tleEntry+1], catalogLines[tleEntry+2], wgs72))
###################################################################################################
###################################################################################################
# Compute pruned list and write to file.
###################################################################################################
# Convert altitude bounds [km] to mean motion [rad/min].
meanMotionMaximum = convertSemiMajorAxisToMeanMotion( \
altitudeMinimum + getgravconst('wgs72')[2], getgravconst('wgs72')[1]) * 60.0
meanMotionMinimum = convertSemiMajorAxisToMeanMotion( \
altitudeMaximum + getgravconst('wgs72')[2], getgravconst('wgs72')[1]) * 60.0
# Create pruned list based on bounds specified by user.
prunedList = [(objectIndex) for objectIndex, debrisObject in enumerate(debrisObjects) \
from sgp4.earth_gravity import wgs72
from sgp4.io import twoline2rv
from urllib import urlretrieve
from visual import *
from orbit import *
from time import sleep
new = twoline2rv("1 25544U 98067A 14102.55154002 .00018142 00000-0 31656-3 0 687","2 25544 51.6489 64.8360 0002245 19.9828 92.1413 15.50758489881146",wgs72)
year=2000
month=6
day=29
hour=12
minute=50
second=19
position, velocity = new.propagate(year, month, day, hour, minute, second)
#position = [x/1000.0 for x in position]
print position
ball= sphere(pos=tuple(position),radius=1000,make_trail=True,color=color.red)
earth = sphere(pos=(0,0,0),radius=6000)
#sleep(5)
#print("CHanged")
x=0
while True:
sleep(.01)
rate(30)
x+=1
position, velocity = new.propagate(year, month, day, hour, minute, second+x)
print(position)
data = response.readlines()
sats = []
thc = 0 # three counter count three and set to zero again.
for d in data:
if(thc < 3):
if(thc == 0):
tmp_sat_name = d.rstrip()
thc = thc + 1
elif(thc == 1):
tmp_sat_tle1 = d.rstrip()
thc = thc + 1
else:
tmp_sat_tle2 = d.rstrip()
sat = Sat(tmp_sat_name, tmp_sat_tle1, tmp_sat_tle2)
sats.append(sat)
thc = 0
earth_radius = 6378.137
print "sat_name, sma, inclination,ecco"
for sat in sats:
satellite = twoline2rv(sat.get_tle1(), sat.get_tle2(), wgs72)
satellite.propagate(2015, 8, 1, 12, 50, 19)
satllite_data = propagation._initl(satellite.satnum, satellite.whichconst,
satellite.ecco,
satellite.jdsatepoch, satellite.inclo,
satellite.no, satellite.method, "a")
print sat.get_name() + "," + str(satllite_data[3] * earth_radius) + "," +\
str(math.degrees(satellite.inclo)) + "," + str(satellite.ecco)
