|
|
'''
|
|
|
|
|
|
$Author: murco $
|
|
|
$Id: JROHeaderIO.py 151 2012-10-31 19:00:51Z murco $
|
|
|
'''
|
|
|
import sys
|
|
|
import numpy
|
|
|
import copy
|
|
|
import datetime
|
|
|
|
|
|
|
|
|
SPEED_OF_LIGHT = 299792458
|
|
|
SPEED_OF_LIGHT = 3e8
|
|
|
|
|
|
FILE_STRUCTURE = numpy.dtype([ #HEADER 48bytes
|
|
|
('FileMgcNumber','<u4'), #0x23020100
|
|
|
('nFDTdataRecors','<u4'), #No Of FDT data records in this file (0 or more)
|
|
|
('RadarUnitId','<u4'),
|
|
|
('SiteName','<s32'), #Null terminated
|
|
|
])
|
|
|
|
|
|
RECORD_STRUCTURE = numpy.dtype([ #RECORD HEADER 180+20N bytes
|
|
|
('RecMgcNumber','<u4'), #0x23030001
|
|
|
('RecCounter','<u4'), #Record counter(0,1, ...)
|
|
|
('Off2StartNxtRec','<u4'), #Offset to start of next record form start of this record
|
|
|
('Off2StartData','<u4'), #Offset to start of data from start of this record
|
|
|
('EpTimeStamp','<i4'), #Epoch time stamp of start of acquisition (seconds)
|
|
|
('msCompTimeStamp','<u4'), #Millisecond component of time stamp (0,...,999)
|
|
|
('ExpTagName','<s32'), #Experiment tag name (null terminated)
|
|
|
('ExpComment','<s32'), #Experiment comment (null terminated)
|
|
|
('SiteLatDegrees','<f4'), #Site latitude (from GPS) in degrees (positive implies North)
|
|
|
('SiteLongDegrees','<f4'), #Site longitude (from GPS) in degrees (positive implies East)
|
|
|
('RTCgpsStatus','<u4'), #RTC GPS engine status (0=SEEK, 1=LOCK, 2=NOT FITTED, 3=UNAVAILABLE)
|
|
|
('TransmitFrec','<u4'), #Transmit frequency (Hz)
|
|
|
('ReceiveFrec','<u4'), #Receive frequency
|
|
|
('FirstOsciFrec','<u4'), #First local oscillator frequency (Hz)
|
|
|
('Polarisation','<u4'), #(0="O", 1="E", 2="linear 1", 3="linear2")
|
|
|
('ReceiverFiltSett','<u4'), #Receiver filter settings (0,1,2,3)
|
|
|
('nModesInUse','<u4'), #Number of modes in use (1 or 2)
|
|
|
('DualModeIndex','<u4'), #Dual Mode index number for these data (0 or 1)
|
|
|
('DualModeRange','<u4'), #Dual Mode range correction for these data (m)
|
|
|
('nDigChannels','<u4'), #Number of digital channels acquired (2*N)
|
|
|
('SampResolution','<u4'), #Sampling resolution (meters)
|
|
|
('nRangeGatesSamp','<u4'), #Number of range gates sampled
|
|
|
('StartRangeSamp','<u4'), #Start range of sampling (meters)
|
|
|
('PRFhz','<u4'), #PRF (Hz)
|
|
|
('Integrations','<u4'), #Integrations
|
|
|
('nDataPointsTrsf','<u4'), #Number of data points transformed
|
|
|
('nReceiveBeams','<u4'), #Number of receive beams stored in file (1 or N)
|
|
|
('nSpectAverages','<u4'), #Number of spectral averages
|
|
|
('FFTwindowingInd','<u4'), #FFT windowing index (0 = no window)
|
|
|
('BeamAngleAzim','<f4'), #Beam steer angle (azimuth) in degrees (clockwise from true North)
|
|
|
('BeamAngleZen','<f4'), #Beam steer angle (zenith) in degrees (0=> vertical)
|
|
|
('AntennaCoord','<f24'), #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
|
|
|
('RecPhaseCalibr','<f12'), #Receiver phase calibration (degrees) - N values
|
|
|
('RecAmpCalibr','<f12'), #Receiver amplitude calibration (ratio relative to receiver one) - N values
|
|
|
('ReceiverGaindB','<u12'), #Receiver gains in dB - N values
|
|
|
])
|
|
|
|
|
|
|
|
|
class Header(object):
|
|
|
|
|
|
def __init__(self):
|
|
|
raise NotImplementedError
|
|
|
|
|
|
|
|
|
def read(self):
|
|
|
|
|
|
raise NotImplementedError
|
|
|
|
|
|
def write(self):
|
|
|
|
|
|
raise NotImplementedError
|
|
|
|
|
|
def printInfo(self):
|
|
|
|
|
|
message = "#"*50 + "\n"
|
|
|
message += self.__class__.__name__.upper() + "\n"
|
|
|
message += "#"*50 + "\n"
|
|
|
|
|
|
keyList = list(self.__dict__.keys())
|
|
|
keyList.sort()
|
|
|
|
|
|
for key in keyList:
|
|
|
message += "%s = %s" %(key, self.__dict__[key]) + "\n"
|
|
|
|
|
|
if "size" not in keyList:
|
|
|
attr = getattr(self, "size")
|
|
|
|
|
|
if attr:
|
|
|
message += "%s = %s" %("size", attr) + "\n"
|
|
|
|
|
|
print(message)
|
|
|
|
|
|
class FileHeader(Header):
|
|
|
|
|
|
FileMgcNumber= None
|
|
|
nFDTdataRecors=None #No Of FDT data records in this file (0 or more)
|
|
|
RadarUnitId= None
|
|
|
SiteName= None
|
|
|
|
|
|
#__LOCALTIME = None
|
|
|
|
|
|
def __init__(self, useLocalTime=True):
|
|
|
|
|
|
self.FileMgcNumber= 0 #0x23020100
|
|
|
self.nFDTdataRecors=0 #No Of FDT data records in this file (0 or more)
|
|
|
self.RadarUnitId= 0
|
|
|
self.SiteName= ""
|
|
|
self.size = 48
|
|
|
|
|
|
#self.useLocalTime = useLocalTime
|
|
|
|
|
|
def read(self, fp):
|
|
|
|
|
|
try:
|
|
|
header = numpy.fromfile(fp, FILE_STRUCTURE,1)
|
|
|
''' numpy.fromfile(file, dtype, count, sep='')
|
|
|
file : file or str
|
|
|
Open file object or filename.
|
|
|
|
|
|
dtype : data-type
|
|
|
Data type of the returned array. For binary files, it is used to determine
|
|
|
the size and byte-order of the items in the file.
|
|
|
|
|
|
count : int
|
|
|
Number of items to read. -1 means all items (i.e., the complete file).
|
|
|
|
|
|
sep : str
|
|
|
Separator between items if file is a text file. Empty (“”) separator means
|
|
|
the file should be treated as binary. Spaces (” ”) in the separator match zero
|
|
|
or more whitespace characters. A separator consisting only of spaces must match
|
|
|
at least one whitespace.
|
|
|
|
|
|
'''
|
|
|
|
|
|
except Exception as e:
|
|
|
print("FileHeader: ")
|
|
|
print(eBasicHeader)
|
|
|
return 0
|
|
|
|
|
|
self.FileMgcNumber= byte(header['FileMgcNumber'][0])
|
|
|
self.nFDTdataRecors=int(header['nFDTdataRecors'][0]) #No Of FDT data records in this file (0 or more)
|
|
|
self.RadarUnitId= int(header['RadarUnitId'][0])
|
|
|
self.SiteName= char(header['SiteName'][0])
|
|
|
|
|
|
|
|
|
if self.size <48:
|
|
|
return 0
|
|
|
|
|
|
return 1
|
|
|
|
|
|
def write(self, fp):
|
|
|
|
|
|
headerTuple = (self.FileMgcNumber,
|
|
|
self.nFDTdataRecors,
|
|
|
self.RadarUnitId,
|
|
|
self.SiteName,
|
|
|
self.size)
|
|
|
|
|
|
|
|
|
header = numpy.array(headerTuple, FILE_STRUCTURE)
|
|
|
# numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
|
|
|
header.tofile(fp)
|
|
|
''' ndarray.tofile(fid, sep, format) Write array to a file as text or binary (default).
|
|
|
|
|
|
fid : file or str
|
|
|
An open file object, or a string containing a filename.
|
|
|
|
|
|
sep : str
|
|
|
Separator between array items for text output. If “” (empty), a binary file is written,
|
|
|
equivalent to file.write(a.tobytes()).
|
|
|
|
|
|
format : str
|
|
|
Format string for text file output. Each entry in the array is formatted to text by
|
|
|
first converting it to the closest Python type, and then using “format” % item.
|
|
|
|
|
|
'''
|
|
|
|
|
|
return 1
|
|
|
|
|
|
|
|
|
class RecordHeader(Header):
|
|
|
|
|
|
RecMgcNumber=None #0x23030001
|
|
|
RecCounter= None
|
|
|
Off2StartNxtRec= None
|
|
|
EpTimeStamp= None
|
|
|
msCompTimeStamp= None
|
|
|
ExpTagName= None
|
|
|
ExpComment=None
|
|
|
SiteLatDegrees=None
|
|
|
SiteLongDegrees= None
|
|
|
RTCgpsStatus= None
|
|
|
TransmitFrec= None
|
|
|
ReceiveFrec= None
|
|
|
FirstOsciFrec= None
|
|
|
Polarisation= None
|
|
|
ReceiverFiltSett= None
|
|
|
nModesInUse= None
|
|
|
DualModeIndex= None
|
|
|
DualModeRange= None
|
|
|
nDigChannels= None
|
|
|
SampResolution= None
|
|
|
nRangeGatesSamp= None
|
|
|
StartRangeSamp= None
|
|
|
PRFhz= None
|
|
|
Integrations= None
|
|
|
nDataPointsTrsf= None
|
|
|
nReceiveBeams= None
|
|
|
nSpectAverages= None
|
|
|
FFTwindowingInd= None
|
|
|
BeamAngleAzim= None
|
|
|
BeamAngleZen= None
|
|
|
AntennaCoord= None
|
|
|
RecPhaseCalibr= None
|
|
|
RecAmpCalibr= None
|
|
|
ReceiverGaindB= None
|
|
|
|
|
|
'''size = None
|
|
|
nSamples = None
|
|
|
nProfiles = None
|
|
|
nChannels = None
|
|
|
adcResolution = None
|
|
|
pciDioBusWidth = None'''
|
|
|
|
|
|
def __init__(self, RecMgcNumber=None, RecCounter= 0, Off2StartNxtRec= 0,
|
|
|
EpTimeStamp= 0, msCompTimeStamp= 0, ExpTagName= None,
|
|
|
ExpComment=None, SiteLatDegrees=0, SiteLongDegrees= 0,
|
|
|
RTCgpsStatus= 0, TransmitFrec= 0, ReceiveFrec= 0,
|
|
|
FirstOsciFrec= 0, Polarisation= 0, ReceiverFiltSett= 0,
|
|
|
nModesInUse= 0, DualModeIndex= 0, DualModeRange= 0,
|
|
|
nDigChannels= 0, SampResolution= 0, nRangeGatesSamp= 0,
|
|
|
StartRangeSamp= 0, PRFhz= 0, Integrations= 0,
|
|
|
nDataPointsTrsf= 0, nReceiveBeams= 0, nSpectAverages= 0,
|
|
|
FFTwindowingInd= 0, BeamAngleAzim= 0, BeamAngleZen= 0,
|
|
|
AntennaCoord= 0, RecPhaseCalibr= 0, RecAmpCalibr= 0,
|
|
|
ReceiverGaindB= 0):
|
|
|
|
|
|
self.RecMgcNumber = RecMgcNumber #0x23030001
|
|
|
self.RecCounter = RecCounter
|
|
|
self.Off2StartNxtRec = Off2StartNxtRec
|
|
|
self.EpTimeStamp = EpTimeStamp
|
|
|
self.msCompTimeStamp = msCompTimeStamp
|
|
|
self.ExpTagName = ExpTagName
|
|
|
self.ExpComment = ExpComment
|
|
|
self.SiteLatDegrees = SiteLatDegrees
|
|
|
self.SiteLongDegrees = SiteLongDegrees
|
|
|
self.RTCgpsStatus = RTCgpsStatus
|
|
|
self.TransmitFrec = TransmitFrec
|
|
|
self.ReceiveFrec = ReceiveFrec
|
|
|
self.FirstOsciFrec = FirstOsciFrec
|
|
|
self.Polarisation = Polarisation
|
|
|
self.ReceiverFiltSett = ReceiverFiltSett
|
|
|
self.nModesInUse = nModesInUse
|
|
|
self.DualModeIndex = DualModeIndex
|
|
|
self.DualModeRange = DualModeRange
|
|
|
self.nDigChannels = nDigChannels
|
|
|
self.SampResolution = SampResolution
|
|
|
self.nRangeGatesSamp = nRangeGatesSamp
|
|
|
self.StartRangeSamp = StartRangeSamp
|
|
|
self.PRFhz = PRFhz
|
|
|
self.Integrations = Integrations
|
|
|
self.nDataPointsTrsf = nDataPointsTrsf
|
|
|
self.nReceiveBeams = nReceiveBeams
|
|
|
self.nSpectAverages = nSpectAverages
|
|
|
self.FFTwindowingInd = FFTwindowingInd
|
|
|
self.BeamAngleAzim = BeamAngleAzim
|
|
|
self.BeamAngleZen = BeamAngleZen
|
|
|
self.AntennaCoord = AntennaCoord
|
|
|
self.RecPhaseCalibr = RecPhaseCalibr
|
|
|
self.RecAmpCalibr = RecAmpCalibr
|
|
|
self.ReceiverGaindB = ReceiverGaindB
|
|
|
|
|
|
|
|
|
def read(self, fp):
|
|
|
|
|
|
startFp = fp.tell() #The method tell() returns the current position of the file read/write pointer within the file.
|
|
|
|
|
|
try:
|
|
|
header = numpy.fromfile(fp,RECORD_STRUCTURE,1)
|
|
|
except Exception as e:
|
|
|
print("System Header: " + e)
|
|
|
return 0
|
|
|
|
|
|
self.RecMgcNumber = header['RecMgcNumber'][0] #0x23030001
|
|
|
self.RecCounter = header['RecCounter'][0]
|
|
|
self.Off2StartNxtRec = header['Off2StartNxtRec'][0]
|
|
|
self.EpTimeStamp = header['EpTimeStamp'][0]
|
|
|
self.msCompTimeStamp = header['msCompTimeStamp'][0]
|
|
|
self.ExpTagName = header['ExpTagName'][0]
|
|
|
self.ExpComment = header['ExpComment'][0]
|
|
|
self.SiteLatDegrees = header['SiteLatDegrees'][0]
|
|
|
self.SiteLongDegrees = header['SiteLongDegrees'][0]
|
|
|
self.RTCgpsStatus = header['RTCgpsStatus'][0]
|
|
|
self.TransmitFrec = header['TransmitFrec'][0]
|
|
|
self.ReceiveFrec = header['ReceiveFrec'][0]
|
|
|
self.FirstOsciFrec = header['FirstOsciFrec'][0]
|
|
|
self.Polarisation = header['Polarisation'][0]
|
|
|
self.ReceiverFiltSett = header['ReceiverFiltSett'][0]
|
|
|
self.nModesInUse = header['nModesInUse'][0]
|
|
|
self.DualModeIndex = header['DualModeIndex'][0]
|
|
|
self.DualModeRange = header['DualModeRange'][0]
|
|
|
self.nDigChannels = header['nDigChannels'][0]
|
|
|
self.SampResolution = header['SampResolution'][0]
|
|
|
self.nRangeGatesSamp = header['nRangeGatesSamp'][0]
|
|
|
self.StartRangeSamp = header['StartRangeSamp'][0]
|
|
|
self.PRFhz = header['PRFhz'][0]
|
|
|
self.Integrations = header['Integrations'][0]
|
|
|
self.nDataPointsTrsf = header['nDataPointsTrsf'][0]
|
|
|
self.nReceiveBeams = header['nReceiveBeams'][0]
|
|
|
self.nSpectAverages = header['nSpectAverages'][0]
|
|
|
self.FFTwindowingInd = header['FFTwindowingInd'][0]
|
|
|
self.BeamAngleAzim = header['BeamAngleAzim'][0]
|
|
|
self.BeamAngleZen = header['BeamAngleZen'][0]
|
|
|
self.AntennaCoord = header['AntennaCoord'][0]
|
|
|
self.RecPhaseCalibr = header['RecPhaseCalibr'][0]
|
|
|
self.RecAmpCalibr = header['RecAmpCalibr'][0]
|
|
|
self.ReceiverGaindB = header['ReceiverGaindB'][0]
|
|
|
|
|
|
Self.size = 180+20*3
|
|
|
|
|
|
endFp = self.size + startFp
|
|
|
|
|
|
if fp.tell() > endFp:
|
|
|
sys.stderr.write("Warning %s: Size value read from System Header is lower than it has to be\n" %fp.name)
|
|
|
return 0
|
|
|
|
|
|
if fp.tell() < endFp:
|
|
|
sys.stderr.write("Warning %s: Size value read from System Header size is greater than it has to be\n" %fp.name)
|
|
|
return 0
|
|
|
|
|
|
return 1
|
|
|
|
|
|
def write(self, fp):
|
|
|
|
|
|
headerTuple = (self.RecMgcNumber,
|
|
|
self.RecCounter,
|
|
|
self.Off2StartNxtRec,
|
|
|
self.EpTimeStamp,
|
|
|
self.msCompTimeStamp,
|
|
|
self.ExpTagName,
|
|
|
self.ExpComment,
|
|
|
self.SiteLatDegrees,
|
|
|
self.SiteLongDegrees,
|
|
|
self.RTCgpsStatus,
|
|
|
self.TransmitFrec,
|
|
|
self.ReceiveFrec,
|
|
|
self.FirstOsciFrec,
|
|
|
self.Polarisation,
|
|
|
self.ReceiverFiltSett,
|
|
|
self.nModesInUse,
|
|
|
self.DualModeIndex,
|
|
|
self.DualModeRange,
|
|
|
self.nDigChannels,
|
|
|
self.SampResolution,
|
|
|
self.nRangeGatesSamp,
|
|
|
self.StartRangeSamp,
|
|
|
self.PRFhz,
|
|
|
self.Integrations,
|
|
|
self.nDataPointsTrsf,
|
|
|
self.nReceiveBeams,
|
|
|
self.nSpectAverages,
|
|
|
self.FFTwindowingInd,
|
|
|
self.BeamAngleAzim,
|
|
|
self.BeamAngleZen,
|
|
|
self.AntennaCoord,
|
|
|
self.RecPhaseCalibr,
|
|
|
self.RecAmpCalibr,
|
|
|
self.ReceiverGaindB)
|
|
|
|
|
|
# self.size,self.nSamples,
|
|
|
# self.nProfiles,
|
|
|
# self.nChannels,
|
|
|
# self.adcResolution,
|
|
|
# self.pciDioBusWidth
|
|
|
|
|
|
header = numpy.array(headerTuple,RECORD_STRUCTURE)
|
|
|
header.tofile(fp)
|
|
|
|
|
|
return 1
|
|
|
|
|
|
|
|
|
def get_dtype_index(numpy_dtype):
|
|
|
|
|
|
index = None
|
|
|
|
|
|
for i in range(len(NUMPY_DTYPE_LIST)):
|
|
|
if numpy_dtype == NUMPY_DTYPE_LIST[i]:
|
|
|
index = i
|
|
|
break
|
|
|
|
|
|
return index
|
|
|
|
|
|
def get_numpy_dtype(index):
|
|
|
|
|
|
#dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
|
|
|
|
|
|
return NUMPY_DTYPE_LIST[index]
|
|
|
|
|
|
|
|
|
def get_dtype_width(index):
|
|
|
|
|
|
return DTYPE_WIDTH[index]
|
