##// END OF EJS Templates
schain
RSS
-Actualización de los nombres de los objetos systemHeader y radaraControllerHeader...
-Actualización de los nombres de los objetos systemHeader y radaraControllerHeader -Modificación de la clase SpectraHeisProcessor
Miguel Valdez - - Load All Authors

File last commit:

r148:1305f08c51fd
r148:1305f08c51fd
Show More
JROHeaderIO.py
504 lines | 16.8 KiB | text/x-python | PythonLexer
/ schainpy2 / IO / JROHeaderIO.py
History | Source | Raw |Copy content |Copy permalink
Daniel Valdez
En esta version se las funciones de LECTURA de rawdata y pdata operan satisfactoriamente.
 r122 '''
Daniel Valdez
Lectura/Escritura de Rawdata y Pdata operando correctamente, se hicieron pruebas con datos de Drifts,Faraday e Imagenes.
 r126 $Author$
$Id$
Daniel Valdez
En esta version se las funciones de LECTURA de rawdata y pdata operan satisfactoriamente.
 r122 '''
import numpy
import copy
class Header:
def __init__(self):
raise
def copy(self):
return copy.deepcopy(self)
def read():
pass
def write():
pass
class BasicHeader(Header):
size = None
version = None
dataBlock = None
utc = None
miliSecond = None
timeZone = None
dstFlag = None
errorCount = None
struct = None
def __init__(self):
self.size = 0
self.version = 0
self.dataBlock = 0
self.utc = 0
self.miliSecond = 0
self.timeZone = 0
self.dstFlag = 0
self.errorCount = 0
self.struct = numpy.dtype([
('nSize','<u4'),
('nVersion','<u2'),
('nDataBlockId','<u4'),
('nUtime','<u4'),
('nMilsec','<u2'),
('nTimezone','<i2'),
('nDstflag','<i2'),
('nErrorCount','<u4')
])
def read(self, fp):
try:
header = numpy.fromfile(fp, self.struct,1)
self.size = header['nSize'][0]
self.version = header['nVersion'][0]
self.dataBlock = header['nDataBlockId'][0]
self.utc = header['nUtime'][0]
self.miliSecond = header['nMilsec'][0]
self.timeZone = header['nTimezone'][0]
self.dstFlag = header['nDstflag'][0]
self.errorCount = header['nErrorCount'][0]
except:
return 0
return 1
def write(self, fp):
headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
header = numpy.array(headerTuple,self.struct)
header.tofile(fp)
return 1
class SystemHeader(Header):
size = None
nSamples = None
nProfiles = None
nChannels = None
adcResolution = None
pciDioBusWidth = None
struct = None
def __init__(self):
self.size = 0
self.nSamples = 0
self.nProfiles = 0
self.nChannels = 0
self.adcResolution = 0
self.pciDioBusWidth = 0
self.struct = numpy.dtype([
('nSize','<u4'),
('nNumSamples','<u4'),
('nNumProfiles','<u4'),
('nNumChannels','<u4'),
('nADCResolution','<u4'),
('nPCDIOBusWidth','<u4'),
])
def read(self, fp):
try:
header = numpy.fromfile(fp,self.struct,1)
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]
except:
return 0
return 1
def write(self, fp):
headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
header = numpy.array(headerTuple,self.struct)
header.tofile(fp)
return 1
class RadarControllerHeader(Header):
size = None
expType = None
nTx = None
ipp = None
txA = None
txB = None
nWindows = None
numTaus = None
codeType = None
line6Function = None
line5Function = None
fClock = None
prePulseBefore = None
prePulserAfter = None
rangeIpp = None
rangeTxA = None
rangeTxB = None
struct = None
def __init__(self):
self.size = 0
self.expType = 0
self.nTx = 0
self.ipp = 0
self.txA = 0
self.txB = 0
self.nWindows = 0
self.numTaus = 0
self.codeType = 0
self.line6Function = 0
self.line5Function = 0
self.fClock = 0
self.prePulseBefore = 0
self.prePulserAfter = 0
self.rangeIpp = 0
self.rangeTxA = 0
self.rangeTxB = 0
self.struct = numpy.dtype([
('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'),
])
self.samplingWindowStruct = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
self.samplingWindow = None
self.nHeights = None
self.firstHeight = None
self.deltaHeight = None
self.samplesWin = None
Daniel Valdez
Realizando cambios para escritura de rawdata
 r123 self.nCode = None
self.nBaud = None
Daniel Valdez
En esta version se las funciones de LECTURA de rawdata y pdata operan satisfactoriamente.
 r122 self.code = None
