|
|
import os, sys
|
|
|
import glob
|
|
|
import fnmatch
|
|
|
import datetime
|
|
|
import time
|
|
|
import re
|
|
|
import h5py
|
|
|
import numpy
|
|
|
import matplotlib.pyplot as plt
|
|
|
|
|
|
import pylab as plb
|
|
|
from scipy.optimize import curve_fit
|
|
|
from scipy import asarray as ar,exp
|
|
|
from scipy import stats
|
|
|
|
|
|
from numpy.ma.core import getdata
|
|
|
|
|
|
SPEED_OF_LIGHT = 299792458
|
|
|
SPEED_OF_LIGHT = 3e8
|
|
|
|
|
|
try:
|
|
|
from gevent import sleep
|
|
|
except:
|
|
|
from time import sleep
|
|
|
|
|
|
from schainpy.model.data.jrodata import Spectra
|
|
|
#from schainpy.model.data.BLTRheaderIO import FileHeader, RecordHeader
|
|
|
from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
|
|
|
#from schainpy.model.io.jroIO_bltr import BLTRReader
|
|
|
from numpy import imag, shape, NaN, empty
|
|
|
|
|
|
|
|
|
|
|
|
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 = 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
|
|
|
|
|
|
|
|
|
FILE_HEADER = numpy.dtype([ #HEADER 1024bytes
|
|
|
('Hname','a32'), #Original file name
|
|
|
('Htime',numpy.str_,32), #Date and time when the file was created
|
|
|
('Hoper',numpy.str_,64), #Name of operator who created the file
|
|
|
('Hplace',numpy.str_,128), #Place where the measurements was carried out
|
|
|
('Hdescr',numpy.str_,256), #Description of measurements
|
|
|
('Hdummy',numpy.str_,512), #Reserved space
|
|
|
#Main chunk 8bytes
|
|
|
('Msign',numpy.str_,4), #Main chunk signature FZKF or NUIG
|
|
|
('MsizeData','<i4'), #Size of data block main chunk
|
|
|
#Processing DSP parameters 36bytes
|
|
|
('PPARsign',numpy.str_,4), #PPAR signature
|
|
|
('PPARsize','<i4'), #PPAR size of block
|
|
|
('PPARprf','<i4'), #Pulse repetition frequency
|
|
|
('PPARpdr','<i4'), #Pulse duration
|
|
|
('PPARsft','<i4'), #FFT length
|
|
|
('PPARavc','<i4'), #Number of spectral (in-coherent) averages
|
|
|
('PPARihp','<i4'), #Number of lowest range gate for moment estimation
|
|
|
('PPARchg','<i4'), #Count for gates for moment estimation
|
|
|
('PPARpol','<i4'), #switch on/off polarimetric measurements. Should be 1.
|
|
|
#Service DSP parameters 112bytes
|
|
|
('SPARatt','<i4'), #STC attenuation on the lowest ranges on/off
|
|
|
('SPARtx','<i4'), #OBSOLETE
|
|
|
('SPARaddGain0','<f4'), #OBSOLETE
|
|
|
('SPARaddGain1','<f4'), #OBSOLETE
|
|
|
('SPARwnd','<i4'), #Debug only. It normal mode it is 0.
|
|
|
('SPARpos','<i4'), #Delay between sync pulse and tx pulse for phase corr, ns
|
|
|
('SPARadd','<i4'), #"add to pulse" to compensate for delay between the leading edge of driver pulse and envelope of the RF signal.
|
|
|
('SPARlen','<i4'), #Time for measuring txn pulse phase. OBSOLETE
|
|
|
('SPARcal','<i4'), #OBSOLETE
|
|
|
('SPARnos','<i4'), #OBSOLETE
|
|
|
('SPARof0','<i4'), #detection threshold
|
|
|
('SPARof1','<i4'), #OBSOLETE
|
|
|
('SPARswt','<i4'), #2nd moment estimation threshold
|
|
|
('SPARsum','<i4'), #OBSOLETE
|
|
|
('SPARosc','<i4'), #flag Oscillosgram mode
|
|
|
('SPARtst','<i4'), #OBSOLETE
|
|
|
('SPARcor','<i4'), #OBSOLETE
|
|
|
('SPARofs','<i4'), #OBSOLETE
|
|
|
('SPARhsn','<i4'), #Hildebrand div noise detection on noise gate
|
|
|
('SPARhsa','<f4'), #Hildebrand div noise detection on all gates
|
|
|
('SPARcalibPow_M','<f4'), #OBSOLETE
|
|
|
('SPARcalibSNR_M','<f4'), #OBSOLETE
|
|
|
('SPARcalibPow_S','<f4'), #OBSOLETE
|
|
|
('SPARcalibSNR_S','<f4'), #OBSOLETE
|
|
|
('SPARrawGate1','<i4'), #Lowest range gate for spectra saving Raw_Gate1 >=5
|
|
|
('SPARrawGate2','<i4'), #Number of range gates with atmospheric signal
|
|
|
('SPARraw','<i4'), #flag - IQ or spectra saving on/off
|
|
|
('SPARprc','<i4'),]) #flag - Moment estimation switched on/off
|
|
|
|
|
|
|
|
|
|
|
|
class FileHeaderMIRA35c(Header):
|
|
|
|
|
|
def __init__(self):
|
|
|
|
|
|
self.Hname= None
|
|
|
self.Htime= None
|
|
|
self.Hoper= None
|
|
|
self.Hplace= None
|
|
|
self.Hdescr= None
|
|
|
self.Hdummy= None
|
|
|
|
|
|
self.Msign=None
|
|
|
self.MsizeData=None
|
|
|
|
|
|
self.PPARsign=None
|
|
|
self.PPARsize=None
|
|
|
self.PPARprf=None
|
|
|
self.PPARpdr=None
|
|
|
self.PPARsft=None
|
|
|
self.PPARavc=None
|
|
|
self.PPARihp=None
|
|
|
self.PPARchg=None
|
|
|
self.PPARpol=None
|
|
|
#Service DSP parameters
|
|
|
self.SPARatt=None
|
|
|
self.SPARtx=None
|
|
|
self.SPARaddGain0=None
|
|
|
self.SPARaddGain1=None
|
|
|
self.SPARwnd=None
|
|
|
self.SPARpos=None
|
|
|
self.SPARadd=None
|
|
|
self.SPARlen=None
|
|
|
self.SPARcal=None
|
|
|
self.SPARnos=None
|
|
|
self.SPARof0=None
|
|
|
self.SPARof1=None
|
|
|
self.SPARswt=None
|
|
|
self.SPARsum=None
|
|
|
self.SPARosc=None
|
|
|
self.SPARtst=None
|
|
|
self.SPARcor=None
|
|
|
self.SPARofs=None
|
|
|
self.SPARhsn=None
|
|
|
self.SPARhsa=None
|
|
|
self.SPARcalibPow_M=None
|
|
|
self.SPARcalibSNR_M=None
|
|
|
self.SPARcalibPow_S=None
|
|
|
self.SPARcalibSNR_S=None
|
|
|
self.SPARrawGate1=None
|
|
|
self.SPARrawGate2=None
|
|
|
self.SPARraw=None
|
|
|
self.SPARprc=None
|
|
|
|
|
|
self.FHsize=1180
|
|
|
|
|
|
def FHread(self, fp):
|
|
|
|
|
|
header = numpy.fromfile(fp, FILE_HEADER,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.
|
|
|
|
|
|
'''
|
|
|
|
|
|
|
|
|
self.Hname= str(header['Hname'][0])
|
|
|
self.Htime= str(header['Htime'][0])
|
|
|
self.Hoper= str(header['Hoper'][0])
|
|
|
self.Hplace= str(header['Hplace'][0])
|
|
|
self.Hdescr= str(header['Hdescr'][0])
|
|
|
self.Hdummy= str(header['Hdummy'][0])
|
|
|
#1024
|
|
|
|
|
|
self.Msign=str(header['Msign'][0])
|
|
|
self.MsizeData=header['MsizeData'][0]
|
|
|
#8
|
|
|
|
|
|
self.PPARsign=str(header['PPARsign'][0])
|
|
|
self.PPARsize=header['PPARsize'][0]
|
|
|
self.PPARprf=header['PPARprf'][0]
|
|
|
self.PPARpdr=header['PPARpdr'][0]
|
|
|
self.PPARsft=header['PPARsft'][0]
|
|
|
self.PPARavc=header['PPARavc'][0]
|
|
|
self.PPARihp=header['PPARihp'][0]
|
|
|
self.PPARchg=header['PPARchg'][0]
|
|
|
self.PPARpol=header['PPARpol'][0]
|
|
|
#Service DSP parameters
|
|
|
#36
|
|
|
|
|
|
self.SPARatt=header['SPARatt'][0]
|
|
|
self.SPARtx=header['SPARtx'][0]
|
|
|
self.SPARaddGain0=header['SPARaddGain0'][0]
|
|
|
self.SPARaddGain1=header['SPARaddGain1'][0]
|
|
|
self.SPARwnd=header['SPARwnd'][0]
|
|
|
self.SPARpos=header['SPARpos'][0]
|
|
|
self.SPARadd=header['SPARadd'][0]
|
|
|
self.SPARlen=header['SPARlen'][0]
|
|
|
self.SPARcal=header['SPARcal'][0]
|
|
|
self.SPARnos=header['SPARnos'][0]
|
|
|
self.SPARof0=header['SPARof0'][0]
|
|
|
self.SPARof1=header['SPARof1'][0]
|
|
|
self.SPARswt=header['SPARswt'][0]
|
|
|
self.SPARsum=header['SPARsum'][0]
|
|
|
self.SPARosc=header['SPARosc'][0]
|
|
|
self.SPARtst=header['SPARtst'][0]
|
|
|
self.SPARcor=header['SPARcor'][0]
|
|
|
self.SPARofs=header['SPARofs'][0]
|
|
|
self.SPARhsn=header['SPARhsn'][0]
|
|
|
self.SPARhsa=header['SPARhsa'][0]
|
|
|
self.SPARcalibPow_M=header['SPARcalibPow_M'][0]
|
|
|
self.SPARcalibSNR_M=header['SPARcalibSNR_M'][0]
|
|
|
self.SPARcalibPow_S=header['SPARcalibPow_S'][0]
|
|
|
self.SPARcalibSNR_S=header['SPARcalibSNR_S'][0]
|
|
|
self.SPARrawGate1=header['SPARrawGate1'][0]
|
|
|
self.SPARrawGate2=header['SPARrawGate2'][0]
|
|
|
self.SPARraw=header['SPARraw'][0]
|
|
|
self.SPARprc=header['SPARprc'][0]
|
|
|
#112
|
|
|
#1180
|
|
|
#print 'Pointer fp header', fp.tell()
|
|
|
#print ' '
|
|
|
#print 'SPARrawGate'
|
|
|
#print self.SPARrawGate2 - self.SPARrawGate1
|
|
|
|
|
|
#print ' '
|
|
|
#print 'Hname'
|
|
|
#print self.Hname
|
|
|
|
|
|
#print ' '
|
|
|
#print 'Msign'
|
|
|
#print self.Msign
|
|
|
|
|
|
def write(self, fp):
|
|
|
|
|
|
headerTuple = (self.Hname,
|
|
|
self.Htime,
|
|
|
self.Hoper,
|
|
|
self.Hplace,
|
|
|
self.Hdescr,
|
|
|
self.Hdummy)
|
|
|
|
|
|
|
|
|
header = numpy.array(headerTuple, FILE_HEADER)
|
|
|
# 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
|
|
|
|
|
|
SRVI_HEADER = numpy.dtype([
|
|
|
('SignatureSRVI1',numpy.str_,4),#
|
|
|
('SizeOfDataBlock1','<i4'),#
|
|
|
('DataBlockTitleSRVI1',numpy.str_,4),#
|
|
|
('SizeOfSRVI1','<i4'),])#
|
|
|
|
|
|
class SRVIHeader(Header):
|
|
|
def __init__(self, SignatureSRVI1=0, SizeOfDataBlock1=0, DataBlockTitleSRVI1=0, SizeOfSRVI1=0):
|
|
|
|
|
|
self.SignatureSRVI1 = SignatureSRVI1
|
|
|
self.SizeOfDataBlock1 = SizeOfDataBlock1
|
|
|
self.DataBlockTitleSRVI1 = DataBlockTitleSRVI1
|
|
|
self.SizeOfSRVI1 = SizeOfSRVI1
|
|
|
|
|
|
self.SRVIHsize=16
|
|
|
|
|
|
def SRVIread(self, fp):
|
|
|
|
|
|
header = numpy.fromfile(fp, SRVI_HEADER,1)
|
|
|
|
|
|
self.SignatureSRVI1 = str(header['SignatureSRVI1'][0])
|
|
|
self.SizeOfDataBlock1 = header['SizeOfDataBlock1'][0]
|
|
|
self.DataBlockTitleSRVI1 = str(header['DataBlockTitleSRVI1'][0])
|
|
|
self.SizeOfSRVI1 = header['SizeOfSRVI1'][0]
|
|
|
#16
|
|
|
print 'Pointer fp SRVIheader', fp.tell()
|
|
|
|
|
|
|
|
|
SRVI_STRUCTURE = numpy.dtype([
|
|
|
('frame_cnt','<u4'),#
|
|
|
('time_t','<u4'), #
|
|
|
('tpow','<f4'), #
|
|
|
('npw1','<f4'), #
|
|
|
('npw2','<f4'), #
|
|
|
('cpw1','<f4'), #
|
|
|
('pcw2','<f4'), #
|
|
|
('ps_err','<u4'), #
|
|
|
('te_err','<u4'), #
|
|
|
('rc_err','<u4'), #
|
|
|
('grs1','<u4'), #
|
|
|
('grs2','<u4'), #
|
|
|
('azipos','<f4'), #
|
|
|
('azivel','<f4'), #
|
|
|
('elvpos','<f4'), #
|
|
|
('elvvel','<f4'), #
|
|
|
('northAngle','<f4'), #
|
|
|
('microsec','<u4'), #
|
|
|
('azisetvel','<f4'), #
|
|
|
('elvsetpos','<f4'), #
|
|
|
('RadarConst','<f4'),]) #
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class RecordHeader(Header):
|
|
|
|
|
|
|
|
|
def __init__(self, frame_cnt=0, time_t= 0, tpow=0, npw1=0, npw2=0,
|
|
|
cpw1=0, pcw2=0, ps_err=0, te_err=0, rc_err=0, grs1=0,
|
|
|
grs2=0, azipos=0, azivel=0, elvpos=0, elvvel=0, northangle=0,
|
|
|
microsec=0, azisetvel=0, elvsetpos=0, RadarConst=0 , RecCounter=0, Off2StartNxtRec=0):
|
|
|
|
|
|
|
|
|
self.frame_cnt = frame_cnt
|
|
|
self.dwell = time_t
|
|
|
self.tpow = tpow
|
|
|
self.npw1 = npw1
|
|
|
self.npw2 = npw2
|
|
|
self.cpw1 = cpw1
|
|
|
self.pcw2 = pcw2
|
|
|
self.ps_err = ps_err
|
|
|
self.te_err = te_err
|
|
|
self.rc_err = rc_err
|
|
|
self.grs1 = grs1
|
|
|
self.grs2 = grs2
|
|
|
self.azipos = azipos
|
|
|
self.azivel = azivel
|
|
|
self.elvpos = elvpos
|
|
|
self.elvvel = elvvel
|
|
|
self.northAngle = northangle
|
|
|
self.microsec = microsec
|
|
|
self.azisetvel = azisetvel
|
|
|
self.elvsetpos = elvsetpos
|
|
|
self.RadarConst = RadarConst
|
|
|
self.RHsize=84
|
|
|
self.RecCounter = RecCounter
|
|
|
self.Off2StartNxtRec=Off2StartNxtRec
|
|
|
|
|
|
def RHread(self, fp):
|
|
|
|
|
|
#startFp = open(fp,"rb") #The method tell() returns the current position of the file read/write pointer within the file.
|
|
|
|
|
|
#OffRHeader= 1180 + self.RecCounter*(self.Off2StartNxtRec)
|
|
|
#startFp.seek(OffRHeader, os.SEEK_SET)
|
|
|
|
|
|
#print 'Posicion del bloque: ',OffRHeader
|
|
|
|
|
|
header = numpy.fromfile(fp,SRVI_STRUCTURE,1)
|
|
|
|
|
|
self.frame_cnt = header['frame_cnt'][0]#
|
|
|
self.time_t = header['time_t'][0] #
|
|
|
self.tpow = header['tpow'][0] #
|
|
|
self.npw1 = header['npw1'][0] #
|
|
|
self.npw2 = header['npw2'][0] #
|
|
|
self.cpw1 = header['cpw1'][0] #
|
|
|
self.pcw2 = header['pcw2'][0] #
|
|
|
self.ps_err = header['ps_err'][0] #
|
|
|
self.te_err = header['te_err'][0] #
|
|
|
self.rc_err = header['rc_err'][0] #
|
|
|
self.grs1 = header['grs1'][0] #
|
|
|
self.grs2 = header['grs2'][0] #
|
|
|
self.azipos = header['azipos'][0] #
|
|
|
self.azivel = header['azivel'][0] #
|
|
|
self.elvpos = header['elvpos'][0] #
|
|
|
self.elvvel = header['elvvel'][0] #
|
|
|
self.northAngle = header['northAngle'][0] #
|
|
|
self.microsec = header['microsec'][0] #
|
|
|
self.azisetvel = header['azisetvel'][0] #
|
|
|
self.elvsetpos = header['elvsetpos'][0] #
|
|
|
self.RadarConst = header['RadarConst'][0] #
|
|
|
#84
|
|
|
|
|
|
#print 'Pointer fp RECheader', fp.tell()
|
|
|
|
|
|
#self.ipp= 0.5*(SPEED_OF_LIGHT/self.PRFhz)
|
|
|
|
|
|
#self.RHsize = 180+20*self.nChannels
|
|
|
#self.Datasize= self.nProfiles*self.nChannels*self.nHeights*2*4
|
|
|
#print 'Datasize',self.Datasize
|
|
|
#endFp = self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
|
|
|
|
|
|
print '=============================================='
|
|
|
|
|
|
print '=============================================='
|
|
|
|
|
|
|
|
|
return 1
|
|
|
|
|
|
class MIRA35CReader (ProcessingUnit,FileHeaderMIRA35c,SRVIHeader,RecordHeader):
|
|
|
|
|
|
path = None
|
|
|
startDate = None
|
|
|
endDate = None
|
|
|
startTime = None
|
|
|
endTime = None
|
|
|
walk = None
|
|
|
isConfig = False
|
|
|
|
|
|
|
|
|
fileList= None
|
|
|
|
|
|
#metadata
|
|
|
TimeZone= None
|
|
|
Interval= None
|
|
|
heightList= None
|
|
|
|
|
|
#data
|
|
|
data= None
|
|
|
utctime= None
|
|
|
|
|
|
|
|
|
|
|
|
def __init__(self, **kwargs):
|
|
|
|
|
|
#Eliminar de la base la herencia
|
|
|
ProcessingUnit.__init__(self, **kwargs)
|
|
|
self.PointerReader = 0
|
|
|
self.FileHeaderFlag = False
|
|
|
self.utc = None
|
|
|
self.ext = ".zspca"
|
|
|
self.optchar = "P"
|
|
|
self.fpFile=None
|
|
|
self.fp = None
|
|
|
self.BlockCounter=0
|
|
|
self.dtype = None
|
|
|
self.fileSizeByHeader = None
|
|
|
self.filenameList = []
|
|
|
self.fileSelector = 0
|
|
|
self.Off2StartNxtRec=0
|
|
|
self.RecCounter=0
|
|
|
self.flagNoMoreFiles = 0
|
|
|
self.data_spc=None
|
|
|
#self.data_cspc=None
|
|
|
self.data_output=None
|
|
|
self.path = None
|
|
|
self.OffsetStartHeader=0
|
|
|
self.Off2StartData=0
|
|
|
self.ipp = 0
|
|
|
self.nFDTdataRecors=0
|
|
|
self.blocksize = 0
|
|
|
self.dataOut = Spectra()
|
|
|
self.profileIndex = 1 #Always
|
|
|
self.dataOut.flagNoData=False
|
|
|
self.dataOut.nRdPairs = 0
|
|
|
self.dataOut.pairsList = []
|
|
|
self.dataOut.data_spc=None
|
|
|
|
|
|
self.dataOut.normFactor=1
|
|
|
self.nextfileflag = True
|
|
|
self.dataOut.RadarConst = 0
|
|
|
self.dataOut.HSDV = []
|
|
|
self.dataOut.NPW = []
|
|
|
self.dataOut.COFA = []
|
|
|
self.dataOut.noise = 0
|
|
|
|
|
|
|
|
|
def Files2Read(self, fp):
|
|
|
'''
|
|
|
Function that indicates the number of .fdt files that exist in the folder to be read.
|
|
|
It also creates an organized list with the names of the files to read.
|
|
|
'''
|
|
|
#self.__checkPath()
|
|
|
|
|
|
ListaData=os.listdir(fp) #Gets the list of files within the fp address
|
|
|
ListaData=sorted(ListaData) #Sort the list of files from least to largest by names
|
|
|
nFiles=0 #File Counter
|
|
|
FileList=[] #A list is created that will contain the .fdt files
|
|
|
for IndexFile in ListaData :
|
|
|
if '.zspca' in IndexFile and '.gz' not in IndexFile:
|
|
|
FileList.append(IndexFile)
|
|
|
nFiles+=1
|
|
|
|
|
|
#print 'Files2Read'
|
|
|
#print 'Existen '+str(nFiles)+' archivos .fdt'
|
|
|
|
|
|
self.filenameList=FileList #List of files from least to largest by names
|
|
|
|
|
|
|
|
|
def run(self, **kwargs):
|
|
|
'''
|
|
|
This method will be the one that will initiate the data entry, will be called constantly.
|
|
|
You should first verify that your Setup () is set up and then continue to acquire
|
|
|
the data to be processed with getData ().
|
|
|
'''
|
|
|
if not self.isConfig:
|
|
|
self.setup(**kwargs)
|
|
|
self.isConfig = True
|
|
|
|
|
|
self.getData()
|
|
|
|
|
|
|
|
|
def setup(self, path=None,
|
|
|
startDate=None,
|
|
|
endDate=None,
|
|
|
startTime=None,
|
|
|
endTime=None,
|
|
|
walk=True,
|
|
|
timezone='utc',
|
|
|
code = None,
|
|
|
online=False,
|
|
|
ReadMode=None, **kwargs):
|
|
|
|
|
|
self.isConfig = True
|
|
|
|
|
|
self.path=path
|
|
|
self.startDate=startDate
|
|
|
self.endDate=endDate
|
|
|
self.startTime=startTime
|
|
|
self.endTime=endTime
|
|
|
self.walk=walk
|
|
|
#self.ReadMode=int(ReadMode)
|
|
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
def getData(self):
|
|
|
'''
|
|
|
Before starting this function, you should check that there is still an unread file,
|
|
|
If there are still blocks to read or if the data block is empty.
|
|
|
|
|
|
You should call the file "read".
|
|
|
|
|
|
'''
|
|
|
|
|
|
if self.flagNoMoreFiles:
|
|
|
self.dataOut.flagNoData = True
|
|
|
print 'NoData se vuelve true'
|
|
|
return 0
|
|
|
|
|
|
self.fp=self.path
|
|
|
self.Files2Read(self.fp)
|
|
|
self.readFile(self.fp)
|
|
|
|
|
|
self.dataOut.data_spc = self.dataOut_spc#self.data_spc.copy()
|
|
|
self.dataOut.RadarConst = self.RadarConst
|
|
|
self.dataOut.data_output=self.data_output
|
|
|
self.dataOut.noise = self.dataOut.getNoise()
|
|
|
#print 'ACAAAAAA', self.dataOut.noise
|
|
|
self.dataOut.data_spc = self.dataOut.data_spc+self.dataOut.noise
|
|
|
#print 'self.dataOut.noise',self.dataOut.noise
|
|
|
|
|
|
|
|
|
return self.dataOut.data_spc
|
|
|
|
|
|
|
|
|
def readFile(self,fp):
|
|
|
'''
|
|
|
You must indicate if you are reading in Online or Offline mode and load the
|
|
|
The parameters for this file reading mode.
|
|
|
|
|
|
Then you must do 2 actions:
|
|
|
|
|
|
1. Get the BLTR FileHeader.
|
|
|
2. Start reading the first block.
|
|
|
'''
|
|
|
|
|
|
#The address of the folder is generated the name of the .fdt file that will be read
|
|
|
print "File: ",self.fileSelector+1
|
|
|
|
|
|
if self.fileSelector < len(self.filenameList):
|
|
|
|
|
|
self.fpFile=str(fp)+'/'+str(self.filenameList[self.fileSelector])
|
|
|
|
|
|
if self.nextfileflag==True:
|
|
|
self.fp = open(self.fpFile,"rb")
|
|
|
self.nextfileflag==False
|
|
|
|
|
|
'''HERE STARTING THE FILE READING'''
|
|
|
|
|
|
|
|
|
self.fheader = FileHeaderMIRA35c()
|
|
|
self.fheader.FHread(self.fp) #Bltr FileHeader Reading
|
|
|
|
|
|
|
|
|
self.SPARrawGate1 = self.fheader.SPARrawGate1
|
|
|
self.SPARrawGate2 = self.fheader.SPARrawGate2
|
|
|
self.Num_Hei = self.SPARrawGate2 - self.SPARrawGate1
|
|
|
self.Num_Bins = self.fheader.PPARsft
|
|
|
self.dataOut.nFFTPoints = self.fheader.PPARsft
|
|
|
|
|
|
|
|
|
self.Num_inCoh = self.fheader.PPARavc
|
|
|
self.dataOut.PRF = self.fheader.PPARprf
|
|
|
self.dataOut.frequency = 34.85*10**9
|
|
|
self.Lambda = SPEED_OF_LIGHT/self.dataOut.frequency
|
|
|
self.dataOut.ippSeconds= 1./float(self.dataOut.PRF)
|
|
|
|
|
|
pulse_width = self.fheader.PPARpdr * 10**-9
|
|
|
self.__deltaHeigth = 0.5 * SPEED_OF_LIGHT * pulse_width
|
|
|
|
|
|
self.data_spc = numpy.zeros((self.Num_Hei, self.Num_Bins,2))#
|
|
|
self.dataOut.HSDV = numpy.zeros((self.Num_Hei, 2))
|
|
|
|
|
|
self.Ze = numpy.zeros(self.Num_Hei)
|
|
|
self.ETA = numpy.zeros(([2,self.Num_Hei]))
|
|
|
|
|
|
|
|
|
|
|
|
self.readBlock() #Block reading
|
|
|
|
|
|
else:
|
|
|
print 'readFile FlagNoData becomes true'
|
|
|
self.flagNoMoreFiles=True
|
|
|
self.dataOut.flagNoData = True
|
|
|
self.FileHeaderFlag == True
|
|
|
return 0
|
|
|
|
|
|
|
|
|
|
|
|
def readBlock(self):
|
|
|
'''
|
|
|
It should be checked if the block has data, if it is not passed to the next file.
|
|
|
|
|
|
Then the following is done:
|
|
|
|
|
|
1. Read the RecordHeader
|
|
|
2. Fill the buffer with the current block number.
|
|
|
|
|
|
'''
|
|
|
|
|
|
if self.PointerReader > 1180:
|
|
|
self.fp.seek(self.PointerReader , os.SEEK_SET)
|
|
|
self.FirstPoint = self.PointerReader
|
|
|
|
|
|
else :
|
|
|
self.FirstPoint = 1180
|
|
|
|
|
|
|
|
|
|
|
|
self.srviHeader = SRVIHeader()
|
|
|
|
|
|
self.srviHeader.SRVIread(self.fp) #Se obtiene la cabecera del SRVI
|
|
|
|
|
|
self.blocksize = self.srviHeader.SizeOfDataBlock1 # Se obtiene el tamao del bloque
|
|
|
|
|
|
if self.blocksize == 148:
|
|
|
print 'blocksize == 148 bug'
|
|
|
jump = numpy.fromfile(self.fp,[('jump',numpy.str_,140)] ,1)
|
|
|
|
|
|
self.srviHeader.SRVIread(self.fp) #Se obtiene la cabecera del SRVI
|
|
|
|
|
|
if not self.srviHeader.SizeOfSRVI1:
|
|
|
self.fileSelector+=1
|
|
|
self.nextfileflag==True
|
|
|
self.FileHeaderFlag == True
|
|
|
|
|
|
self.recordheader = RecordHeader()
|
|
|
self.recordheader.RHread(self.fp)
|
|
|
self.RadarConst = self.recordheader.RadarConst
|
|
|
dwell = self.recordheader.time_t
|
|
|
npw1 = self.recordheader.npw1
|
|
|
npw2 = self.recordheader.npw2
|
|
|
|
|
|
|
|
|
self.dataOut.channelList = range(1)
|
|
|
self.dataOut.nIncohInt = self.Num_inCoh
|
|
|
self.dataOut.nProfiles = self.Num_Bins
|
|
|
self.dataOut.nCohInt = 1
|
|
|
self.dataOut.windowOfFilter = 1
|
|
|
self.dataOut.utctime = dwell
|
|
|
self.dataOut.timeZone=0
|
|
|
|
|
|
self.dataOut.outputInterval = self.dataOut.getTimeInterval()
|
|
|
self.dataOut.heightList = self.SPARrawGate1*self.__deltaHeigth + numpy.array(range(self.Num_Hei))*self.__deltaHeigth
|
|
|
|
|
|
|
|
|
|
|
|
self.HSDVsign = numpy.fromfile( self.fp, [('HSDV',numpy.str_,4)],1)
|
|
|
self.SizeHSDV = numpy.fromfile( self.fp, [('SizeHSDV','<i4')],1)
|
|
|
self.HSDV_Co = numpy.fromfile( self.fp, [('HSDV_Co','<f4')],self.Num_Hei)
|
|
|
self.HSDV_Cx = numpy.fromfile( self.fp, [('HSDV_Cx','<f4')],self.Num_Hei)
|
|
|
|
|
|
self.COFAsign = numpy.fromfile( self.fp, [('COFA',numpy.str_,4)],1)
|
|
|
self.SizeCOFA = numpy.fromfile( self.fp, [('SizeCOFA','<i4')],1)
|
|
|
self.COFA_Co = numpy.fromfile( self.fp, [('COFA_Co','<f4')],self.Num_Hei)
|
|
|
self.COFA_Cx = numpy.fromfile( self.fp, [('COFA_Cx','<f4')],self.Num_Hei)
|
|
|
|
|
|
self.ZSPCsign = numpy.fromfile(self.fp, [('ZSPCsign',numpy.str_,4)],1)
|
|
|
self.SizeZSPC = numpy.fromfile(self.fp, [('SizeZSPC','<i4')],1)
|
|
|
|
|
|
self.dataOut.HSDV[0]=self.HSDV_Co[:][0]
|
|
|
self.dataOut.HSDV[1]=self.HSDV_Cx[:][0]
|
|
|
|
|
|
for irg in range(self.Num_Hei):
|
|
|
nspc = numpy.fromfile(self.fp, [('nspc','int16')],1)[0][0] # Number of spectral sub pieces containing significant power
|
|
|
|
|
|
for k in range(nspc):
|
|
|
binIndex = numpy.fromfile(self.fp, [('binIndex','int16')],1)[0][0] # Index of the spectral bin where the piece is beginning
|
|
|
nbins = numpy.fromfile(self.fp, [('nbins','int16')],1)[0][0] # Number of bins of the piece
|
|
|
|
|
|
#Co_Channel
|
|
|
jbin = numpy.fromfile(self.fp, [('jbin','uint16')],nbins)[0][0] # Spectrum piece to be normaliced
|
|
|
jmax = numpy.fromfile(self.fp, [('jmax','float32')],1)[0][0] # Maximun piece to be normaliced
|
|
|
|
|
|
|
|
|
self.data_spc[irg,binIndex:binIndex+nbins,0] = self.data_spc[irg,binIndex:binIndex+nbins,0]+jbin/65530.*jmax
|
|
|
|
|
|
#Cx_Channel
|
|
|
jbin = numpy.fromfile(self.fp, [('jbin','uint16')],nbins)[0][0]
|
|
|
jmax = numpy.fromfile(self.fp, [('jmax','float32')],1)[0][0]
|
|
|
|
|
|
|
|
|
self.data_spc[irg,binIndex:binIndex+nbins,1] = self.data_spc[irg,binIndex:binIndex+nbins,1]+jbin/65530.*jmax
|
|
|
|
|
|
for bin in range(self.Num_Bins):
|
|
|
|
|
|
self.data_spc[:,bin,0] = self.data_spc[:,bin,0] - self.dataOut.HSDV[:,0]
|
|
|
|
|
|
self.data_spc[:,bin,1] = self.data_spc[:,bin,1] - self.dataOut.HSDV[:,1]
|
|
|
|
|
|
|
|
|
numpy.set_printoptions(threshold='nan')
|
|
|
|
|
|
self.data_spc = numpy.where(self.data_spc > 0. , self.data_spc, 0)
|
|
|
|
|
|
self.dataOut.COFA = numpy.array([self.COFA_Co , self.COFA_Cx])
|
|
|
|
|
|
print ' '
|
|
|
print 'SPC',numpy.shape(self.dataOut.data_spc)
|
|
|
#print 'SPC',self.dataOut.data_spc
|
|
|
|
|
|
noinor1 = 713031680
|
|
|
noinor2 = 30
|
|
|
|
|
|
npw1 = 1#0**(npw1/10) * noinor1 * noinor2
|
|
|
npw2 = 1#0**(npw2/10) * noinor1 * noinor2
|
|
|
self.dataOut.NPW = numpy.array([npw1, npw2])
|
|
|
|
|
|
print ' '
|
|
|
|
|
|
self.data_spc = numpy.transpose(self.data_spc, (2,1,0))
|
|
|
self.data_spc = numpy.fft.fftshift(self.data_spc, axes = 1)
|
|
|
|
|
|
self.data_spc = numpy.fliplr(self.data_spc)
|
|
|
|
|
|
self.data_spc = numpy.where(self.data_spc > 0. , self.data_spc, 0)
|
|
|
self.dataOut_spc= numpy.ones([1, self.Num_Bins , self.Num_Hei])
|
|
|
self.dataOut_spc[0,:,:] = self.data_spc[0,:,:]
|
|
|
#print 'SHAPE', self.dataOut_spc.shape
|
|
|
#For nyquist correction:
|
|
|
#fix = 20 # ~3m/s
|
|
|
#shift = self.Num_Bins/2 + fix
|
|
|
#self.data_spc = numpy.array([ self.data_spc[: , self.Num_Bins-shift+1: , :] , self.data_spc[: , 0:self.Num_Bins-shift , :]])
|
|
|
|
|
|
|
|
|
|
|
|
'''Block Reading, the Block Data is received and Reshape is used to give it
|
|
|
shape.
|
|
|
'''
|
|
|
|
|
|
self.PointerReader = self.fp.tell()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
