def readOrbit(self, platformPositionRecord):
'''
reformat orbit from platformPositionRecord
'''
orb=Orbit()
orb.setOrbitSource('leaderfile')
orb.setOrbitQuality(self.orbitElementsDesignator[platformPositionRecord.metadata['Orbital elements designator']])
t0 = datetime.datetime(year=platformPositionRecord.metadata['Year of data point'],
month=platformPositionRecord.metadata['Month of data point'],
day=platformPositionRecord.metadata['Day of data point'])
t0 = t0 + datetime.timedelta(seconds=platformPositionRecord.metadata['Seconds of day'])
#####Read in orbit in inertial coordinates
deltaT = platformPositionRecord.metadata['Time interval between data points']
numPts = platformPositionRecord.metadata['Number of data points']
for i in range(numPts):
vec = StateVector()
t = t0 + datetime.timedelta(seconds=i*deltaT)
vec.setTime(t)
dataPoints = platformPositionRecord.metadata['Positional Data Points'][i]
pos = [dataPoints['Position vector X'], dataPoints['Position vector Y'], dataPoints['Position vector Z']]
vel = [dataPoints['Velocity vector X'], dataPoints['Velocity vector Y'], dataPoints['Velocity vector Z']]
vec.setPosition(pos)
vec.setVelocity(vel)
orb.addStateVector(vec)
return orb
class DOR(BaseEnvisatFile):
"""A class for parsing Envisat DORIS orbit files"""
def __init__(self,fileName=None):
BaseEnvisatFile.__init__(self)
self.fileName = fileName
self.fp = None
self.orbit = Orbit()
self.orbit.setOrbitSource('DORIS')
self.orbit.setReferenceFrame('ECR')
def parse(self):
orbitDict = {}
try:
self.fp = open(self.fileName, 'rb')
except IOError as errs:
errno,strerr = errs
print("IOError: %s" % strerr)
return
self.readMPH()
self.readSPH()
self.readStateVectors()
self.fp.close()
if (self.sph['dataSets'][0]['DS_NAME'] == 'DORIS PRELIMINARY ORBIT'):
self.orbit.setOrbitQuality('Preliminary')
elif (self.sph['dataSets'][0]['DS_NAME'] == 'DORIS PRECISE ORBIT'):
self.orbit.setOrbitQuality('Precise')
orbitDict.update(self.mph)
orbitDict.update(self.sph)
return orbitDict
def readStateVectors(self):
headerLength = self.mphLength + self.sphLength
self.fp.seek(headerLength)
for line in self.fp.readlines():
vals = line.decode('utf8').split()
dateTime = self._parseDateTime(vals[0] + ' ' + vals[1])
position = list(map(float,vals[4:7]))
velocity = list(map(float,vals[7:10]))
sv = StateVector()
sv.setTime(dateTime)
sv.setPosition(position)
sv.setVelocity(velocity)
self.orbit.addStateVector(sv)
def _parseDateTime(self,dtString):
dateTime = datetime.datetime.strptime(dtString,'%d-%b-%Y %H:%M:%S.%f')
return dateTime
def convert(self):
'''
Convert ECI orbit to ECEF orbit.
'''
ECROrbit = Orbit()
ECROrbit.configure()
for sv in self.orbit:
svtime = sv.getTime()
position = sv.getPosition()
velocity = sv.getVelocity()
####Compute GMST from GAST - Eq 5.13
dtiff = (svtime - self.referenceEpoch).total_seconds()
theta = self.referenceGAST + self.Omega * dtiff
costh = np.cos(theta)
sinth = np.sin(theta)
###Position transformation
A = np.zeros((3, 3))
A[0, 0] = costh
A[0, 1] = sinth
A[1, 0] = -sinth
A[1, 1] = costh
A[2, 2] = 1
###Velocity transformation
Adot = np.zeros((3, 3))
Adot[0, 0] = -self.Omega * sinth
Adot[0, 1] = self.Omega * costh
Adot[1, 0] = -self.Omega * costh
Adot[1, 1] = -self.Omega * sinth
###Compute ECR state vector
newPos = np.dot(A, position)
newVel = np.dot(Adot, position) + np.dot(A, velocity)
####Create state vector object
newsv = StateVector()
newsv.setTime(svtime)
newsv.setPosition(newPos.tolist())
newsv.setVelocity(newVel.tolist())
###Append to orbit
ECROrbit.addStateVector(newsv)
ECROrbit.setOrbitSource('Sidereal angle conversion')
ECROrbit.setOrbitQuality(self.orbit.getOrbitQuality())
return ECROrbit
def convert(self):
'''Convert ECI orbit to ECEF orbit.'''
date = self.orbit._stateVectors[0].getTime().date()
bspName = 'inertial_orbit_' + date.strftime('%Y%m%d') + '.bsp'
####Convert ISCE orbit to SPICE orbit file
sorb = ISCEOrbit(self.orbit)
sorb.exportToSPK(bspName, frame=self.eci)
####Convert coordinates with corrections
spk = SpiceOrbit(bspName)
spk.initSpice()
wgsOrbit = Orbit()
wgsOrbit.setOrbitSource(self.orbit.getOrbitSource())
wgsOrbit.setOrbitQuality(self.orbit.getOrbitQuality())
for sv in self.orbit:
tim = sv.getTime()
spksv = spk.interpolateOrbit(tim, frame=self.ecef)
wgsOrbit.addStateVector(spksv)
return wgsOrbit
class PRC(object):
"""A class to parse orbit data from D-PAF"""
logging_name = "isce.orbit.PRC.PRC"
@logged
def __init__(self, file=None):
self.filename = file
self.firstEpoch = 0
self.lastEpoch = 0
self.tdtOffset = 0
self.orbit = Orbit()
self.orbit.configure()
self.orbit.setOrbitQuality('Precise')
self.orbit.setOrbitSource('PRC')
return None
def getOrbit(self):
return self.orbit
def parse(self):
#People still seem to be using the old .Z format
#Adding support for it - PSA
if os.path.splitext(self.filename)[1] == '.Z':
from subprocess import Popen, PIPE
fp = Popen(["zcat", self.filename], stdout=PIPE).stdout
else:
fp = open(self.filename, 'r')
data = fp.read()
fp.close()
numLines = int(len(data) / 130)
for i in range(numLines):
line = data[i * 130:(i + 1) * 130]
self.__parseLine(line)
def __parseLine(self, line):
"""Parse a line from a PRC orbit file"""
referenceFrame = line[0:6].decode('utf-8')
if (referenceFrame == 'STATE '):
self.__parseStateLine(line)
if (referenceFrame == 'STTERR'):
self.__parseTerrestrialLine(line)
def __parseTerrestrialLine(self, line):
j2000Day = float(line[14:20]) / 10.0 + 0.5
tdt = float(line[20:31]) / 1e6
x = float(line[31:43]) / 1e3
y = float(line[43:55]) / 1e3
z = float(line[55:67]) / 1e3
vx = float(line[67:78]) / 1e6
vy = float(line[78:89]) / 1e6
vz = float(line[89:100]) / 1e6
quality = line[127]
tdt = tdt - self.tdtOffset
dt = self.__j2000ToDatetime(j2000Day, tdt)
sv = StateVector()
sv.configure()
sv.setTime(dt)
sv.setPosition([x, y, z])
sv.setVelocity([vx, vy, vz])
self.orbit.addStateVector(sv)
def __parseStateLine(self, line):
self.firstEpoch = self.__j2000ToDatetime(float(line[6:12]) / 10.0, 0.0)
self.lastEpoch = self.__j2000ToDatetime(float(line[12:18]) / 10.0, 0.0)
self.tdtOffset = float(line[47:52])
self.tdtOffset = self.tdtOffset / 1e3
def __j2000ToDatetime(self, j2000Day, tdt):
"""Convert the number of days since 1 Jan. 2000 to a datetime object"""
j2000 = datetime.datetime(year=2000, month=1, day=1)
dt = j2000 + datetime.timedelta(days=j2000Day, seconds=tdt)
return dt
pass