self.flip1 = None
self.flip2 = None
self.dynamic = numpy.array([],numpy.dtype('byte'))
def read(self, fp):
try:
startFp = fp.tell()
header = numpy.fromfile(fp,self.struct,1)
self.size = header['nSize'][0]
self.expType = header['nExpType'][0]
self.nTx = header['nNTx'][0]
self.ipp = header['fIpp'][0]
self.txA = header['fTxA'][0]
self.txB = header['fTxB'][0]
self.nWindows = header['nNumWindows'][0]
self.numTaus = header['nNumTaus'][0]
self.codeType = header['nCodeType'][0]
self.line6Function = header['nLine6Function'][0]
self.line5Function = header['nLine5Function'][0]
self.fClock = header['fClock'][0]
self.prePulseBefore = header['nPrePulseBefore'][0]
self.prePulserAfter = header['nPrePulseAfter'][0]
self.rangeIpp = header['sRangeIPP'][0]
self.rangeTxA = header['sRangeTxA'][0]
self.rangeTxB = header['sRangeTxB'][0]
# jump Dynamic Radar Controller Header
jumpFp = self.size - 116
self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpFp)
#pointer backward to dynamic header and read
backFp = fp.tell() - jumpFp
fp.seek(backFp)
self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.nWindows)
self.nHeights = numpy.sum(self.samplingWindow['nsa'])
self.firstHeight = self.samplingWindow['h0']
self.deltaHeight = self.samplingWindow['dh']
self.samplesWin = self.samplingWindow['nsa']
self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
if self.codeType != 0:
Daniel Valdez
Realizando cambios para escritura de rawdata
 r123 self.nCode = numpy.fromfile(fp,'<u4',1)
self.nBaud = numpy.fromfile(fp,'<u4',1)
self.code = numpy.empty([self.nCode,self.nBaud],dtype='u1')
Daniel Valdez
En esta version se las funciones de LECTURA de rawdata y pdata operan satisfactoriamente.
 r122 tempList = []
Daniel Valdez
Realizando cambios para escritura de rawdata
 r123 for ic in range(self.nCode):
temp = numpy.fromfile(fp,'u1',4*numpy.ceil(self.nBaud/32.))
Daniel Valdez
En esta version se las funciones de LECTURA de rawdata y pdata operan satisfactoriamente.
 r122 tempList.append(temp)
Daniel Valdez
Realizando cambios para escritura de rawdata
 r123 self.code[ic] = numpy.unpackbits(temp[::-1])[-1*self.nBaud:]
Daniel Valdez
En esta version se las funciones de LECTURA de rawdata y pdata operan satisfactoriamente.
 r122 self.code = 2.0*self.code - 1.0
if self.line5Function == RCfunction.FLIP:
self.flip1 = numpy.fromfile(fp,'<u4',1)
if self.line6Function == RCfunction.FLIP:
self.flip2 = numpy.fromfile(fp,'<u4',1)
endFp = self.size + startFp
jumpFp = endFp - fp.tell()
if jumpFp > 0:
fp.seek(jumpFp)
except:
return 0
return 1
def write(self, fp):
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,
self.prePulserAfter,
self.rangeIpp,
self.rangeTxA,
self.rangeTxB)
header = numpy.array(headerTuple,self.struct)
header.tofile(fp)
dynamic = self.dynamic
dynamic.tofile(fp)
return 1
class ProcessingHeader(Header):
size = None
dtype = None
blockSize = None
profilesPerBlock = None
dataBlocksPerFile = None
nWindows = None
processFlags = None
nCohInt = None
nIncohInt = None
totalSpectra = None
struct = None
flag_dc = None
flag_cspc = None
def __init__(self):
self.size = 0
Miguel Valdez
-Actualización de los nombres de los objetos systemHeader y radaraControllerHeader...
 r148 self.dtype = 0
Daniel Valdez
En esta version se las funciones de LECTURA de rawdata y pdata operan satisfactoriamente.
 r122 self.blockSize = 0
self.profilesPerBlock = 0
self.dataBlocksPerFile = 0
self.nWindows = 0
self.processFlags = 0
self.nCohInt = 0
self.nIncohInt = 0
self.totalSpectra = 0
self.struct = numpy.dtype([
('nSize','<u4'),
('nDataType','<u4'),
('nSizeOfDataBlock','<u4'),
('nProfilesperBlock','<u4'),
('nDataBlocksperFile','<u4'),
('nNumWindows','<u4'),
('nProcessFlags','<u4'),
('nCoherentIntegrations','<u4'),
('nIncoherentIntegrations','<u4'),
('nTotalSpectra','<u4')
])
self.samplingWindow = 0
self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
self.nHeights = 0
self.firstHeight = 0
self.deltaHeight = 0
self.samplesWin = 0
self.spectraComb = 0
Daniel Valdez
Version con Lectura de Pdata y RawData operando correctamente,tambien la Escritura de Rawdata....
 r124 self.nCode = None
self.code = None
self.nBaud = None
Daniel Valdez
En esta version se las funciones de LECTURA de rawdata y pdata operan satisfactoriamente.
 r122 self.shif_fft = False
