jroheaderIO.py
906 lines
| 28.5 KiB
| text/x-python
|
PythonLexer
|
r487 | ''' | |
$Author: murco $ | |||
$Id: JROHeaderIO.py 151 2012-10-31 19:00:51Z murco $ | |||
''' | |||
|
r798 | import sys | |
|
r487 | import numpy | |
import copy | |||
import datetime | |||
|
r980 | import inspect | |
|
r1167 | from schainpy.utils import log | |
|
r487 | ||
|
r616 | SPEED_OF_LIGHT = 299792458 | |
SPEED_OF_LIGHT = 3e8 | |||
|
r487 | BASIC_STRUCTURE = numpy.dtype([ | |
|
r1120 | ('nSize', '<u4'), | |
('nVersion', '<u2'), | |||
('nDataBlockId', '<u4'), | |||
('nUtime', '<u4'), | |||
('nMilsec', '<u2'), | |||
('nTimezone', '<i2'), | |||
('nDstflag', '<i2'), | |||
('nErrorCount', '<u4') | |||
]) | |||
|
r487 | ||
SYSTEM_STRUCTURE = numpy.dtype([ | |||
|
r1120 | ('nSize', '<u4'), | |
('nNumSamples', '<u4'), | |||
('nNumProfiles', '<u4'), | |||
('nNumChannels', '<u4'), | |||
('nADCResolution', '<u4'), | |||
('nPCDIOBusWidth', '<u4'), | |||
]) | |||
|
r487 | ||
RADAR_STRUCTURE = numpy.dtype([ | |||
|
r1120 | ('nSize', '<u4'), | |
('nExpType', '<u4'), | |||
('nNTx', '<u4'), | |||
('fIpp', '<f4'), | |||
('fTxA', '<f4'), | |||
('fTxB', '<f4'), | |||
('nNumWindows', '<u4'), | |||
('nNumTaus', '<u4'), | |||
('nCodeType', '<u4'), | |||
('nLine6Function', '<u4'), | |||
('nLine5Function', '<u4'), | |||
('fClock', '<f4'), | |||
('nPrePulseBefore', '<u4'), | |||
('nPrePulseAfter', '<u4'), | |||
('sRangeIPP', '<a20'), | |||
('sRangeTxA', '<a20'), | |||
('sRangeTxB', '<a20'), | |||
]) | |||
SAMPLING_STRUCTURE = numpy.dtype( | |||
[('h0', '<f4'), ('dh', '<f4'), ('nsa', '<u4')]) | |||
|
r487 | ||
PROCESSING_STRUCTURE = numpy.dtype([ | |||
|
r1120 | ('nSize', '<u4'), | |
('nDataType', '<u4'), | |||
('nSizeOfDataBlock', '<u4'), | |||
('nProfilesperBlock', '<u4'), | |||
('nDataBlocksperFile', '<u4'), | |||
('nNumWindows', '<u4'), | |||
('nProcessFlags', '<u4'), | |||
('nCoherentIntegrations', '<u4'), | |||
('nIncoherentIntegrations', '<u4'), | |||
('nTotalSpectra', '<u4') | |||
]) | |||
|
r487 | ||
class Header(object): | |||
|
r1120 | ||
|
r487 | def __init__(self): | |
|
r684 | raise NotImplementedError | |
|
r1120 | ||
|
r487 | def copy(self): | |
return copy.deepcopy(self) | |||
|
r1120 | ||
|
r487 | def read(self): | |
|
r1120 | ||
|
r684 | raise NotImplementedError | |
|
r1120 | ||
|
r487 | def write(self): | |
|
r1120 | ||
|
r684 | raise NotImplementedError | |
|
r980 | ||
def getAllowedArgs(self): | |||
|
r981 | args = inspect.getargspec(self.__init__).args | |
try: | |||
args.remove('self') | |||
except: | |||
pass | |||
return args | |||
def getAsDict(self): | |||
args = self.getAllowedArgs() | |||
asDict = {} | |||
for x in args: | |||
asDict[x] = self[x] | |||
return asDict | |||
|
r1120 | ||
|
r981 | def __getitem__(self, name): | |
return getattr(self, name) | |||
|
r487 | def printInfo(self): | |
|
r1120 | ||
message = "#" * 50 + "\n" | |||
|
r672 | message += self.__class__.__name__.upper() + "\n" | |
|
r1120 | message += "#" * 50 + "\n" | |
|
r1167 | keyList = list(self.__dict__.keys()) | |
|
r728 | keyList.sort() | |
|
r1120 | ||
|
r728 | for key in keyList: | |
|
r1120 | message += "%s = %s" % (key, self.__dict__[key]) + "\n" | |
|
r728 | if "size" not in keyList: | |
attr = getattr(self, "size") | |||
|
r1120 | ||
|
r728 | if attr: | |
|
r1120 | message += "%s = %s" % ("size", attr) + "\n" | |
|
r1167 | print(message) | |
|
r568 | ||
|
r1120 | ||
|
r487 | class BasicHeader(Header): | |
|
r1120 | ||
|
r487 | size = None | |
version = None | |||
dataBlock = None | |||
utc = None | |||
ltc = None | |||
miliSecond = None | |||
timeZone = None | |||
dstFlag = None | |||
errorCount = None | |||
datatime = None | |||
|
r980 | structure = BASIC_STRUCTURE | |
|
r487 | __LOCALTIME = None | |
|
r1120 | ||
|
r487 | def __init__(self, useLocalTime=True): | |
|
r1120 | ||
|
r487 | self.size = 24 | |
self.version = 0 | |||
self.dataBlock = 0 | |||
self.utc = 0 | |||
self.miliSecond = 0 | |||
self.timeZone = 0 | |||
self.dstFlag = 0 | |||
self.errorCount = 0 | |||
|
r1120 | ||
|
r487 | self.useLocalTime = useLocalTime | |
|
r1120 | ||
|
r487 | def read(self, fp): | |
|
r1120 | ||
|
r975 | self.length = 0 | |
|
r487 | try: | |
|
r963 | if hasattr(fp, 'read'): | |
|
r1120 | header = numpy.fromfile(fp, BASIC_STRUCTURE, 1) | |
|
r963 | else: | |
|
r1120 | header = numpy.fromstring(fp, BASIC_STRUCTURE, 1) | |
|
r1167 | except Exception as e: | |
print("BasicHeader: ") | |||
print(e) | |||
|
r487 | return 0 | |
|
r975 | ||
|
r684 | self.size = int(header['nSize'][0]) | |
self.version = int(header['nVersion'][0]) | |||
self.dataBlock = int(header['nDataBlockId'][0]) | |||
self.utc = int(header['nUtime'][0]) | |||
self.miliSecond = int(header['nMilsec'][0]) | |||
self.timeZone = int(header['nTimezone'][0]) | |||
self.dstFlag = int(header['nDstflag'][0]) | |||
self.errorCount = int(header['nErrorCount'][0]) | |||
|
r1120 | ||
|
r803 | if self.size < 24: | |
return 0 | |||
|
r975 | ||
self.length = header.nbytes | |||
|
r487 | return 1 | |
|
r1120 | ||
|
r487 | def write(self, fp): | |
|
r1120 | ||
headerTuple = (self.size, self.version, self.dataBlock, self.utc, | |||
self.miliSecond, self.timeZone, self.dstFlag, self.errorCount) | |||
header = numpy.array(headerTuple, BASIC_STRUCTURE) | |||
|
r487 | header.tofile(fp) | |
|
r1120 | ||
|
r487 | return 1 | |
|
r1120 | ||
|
r487 | def get_ltc(self): | |
|
r1120 | ||
return self.utc - self.timeZone * 60 | |||
|
r487 | def set_ltc(self, value): | |
|
r1120 | ||
self.utc = value + self.timeZone * 60 | |||
|
r487 | def get_datatime(self): | |
|
r1120 | ||
|
r487 | return datetime.datetime.utcfromtimestamp(self.ltc) | |
|
r1120 | ||
|
r487 | ltc = property(get_ltc, set_ltc) | |
datatime = property(get_datatime) | |||
|
r1120 | ||
|
r487 | class SystemHeader(Header): | |
|
r1120 | ||
|
r487 | size = None | |
nSamples = None | |||
nProfiles = None | |||
nChannels = None | |||
adcResolution = None | |||
pciDioBusWidth = None | |||
|
r980 | structure = SYSTEM_STRUCTURE | |
|
r981 | def __init__(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=0): | |
|
r1120 | ||
self.size = 24 | |||
|
r568 | self.nSamples = nSamples | |
self.nProfiles = nProfiles | |||
self.nChannels = nChannels | |||
self.adcResolution = adcResolution | |||
|
r981 | self.pciDioBusWidth = pciDioBusWidth | |
|
r980 | ||
|
r487 | def read(self, fp): | |
|
r975 | self.length = 0 | |
|
r487 | try: | |
|
r975 | startFp = fp.tell() | |
|
r1167 | except Exception as e: | |
|
r975 | startFp = None | |
pass | |||
try: | |||
if hasattr(fp, 'read'): | |||
|
r1120 | header = numpy.fromfile(fp, SYSTEM_STRUCTURE, 1) | |
|
r975 | else: | |
|
r1120 | header = numpy.fromstring(fp, SYSTEM_STRUCTURE, 1) | |
|
r1167 | except Exception as e: | |
print("System Header: " + str(e)) | |||
|
r487 | return 0 | |
|
r1120 | ||
|
r684 | self.size = header['nSize'][0] | |
self.nSamples = header['nNumSamples'][0] | |||
self.nProfiles = header['nNumProfiles'][0] | |||
self.nChannels = header['nNumChannels'][0] | |||
self.adcResolution = header['nADCResolution'][0] | |||
self.pciDioBusWidth = header['nPCDIOBusWidth'][0] | |||
|
r1120 | ||
|
r975 | if startFp is not None: | |
endFp = self.size + startFp | |||
|
r1120 | ||
|
r975 | if fp.tell() > endFp: | |
|
r1120 | sys.stderr.write( | |
"Warning %s: Size value read from System Header is lower than it has to be\n" % fp.name) | |||
|
r975 | return 0 | |
|
r1120 | ||
|
r975 | if fp.tell() < endFp: | |
|
r1120 | sys.stderr.write( | |
"Warning %s: Size value read from System Header size is greater than it has to be\n" % fp.name) | |||
|
r975 | return 0 | |
|
r1120 | ||
|
r975 | self.length = header.nbytes | |
|
r487 | return 1 | |
|
r1120 | ||
|
r487 | def write(self, fp): | |
|
r1120 | ||
headerTuple = (self.size, self.nSamples, self.nProfiles, | |||
self.nChannels, self.adcResolution, self.pciDioBusWidth) | |||
header = numpy.array(headerTuple, SYSTEM_STRUCTURE) | |||
|
r487 | header.tofile(fp) | |
|
r1120 | ||
|
r487 | return 1 | |
|
r1120 | ||
|
r487 | class RadarControllerHeader(Header): | |
|
r1120 | ||
|
r487 | expType = None | |
nTx = None | |||
ipp = None | |||
txA = None | |||
txB = None | |||
nWindows = None | |||
numTaus = None | |||
codeType = None | |||
line6Function = None | |||
line5Function = None | |||
fClock = None | |||
prePulseBefore = None | |||
|
r981 | prePulseAfter = None | |
|
r487 | rangeIpp = None | |
rangeTxA = None | |||
rangeTxB = None | |||
|
r980 | structure = RADAR_STRUCTURE | |
|
r616 | __size = None | |
|
r1120 | ||
|
r568 | def __init__(self, expType=2, nTx=1, | |
|
r981 | ipp=None, txA=0, txB=0, | |
|
r568 | nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None, | |
|
r616 | numTaus=0, line6Function=0, line5Function=0, fClock=None, | |
|
r568 | prePulseBefore=0, prePulseAfter=0, | |
codeType=0, nCode=0, nBaud=0, code=None, | |||
flip1=0, flip2=0): | |||
|
r1120 | ||
# self.size = 116 | |||
|
r568 | self.expType = expType | |
self.nTx = nTx | |||
|
r981 | self.ipp = ipp | |
|
r568 | self.txA = txA | |
self.txB = txB | |||
|
r981 | self.rangeIpp = ipp | |
|
r568 | self.rangeTxA = txA | |
self.rangeTxB = txB | |||
|
r1120 | ||
|
r568 | self.nWindows = nWindows | |
self.numTaus = numTaus | |||
self.codeType = codeType | |||
self.line6Function = line6Function | |||
self.line5Function = line5Function | |||
self.fClock = fClock | |||
self.prePulseBefore = prePulseBefore | |||
|
r981 | self.prePulseAfter = prePulseAfter | |
|
r1120 | ||
|
r568 | self.nHeights = nHeights | |
self.firstHeight = firstHeight | |||
self.deltaHeight = deltaHeight | |||
self.samplesWin = nHeights | |||
|
r1120 | ||
|
r568 | self.nCode = nCode | |
self.nBaud = nBaud | |||
self.code = code | |||
self.flip1 = flip1 | |||
self.flip2 = flip2 | |||
|
r1120 | ||
self.code_size = int(numpy.ceil(self.nBaud / 32.)) * self.nCode * 4 | |||
|
r487 | # self.dynamic = numpy.array([],numpy.dtype('byte')) | |
|
r1120 | ||
|
r616 | if self.fClock is None and self.deltaHeight is not None: | |
|
r1120 | self.fClock = 0.15 / (deltaHeight * 1e-6) # 0.15Km / (height * 1u) | |
|
r487 | ||
def read(self, fp): | |||
|
r975 | self.length = 0 | |
|
r684 | try: | |
|
r975 | startFp = fp.tell() | |
|
r1167 | except Exception as e: | |
|
r975 | startFp = None | |
pass | |||
try: | |||
if hasattr(fp, 'read'): | |||
|
r1120 | header = numpy.fromfile(fp, RADAR_STRUCTURE, 1) | |
|
r975 | else: | |
|
r1120 | header = numpy.fromstring(fp, RADAR_STRUCTURE, 1) | |
|
r975 | self.length += header.nbytes | |
|
r1167 | except Exception as e: | |
print("RadarControllerHeader: " + str(e)) | |||
|
r684 | return 0 | |
|
r1120 | ||
|
r624 | size = int(header['nSize'][0]) | |
self.expType = int(header['nExpType'][0]) | |||
self.nTx = int(header['nNTx'][0]) | |||
self.ipp = float(header['fIpp'][0]) | |||
self.txA = float(header['fTxA'][0]) | |||
self.txB = float(header['fTxB'][0]) | |||
self.nWindows = int(header['nNumWindows'][0]) | |||
self.numTaus = int(header['nNumTaus'][0]) | |||
self.codeType = int(header['nCodeType'][0]) | |||
self.line6Function = int(header['nLine6Function'][0]) | |||
self.line5Function = int(header['nLine5Function'][0]) | |||
self.fClock = float(header['fClock'][0]) | |||
self.prePulseBefore = int(header['nPrePulseBefore'][0]) | |||
|
r981 | self.prePulseAfter = int(header['nPrePulseAfter'][0]) | |
|
r624 | self.rangeIpp = header['sRangeIPP'][0] | |
self.rangeTxA = header['sRangeTxA'][0] | |||
self.rangeTxB = header['sRangeTxB'][0] | |||
|
r1120 | ||
|
r975 | try: | |
if hasattr(fp, 'read'): | |||
|
r1120 | samplingWindow = numpy.fromfile( | |
fp, SAMPLING_STRUCTURE, self.nWindows) | |||
|
r975 | else: | |
|
r1120 | samplingWindow = numpy.fromstring( | |
fp[self.length:], SAMPLING_STRUCTURE, self.nWindows) | |||
|
r975 | self.length += samplingWindow.nbytes | |
|
r1167 | except Exception as e: | |
print("RadarControllerHeader: " + str(e)) | |||
|
r975 | return 0 | |
|
r624 | self.nHeights = int(numpy.sum(samplingWindow['nsa'])) | |
self.firstHeight = samplingWindow['h0'] | |||
self.deltaHeight = samplingWindow['dh'] | |||
self.samplesWin = samplingWindow['nsa'] | |||
|
r975 | ||
try: | |||
if hasattr(fp, 'read'): | |||
self.Taus = numpy.fromfile(fp, '<f4', self.numTaus) | |||
else: | |||
|
r1120 | self.Taus = numpy.fromstring( | |
fp[self.length:], '<f4', self.numTaus) | |||
|
r975 | self.length += self.Taus.nbytes | |
|
r1167 | except Exception as e: | |
print("RadarControllerHeader: " + str(e)) | |||
|
r975 | return 0 | |
|
r1120 | ||
|
r624 | self.code_size = 0 | |
if self.codeType != 0: | |||
|
r1120 | ||
|
r975 | try: | |
if hasattr(fp, 'read'): | |||
|
r992 | self.nCode = numpy.fromfile(fp, '<u4', 1)[0] | |
|
r975 | self.length += self.nCode.nbytes | |
|
r992 | self.nBaud = numpy.fromfile(fp, '<u4', 1)[0] | |
|
r975 | self.length += self.nBaud.nbytes | |
else: | |||
|
r1120 | self.nCode = numpy.fromstring( | |
fp[self.length:], '<u4', 1)[0] | |||
|
r975 | self.length += self.nCode.nbytes | |
|
r1120 | self.nBaud = numpy.fromstring( | |
fp[self.length:], '<u4', 1)[0] | |||
|
r975 | self.length += self.nBaud.nbytes | |
|
r1167 | except Exception as e: | |
print("RadarControllerHeader: " + str(e)) | |||
|
r1120 | return 0 | |
code = numpy.empty([self.nCode, self.nBaud], dtype='i1') | |||
|
r624 | for ic in range(self.nCode): | |
|
r975 | try: | |
if hasattr(fp, 'read'): | |||
|
r1120 | temp = numpy.fromfile(fp, 'u4', int( | |
numpy.ceil(self.nBaud / 32.))) | |||
|
r975 | else: | |
|
r1120 | temp = numpy.fromstring( | |
fp, 'u4', int(numpy.ceil(self.nBaud / 32.))) | |||
|
r975 | self.length += temp.nbytes | |
|
r1167 | except Exception as e: | |
print("RadarControllerHeader: " + str(e)) | |||
|
r975 | return 0 | |
|
r1120 | for ib in range(self.nBaud - 1, -1, -1): | |
|
r1167 | log.error(ib / 32) | |
code[ic, ib] = temp[int(ib / 32)] % 2 | |||
temp[int(ib / 32)] = temp[int(ib / 32)] / 2 | |||
|
r1120 | ||
self.code = 2.0 * code - 1.0 | |||
self.code_size = int(numpy.ceil(self.nBaud / 32.)) * self.nCode * 4 | |||
|
r616 | # if self.line5Function == RCfunction.FLIP: | |
# self.flip1 = numpy.fromfile(fp,'<u4',1) | |||
|
r1120 | # | |
|
r616 | # if self.line6Function == RCfunction.FLIP: | |
# self.flip2 = numpy.fromfile(fp,'<u4',1) | |||
|
r975 | if startFp is not None: | |
endFp = size + startFp | |||
|
r1120 | ||
|
r975 | if fp.tell() != endFp: | |
|
r1120 | # fp.seek(endFp) | |
|
r1167 | print("%s: Radar Controller Header size is not consistent: from data [%d] != from header field [%d]" % (fp.name, fp.tell() - startFp, size)) | |
|
r975 | # return 0 | |
if fp.tell() > endFp: | |||
|
r1120 | sys.stderr.write( | |
"Warning %s: Size value read from Radar Controller header is lower than it has to be\n" % fp.name) | |||
|
r975 | # return 0 | |
|
r1120 | ||
|
r975 | if fp.tell() < endFp: | |
|
r1120 | sys.stderr.write( | |
"Warning %s: Size value read from Radar Controller header is greater than it has to be\n" % fp.name) | |||
|
r487 | return 1 | |
|
r1120 | ||
|
r487 | def write(self, fp): | |
|
r1120 | ||
|
r487 | headerTuple = (self.size, | |
self.expType, | |||
self.nTx, | |||
self.ipp, | |||
self.txA, | |||
self.txB, | |||
self.nWindows, | |||
self.numTaus, | |||
self.codeType, | |||
self.line6Function, | |||
self.line5Function, | |||
self.fClock, | |||
self.prePulseBefore, | |||
|
r981 | self.prePulseAfter, | |
|
r487 | self.rangeIpp, | |
self.rangeTxA, | |||
self.rangeTxB) | |||
|
r1120 | ||
header = numpy.array(headerTuple, RADAR_STRUCTURE) | |||
|
r487 | header.tofile(fp) | |
|
r1120 | ||
sampleWindowTuple = ( | |||
self.firstHeight, self.deltaHeight, self.samplesWin) | |||
samplingWindow = numpy.array(sampleWindowTuple, SAMPLING_STRUCTURE) | |||
|
r487 | samplingWindow.tofile(fp) | |
|
r1120 | ||
|
r487 | if self.numTaus > 0: | |
self.Taus.tofile(fp) | |||
|
r1120 | ||
if self.codeType != 0: | |||
|
r556 | nCode = numpy.array(self.nCode, '<u4') | |
nCode.tofile(fp) | |||
nBaud = numpy.array(self.nBaud, '<u4') | |||
nBaud.tofile(fp) | |||
|
r1120 | code1 = (self.code + 1.0) / 2. | |
|
r556 | for ic in range(self.nCode): | |
|
r1125 | tempx = numpy.zeros(int(numpy.ceil(self.nBaud / 32.))) | |
|
r556 | start = 0 | |
end = 32 | |||
for i in range(len(tempx)): | |||
|
r1120 | code_selected = code1[ic, start:end] | |
for j in range(len(code_selected) - 1, -1, -1): | |||
|
r556 | if code_selected[j] == 1: | |
|
r1120 | tempx[i] = tempx[i] + \ | |
2**(len(code_selected) - 1 - j) | |||
|
r556 | start = start + 32 | |
end = end + 32 | |||
|
r1120 | ||
|
r556 | tempx = tempx.astype('u4') | |
tempx.tofile(fp) | |||
|
r1120 | ||
|
r616 | # if self.line5Function == RCfunction.FLIP: | |
# self.flip1.tofile(fp) | |||
|
r1120 | # | |
|
r616 | # if self.line6Function == RCfunction.FLIP: | |
# self.flip2.tofile(fp) | |||
|
r1120 | ||
|
r487 | return 1 | |
def get_ippSeconds(self): | |||
''' | |||
''' | |||
|
r616 | ippSeconds = 2.0 * 1000 * self.ipp / SPEED_OF_LIGHT | |
|
r1120 | ||
|
r487 | return ippSeconds | |
|
r1120 | ||
|
r487 | def set_ippSeconds(self, ippSeconds): | |
''' | |||
''' | |||
|
r1120 | ||
self.ipp = ippSeconds * SPEED_OF_LIGHT / (2.0 * 1000) | |||
|
r616 | return | |
|
r1120 | ||
|
r616 | def get_size(self): | |
|
r1120 | ||
self.__size = 116 + 12 * self.nWindows + 4 * self.numTaus | |||
|
r616 | if self.codeType != 0: | |
|
r1120 | self.__size += 4 + 4 + 4 * self.nCode * \ | |
numpy.ceil(self.nBaud / 32.) | |||
|
r616 | return self.__size | |
|
r1120 | ||
|
r616 | def set_size(self, value): | |
|
r1120 | ||
|
r1167 | raise IOError("size is a property and it cannot be set, just read") | |
|
r1120 | ||
|
r487 | return | |
|
r1120 | ||
|
r487 | ippSeconds = property(get_ippSeconds, set_ippSeconds) | |
|
r616 | size = property(get_size, set_size) | |
|
r487 | ||
|
r1120 | ||
|
r487 | class ProcessingHeader(Header): | |
|
r1120 | ||
# size = None | |||
|
r487 | dtype = None | |
blockSize = None | |||
profilesPerBlock = None | |||
dataBlocksPerFile = None | |||
nWindows = None | |||
processFlags = None | |||
nCohInt = None | |||
nIncohInt = None | |||
totalSpectra = None | |||
|
r980 | structure = PROCESSING_STRUCTURE | |
|
r487 | flag_dc = None | |
flag_cspc = None | |||
|
r1120 | ||
def __init__(self, dtype=0, blockSize=0, profilesPerBlock=0, dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0, | |||
nIncohInt=0, totalSpectra=0, nHeights=0, firstHeight=0, deltaHeight=0, samplesWin=0, spectraComb=0, nCode=0, | |||
code=0, nBaud=None, shif_fft=False, flag_dc=False, flag_cspc=False, flag_decode=False, flag_deflip=False | |||
): | |||
# self.size = 0 | |||
|
r980 | self.dtype = dtype | |
self.blockSize = blockSize | |||
|
r487 | self.profilesPerBlock = 0 | |
self.dataBlocksPerFile = 0 | |||
self.nWindows = 0 | |||
self.processFlags = 0 | |||
self.nCohInt = 0 | |||
self.nIncohInt = 0 | |||
self.totalSpectra = 0 | |||
|
r1120 | ||
|
r487 | self.nHeights = 0 | |
self.firstHeight = 0 | |||
self.deltaHeight = 0 | |||
self.samplesWin = 0 | |||
self.spectraComb = 0 | |||
|
r624 | self.nCode = None | |
self.code = None | |||
self.nBaud = None | |||
|
r1120 | ||
|
r487 | self.shif_fft = False | |
self.flag_dc = False | |||
self.flag_cspc = False | |||
|
r624 | self.flag_decode = False | |
self.flag_deflip = False | |||
|
r975 | self.length = 0 | |
|
r980 | ||
|
r487 | def read(self, fp): | |
|
r975 | self.length = 0 | |
try: | |||
startFp = fp.tell() | |||
|
r1167 | except Exception as e: | |
|
r975 | startFp = None | |
pass | |||
|
r1120 | ||
|
r684 | try: | |
|
r975 | if hasattr(fp, 'read'): | |
header = numpy.fromfile(fp, PROCESSING_STRUCTURE, 1) | |||
else: | |||
header = numpy.fromstring(fp, PROCESSING_STRUCTURE, 1) | |||
self.length += header.nbytes | |||
|
r1167 | except Exception as e: | |
print("ProcessingHeader: " + str(e)) | |||
|
r684 | return 0 | |
|
r1120 | ||
|
r624 | size = int(header['nSize'][0]) | |
|
r487 | self.dtype = int(header['nDataType'][0]) | |
self.blockSize = int(header['nSizeOfDataBlock'][0]) | |||
self.profilesPerBlock = int(header['nProfilesperBlock'][0]) | |||
self.dataBlocksPerFile = int(header['nDataBlocksperFile'][0]) | |||
self.nWindows = int(header['nNumWindows'][0]) | |||
self.processFlags = header['nProcessFlags'] | |||
self.nCohInt = int(header['nCoherentIntegrations'][0]) | |||
self.nIncohInt = int(header['nIncoherentIntegrations'][0]) | |||
self.totalSpectra = int(header['nTotalSpectra'][0]) | |||
|
r1120 | ||
|
r975 | try: | |
if hasattr(fp, 'read'): | |||
|
r1120 | samplingWindow = numpy.fromfile( | |
fp, SAMPLING_STRUCTURE, self.nWindows) | |||
|
r975 | else: | |
|
r1120 | samplingWindow = numpy.fromstring( | |
fp[self.length:], SAMPLING_STRUCTURE, self.nWindows) | |||
|
r975 | self.length += samplingWindow.nbytes | |
|
r1167 | except Exception as e: | |
print("ProcessingHeader: " + str(e)) | |||
|
r975 | return 0 | |
|
r1120 | ||
|
r568 | self.nHeights = int(numpy.sum(samplingWindow['nsa'])) | |
self.firstHeight = float(samplingWindow['h0'][0]) | |||
self.deltaHeight = float(samplingWindow['dh'][0]) | |||
self.samplesWin = samplingWindow['nsa'][0] | |||
|
r975 | ||
try: | |||
if hasattr(fp, 'read'): | |||
|
r1120 | self.spectraComb = numpy.fromfile( | |
fp, 'u1', 2 * self.totalSpectra) | |||
|
r975 | else: | |
|
r1120 | self.spectraComb = numpy.fromstring( | |
fp[self.length:], 'u1', 2 * self.totalSpectra) | |||
|
r975 | self.length += self.spectraComb.nbytes | |
|
r1167 | except Exception as e: | |
print("ProcessingHeader: " + str(e)) | |||
|
r975 | return 0 | |
|
r1120 | ||
|
r624 | if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE): | |
|
r1120 | self.nCode = int(numpy.fromfile(fp, '<u4', 1)) | |
self.nBaud = int(numpy.fromfile(fp, '<u4', 1)) | |||
self.code = numpy.fromfile( | |||
fp, '<f4', self.nCode * self.nBaud).reshape(self.nCode, self.nBaud) | |||
|
r624 | if ((self.processFlags & PROCFLAG.EXP_NAME_ESP) == PROCFLAG.EXP_NAME_ESP): | |
|
r1120 | exp_name_len = int(numpy.fromfile(fp, '<u4', 1)) | |
exp_name = numpy.fromfile(fp, 'u1', exp_name_len + 1) | |||
|
r487 | if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA): | |
self.shif_fft = True | |||
else: | |||
self.shif_fft = False | |||
|
r1120 | ||
|
r487 | if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC): | |
self.flag_dc = True | |||
|
r624 | else: | |
self.flag_dc = False | |||
|
r1120 | ||
|
r624 | if ((self.processFlags & PROCFLAG.DECODE_DATA) == PROCFLAG.DECODE_DATA): | |
self.flag_decode = True | |||
else: | |||
self.flag_decode = False | |||
|
r1120 | ||
|
r624 | if ((self.processFlags & PROCFLAG.DEFLIP_DATA) == PROCFLAG.DEFLIP_DATA): | |
self.flag_deflip = True | |||
else: | |||
self.flag_deflip = False | |||
|
r1120 | ||
|
r487 | nChannels = 0 | |
nPairs = 0 | |||
pairList = [] | |||
|
r1120 | ||
for i in range(0, self.totalSpectra * 2, 2): | |||
if self.spectraComb[i] == self.spectraComb[i + 1]: | |||
nChannels = nChannels + 1 # par de canales iguales | |||
|
r487 | else: | |
|
r1120 | nPairs = nPairs + 1 # par de canales diferentes | |
pairList.append((self.spectraComb[i], self.spectraComb[i + 1])) | |||
|
r487 | self.flag_cspc = False | |
if nPairs > 0: | |||
self.flag_cspc = True | |||
|
r1120 | ||
|
r975 | if startFp is not None: | |
endFp = size + startFp | |||
if fp.tell() > endFp: | |||
|
r1120 | sys.stderr.write( | |
"Warning: Processing header size is lower than it has to be") | |||
|
r975 | return 0 | |
|
r1120 | ||
|
r975 | if fp.tell() < endFp: | |
|
r1120 | sys.stderr.write( | |
"Warning: Processing header size is greater than it is considered") | |||
|
r487 | return 1 | |
|
r1120 | ||
|
r487 | def write(self, fp): | |
|
r1120 | # Clear DEFINE_PROCESS_CODE | |
|
r704 | self.processFlags = self.processFlags & (~PROCFLAG.DEFINE_PROCESS_CODE) | |
|
r1120 | ||
|
r487 | headerTuple = (self.size, | |
self.dtype, | |||
self.blockSize, | |||
self.profilesPerBlock, | |||
self.dataBlocksPerFile, | |||
self.nWindows, | |||
self.processFlags, | |||
self.nCohInt, | |||
self.nIncohInt, | |||
self.totalSpectra) | |||
|
r1120 | ||
header = numpy.array(headerTuple, PROCESSING_STRUCTURE) | |||
|
r487 | header.tofile(fp) | |
|
r1120 | ||
|
r487 | if self.nWindows != 0: | |
|
r1120 | sampleWindowTuple = ( | |
self.firstHeight, self.deltaHeight, self.samplesWin) | |||
samplingWindow = numpy.array(sampleWindowTuple, SAMPLING_STRUCTURE) | |||
|
r487 | samplingWindow.tofile(fp) | |
|
r1120 | ||
|
r487 | if self.totalSpectra != 0: | |
|
r1120 | # spectraComb = numpy.array([],numpy.dtype('u1')) | |
|
r487 | spectraComb = self.spectraComb | |
spectraComb.tofile(fp) | |||
|
r1120 | ||
|
r778 | # if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE: | |
# nCode = numpy.array([self.nCode], numpy.dtype('u4')) #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba | |||
# nCode.tofile(fp) | |||
|
r1120 | # | |
|
r778 | # nBaud = numpy.array([self.nBaud], numpy.dtype('u4')) | |
# nBaud.tofile(fp) | |||
|
r1120 | # | |
|
r778 | # code = self.code.reshape(self.nCode*self.nBaud) | |
# code = code.astype(numpy.dtype('<f4')) | |||
# code.tofile(fp) | |||
|
r1120 | ||
|
r487 | return 1 | |
|
r624 | def get_size(self): | |
|
r1120 | ||
self.__size = 40 + 12 * self.nWindows + 2 * self.totalSpectra | |||
|
r778 | # if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE: | |
|
r624 | # self.__size += 4 + 4 + 4*self.nCode*numpy.ceil(self.nBaud/32.) | |
|
r778 | # self.__size += 4 + 4 + 4 * self.nCode * self.nBaud | |
|
r1120 | ||
|
r624 | return self.__size | |
|
r1120 | ||
|
r624 | def set_size(self, value): | |
|
r1120 | ||
|
r1167 | raise IOError("size is a property and it cannot be set, just read") | |
|
r1120 | ||
|
r624 | return | |
|
r1120 | ||
|
r624 | size = property(get_size, set_size) | |
|
r1120 | ||
|
r487 | class RCfunction: | |
|
r1120 | NONE = 0 | |
FLIP = 1 | |||
CODE = 2 | |||
SAMPLING = 3 | |||
LIN6DIV256 = 4 | |||
SYNCHRO = 5 | |||
|
r487 | ||
class nCodeType: | |||
|
r1120 | NONE = 0 | |
USERDEFINE = 1 | |||
BARKER2 = 2 | |||
BARKER3 = 3 | |||
BARKER4 = 4 | |||
BARKER5 = 5 | |||
BARKER7 = 6 | |||
BARKER11 = 7 | |||
BARKER13 = 8 | |||
AC128 = 9 | |||
COMPLEMENTARYCODE2 = 10 | |||
COMPLEMENTARYCODE4 = 11 | |||
COMPLEMENTARYCODE8 = 12 | |||
COMPLEMENTARYCODE16 = 13 | |||
COMPLEMENTARYCODE32 = 14 | |||
COMPLEMENTARYCODE64 = 15 | |||
COMPLEMENTARYCODE128 = 16 | |||
CODE_BINARY28 = 17 | |||
class PROCFLAG: | |||
|
r487 | COHERENT_INTEGRATION = numpy.uint32(0x00000001) | |
|
r1120 | DECODE_DATA = numpy.uint32(0x00000002) | |
|
r487 | SPECTRA_CALC = numpy.uint32(0x00000004) | |
|
r1120 | INCOHERENT_INTEGRATION = numpy.uint32(0x00000008) | |
|
r487 | POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010) | |
SHIFT_FFT_DATA = numpy.uint32(0x00000020) | |||
|
r1120 | ||
|
r487 | DATATYPE_CHAR = numpy.uint32(0x00000040) | |
DATATYPE_SHORT = numpy.uint32(0x00000080) | |||
DATATYPE_LONG = numpy.uint32(0x00000100) | |||
DATATYPE_INT64 = numpy.uint32(0x00000200) | |||
DATATYPE_FLOAT = numpy.uint32(0x00000400) | |||
DATATYPE_DOUBLE = numpy.uint32(0x00000800) | |||
|
r1120 | ||
DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000) | |||
DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000) | |||
DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000) | |||
|
r487 | SAVE_CHANNELS_DC = numpy.uint32(0x00008000) | |
|
r1120 | DEFLIP_DATA = numpy.uint32(0x00010000) | |
DEFINE_PROCESS_CODE = numpy.uint32(0x00020000) | |||
|
r487 | ACQ_SYS_NATALIA = numpy.uint32(0x00040000) | |
ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000) | |||
ACQ_SYS_ADRXD = numpy.uint32(0x000C0000) | |||
ACQ_SYS_JULIA = numpy.uint32(0x00100000) | |||
ACQ_SYS_XXXXXX = numpy.uint32(0x00140000) | |||
|
r1120 | ||
|
r487 | EXP_NAME_ESP = numpy.uint32(0x00200000) | |
CHANNEL_NAMES_ESP = numpy.uint32(0x00400000) | |||
|
r1120 | ||
|
r487 | OPERATION_MASK = numpy.uint32(0x0000003F) | |
DATATYPE_MASK = numpy.uint32(0x00000FC0) | |||
DATAARRANGE_MASK = numpy.uint32(0x00007000) | |||
|
r616 | ACQ_SYS_MASK = numpy.uint32(0x001C0000) | |
|
r1120 | ||
dtype0 = numpy.dtype([('real', '<i1'), ('imag', '<i1')]) | |||
dtype1 = numpy.dtype([('real', '<i2'), ('imag', '<i2')]) | |||
dtype2 = numpy.dtype([('real', '<i4'), ('imag', '<i4')]) | |||
dtype3 = numpy.dtype([('real', '<i8'), ('imag', '<i8')]) | |||
dtype4 = numpy.dtype([('real', '<f4'), ('imag', '<f4')]) | |||
dtype5 = numpy.dtype([('real', '<f8'), ('imag', '<f8')]) | |||
|
r616 | ||
NUMPY_DTYPE_LIST = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5] | |||
|
r1120 | PROCFLAG_DTYPE_LIST = [PROCFLAG.DATATYPE_CHAR, | |
PROCFLAG.DATATYPE_SHORT, | |||
PROCFLAG.DATATYPE_LONG, | |||
PROCFLAG.DATATYPE_INT64, | |||
PROCFLAG.DATATYPE_FLOAT, | |||
|
r616 | PROCFLAG.DATATYPE_DOUBLE] | |
DTYPE_WIDTH = [1, 2, 4, 8, 4, 8] | |||
|
r1120 | ||
|
r616 | def get_dtype_index(numpy_dtype): | |
|
r1120 | ||
|
r616 | index = None | |
|
r1120 | ||
|
r616 | for i in range(len(NUMPY_DTYPE_LIST)): | |
if numpy_dtype == NUMPY_DTYPE_LIST[i]: | |||
index = i | |||
break | |||
|
r1120 | ||
|
r616 | return index | |
|
r1120 | ||
|
r616 | def get_numpy_dtype(index): | |
|
r1120 | ||
|
r616 | return NUMPY_DTYPE_LIST[index] | |
|
r1120 | ||
|
r616 | def get_procflag_dtype(index): | |
|
r1120 | ||
|
r616 | return PROCFLAG_DTYPE_LIST[index] | |
|
r1120 | ||
|
r616 | def get_dtype_width(index): | |
|
r1120 | ||
|
r1167 | return DTYPE_WIDTH[index] |