self.flag_dc = False
self.flag_cspc = False
def read(self, fp):
try:
header = numpy.fromfile(fp,self.struct,1)
self.size = header['nSize'][0]
Miguel Valdez
-Actualización de los nombres de los objetos systemHeader y radaraControllerHeader...
 r148 self.dtype = header['nDataType'][0]
Daniel Valdez
En esta version se las funciones de LECTURA de rawdata y pdata operan satisfactoriamente.
 r122 self.blockSize = header['nSizeOfDataBlock'][0]
self.profilesPerBlock = header['nProfilesperBlock'][0]
self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
self.nWindows = header['nNumWindows'][0]
self.processFlags = header['nProcessFlags']
self.nCohInt = header['nCoherentIntegrations'][0]
self.nIncohInt = header['nIncoherentIntegrations'][0]
self.totalSpectra = header['nTotalSpectra'][0]
self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.nWindows)
self.nHeights = numpy.sum(self.samplingWindow['nsa'])
self.firstHeight = self.samplingWindow['h0'][0]
self.deltaHeight = self.samplingWindow['dh'][0]
self.samplesWin = self.samplingWindow['nsa']
self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
Daniel Valdez
Realizando cambios para escritura de rawdata
 r123 self.nCode = numpy.fromfile(fp,'<u4',1)
self.nBaud = numpy.fromfile(fp,'<u4',1)
self.code = numpy.fromfile(fp,'<f4',self.nCode*self.nBaud).reshape(self.nBaud,self.nCode)
Daniel Valdez
En esta version se las funciones de LECTURA de rawdata y pdata operan satisfactoriamente.
 r122
if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
self.shif_fft = True
else:
self.shif_fft = False
if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
self.flag_dc = True
nChannels = 0
nPairs = 0
pairList = []
for i in range( 0, self.totalSpectra*2, 2 ):
if self.spectraComb[i] == self.spectraComb[i+1]:
nChannels = nChannels + 1 #par de canales iguales
else:
nPairs = nPairs + 1 #par de canales diferentes
pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
self.flag_cspc = False
if nPairs > 0:
self.flag_cspc = True
except:
return 0
return 1
def write(self, fp):
headerTuple = (self.size,
Miguel Valdez
-Actualización de los nombres de los objetos systemHeader y radaraControllerHeader...
 r148 self.dtype,
Daniel Valdez
En esta version se las funciones de LECTURA de rawdata y pdata operan satisfactoriamente.
 r122 self.blockSize,
self.profilesPerBlock,
self.dataBlocksPerFile,
self.nWindows,
self.processFlags,
self.nCohInt,
self.nIncohInt,
self.totalSpectra)
header = numpy.array(headerTuple,self.struct)
header.tofile(fp)
if self.nWindows != 0:
sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
samplingWindow.tofile(fp)
if self.totalSpectra != 0:
spectraComb = numpy.array([],numpy.dtype('u1'))
spectraComb = self.spectraComb
spectraComb.tofile(fp)
if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
Daniel Valdez
avance de Escritura de Pdata, faltan probar con mas experimentos.
 r125 nCode = self.nCode #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
Daniel Valdez
Realizando cambios para escritura de rawdata
 r123 nCode.tofile(fp)
Daniel Valdez
En esta version se las funciones de LECTURA de rawdata y pdata operan satisfactoriamente.
 r122
Daniel Valdez
Realizando cambios para escritura de rawdata
 r123 nBaud = self.nBaud
nBaud.tofile(fp)
Daniel Valdez
En esta version se las funciones de LECTURA de rawdata y pdata operan satisfactoriamente.
 r122
Daniel Valdez
Realizando cambios para escritura de rawdata
 r123 code = self.code.reshape(nCode*nBaud)
Daniel Valdez
En esta version se las funciones de LECTURA de rawdata y pdata operan satisfactoriamente.
 r122 code.tofile(fp)
return 1
class RCfunction:
NONE=0
FLIP=1
CODE=2
SAMPLING=3
LIN6DIV256=4
SYNCHRO=5
class nCodeType:
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:
COHERENT_INTEGRATION = numpy.uint32(0x00000001)
DECODE_DATA = numpy.uint32(0x00000002)
SPECTRA_CALC = numpy.uint32(0x00000004)
INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
SHIFT_FFT_DATA = numpy.uint32(0x00000020)
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)
DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
DEFLIP_DATA = numpy.uint32(0x00010000)
DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
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)
EXP_NAME_ESP = numpy.uint32(0x00200000)
CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
OPERATION_MASK = numpy.uint32(0x0000003F)
DATATYPE_MASK = numpy.uint32(0x00000FC0)
DATAARRANGE_MASK = numpy.uint32(0x00007000)
Daniel Valdez
Nuevo Desarrollo SChain
 r119 ACQ_SYS_MASK = numpy.uint32(0x001C0000)