schain Commit - r124:5a0951cb35e4 · Jicamarca Repository

Version con Lectura de Pdata y RawData operando correctamente,tambien la Escritura de Rawdata....

Daniel Valdez -

r124:5a0951cb35e4

parent child

Context file:

r124:5a0951cb35e4

Collapse all files

schainpy2/Processing/SpectraProcessor.py created 644 +388 0

@@ -0,0 +1,388
	1	'''
	2	Created on Feb 7, 2012
	3
	4	@author $Author: murco $
	5	@version $Id: SpectraProcessor.py 119 2012-09-05 17:06:09Z murco $
	6	'''
	7	import os, sys
	8	import numpy
	9	import time
	10
	11	path = os.path.split(os.getcwd())[0]
	12	sys.path.append(path)
	13
	14	from Data.Spectra import Spectra
	15	from IO.SpectraIO import SpectraWriter
	16	#from Graphics.SpectraPlot import Spectrum
	17	#from JRONoise import Noise
	18
	19	class SpectraProcessor:
	20	'''
	21	classdocs
	22	'''
	23
	24	dataInObj = None
	25
	26	dataOutObj = None
	27
	28	noiseObj = None
	29
	30	integratorObjList = []
	31
	32	writerObjList = []
	33
	34	integratorObjIndex = None
	35
	36	writerObjIndex = None
	37
	38	profIndex = 0 # Se emplea cuando el objeto de entrada es un Voltage
	39
	40	# integratorObjList = []
	41	#
	42	# decoderObjList = []
	43	#
	44	# writerObjList = []
	45	#
	46	# plotterObjList = []
	47	#
	48	# integratorObjIndex = None
	49	#
	50	# decoderObjIndex = None
	51	#
	52	# writerObjIndex = None
	53	#
	54	# plotterObjIndex = None
	55	#
	56	# buffer = None
	57	#
	58	# profIndex = 0
	59	#
	60	# nFFTPoints = None
	61	#
	62	# nChannels = None
	63	#
	64	# nHeights = None
	65	#
	66	# nPairs = None
	67	#
	68	# pairList = None
	69
	70
	71	def __init__(self):
	72	'''
	73	Constructor
	74	'''
	75
	76	self.integratorObjIndex = None
	77	self.writerObjIndex = None
	78	self.integratorObjList = []
	79	self.writerObjList = []
	80	self.noiseObj = None
	81	self.buffer = None
	82	self.profIndex = 0
	83
	84	def setup(self, dataInObj=None, dataOutObj=None, nFFTPoints=None, pairList=None):
	85
	86	if dataInObj == None:
	87	raise ValueError, "This SpectraProcessor.setup() function needs dataInObj input variable"
	88
	89	if dataInObj.type == "Voltage":
	90	if nFFTPoints == None:
	91	raise ValueError, "This SpectraProcessor.setup() function needs nFFTPoints input variable"
	92	else:
	93	nFFTPoints = dataInObj.nFFTPoints
	94
	95	self.dataInObj = dataInObj
	96
	97	if dataOutObj == None:
	98	dataOutObj = Spectra()
	99
	100	self.dataOutObj = dataOutObj
	101
	102	# self.noiseObj = Noise() #aun no se incluye el objeto Noise()
	103
	104	##########################################
	105	# self.nFFTPoints = nFFTPoints
	106	# self.nChannels = self.dataInObj.nChannels
	107	# self.nHeights = self.dataInObj.nHeights
	108	# self.pairList = pairList
	109	# if pairList != None:
	110	# self.nPairs = len(pairList)
	111	# else:
	112	# self.nPairs = 0
	113	#
	114	# self.dataOutObj.heightList = self.dataInObj.heightList
	115	# self.dataOutObj.channelIndexList = self.dataInObj.channelIndexList
	116	# self.dataOutObj.m_BasicHeader = self.dataInObj.m_BasicHeader.copy()
	117	# self.dataOutObj.m_ProcessingHeader = self.dataInObj.m_ProcessingHeader.copy()
	118	# self.dataOutObj.m_RadarControllerHeader = self.dataInObj.m_RadarControllerHeader.copy()
	119	# self.dataOutObj.m_SystemHeader = self.dataInObj.m_SystemHeader.copy()
	120	#
	121	# self.dataOutObj.dataType = self.dataInObj.dataType
	122	# self.dataOutObj.nPairs = self.nPairs
	123	# self.dataOutObj.nChannels = self.nChannels
	124	# self.dataOutObj.nProfiles = self.nFFTPoints
	125	# self.dataOutObj.nHeights = self.nHeights
	126	# self.dataOutObj.nFFTPoints = self.nFFTPoints
	127	# #self.dataOutObj.data = None
	128	#
	129	# self.dataOutObj.m_SystemHeader.numChannels = self.nChannels
	130	# self.dataOutObj.m_SystemHeader.nProfiles = self.nFFTPoints
	131	#
	132	# self.dataOutObj.m_ProcessingHeader.totalSpectra = self.nChannels + self.nPairs
	133	# self.dataOutObj.m_ProcessingHeader.profilesPerBlock = self.nFFTPoints
	134	# self.dataOutObj.m_ProcessingHeader.numHeights = self.nHeights
	135	# self.dataOutObj.m_ProcessingHeader.shif_fft = True
	136	#
	137	# spectraComb = numpy.zeros( (self.nChannels+self.nPairs)*2,numpy.dtype('u1'))
	138	# k = 0
	139	# for i in range( 0,self.nChannels*2,2 ):
	140	# spectraComb[i] = k
	141	# spectraComb[i+1] = k
	142	# k += 1
	143	#
	144	# k *= 2
	145	#
	146	# if self.pairList != None:
	147	#
	148	# for pair in self.pairList:
	149	# spectraComb[k] = pair[0]
	150	# spectraComb[k+1] = pair[1]
	151	# k += 2
	152	#
	153	# self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
	154
	155	return self.dataOutObj
	156
	157	def init(self):
	158	#
	159	# self.nHeights = self.dataInObj.nHeights
	160	# self.dataOutObj.nHeights = self.nHeights
	161	# self.dataOutObj.heightList = self.dataInObj.heightList
	162	#
	163
	164	self.integratorObjIndex = 0
	165	self.writerObjIndex = 0
	166
	167	if self.dataInObj.type == "Voltage":
	168
	169	if self.buffer == None:
	170	self.buffer = numpy.zeros((self.nChannels,
	171	self.nFFTPoints,
	172	self.dataInObj.nHeights),
	173	dtype='complex')
	174
	175	self.buffer[:,self.profIndex,:] = self.dataInObj.data
	176	self.profIndex += 1
	177
	178	if self.profIndex == self.nFFTPoints:
	179	self.__getFft()
	180	self.dataOutObj.flagNoData = False
	181
	182	self.buffer = None
	183	self.profIndex = 0
	184	return
	185
	186	self.dataOutObj.flagNoData = True
	187
	188	return
	189
	190	#Other kind of data
	191	if self.dataInObj.type == "Spectra":
	192	self.dataOutObj.copy(self.dataInObj)
	193	self.dataOutObj.flagNoData = False
	194	return
	195
	196	raise ValueError, "The datatype is not valid"
	197
	198	def __getFft(self):
	199	"""
	200	Convierte valores de Voltaje a Spectra
	201
	202	Affected:
	203	self.dataOutObj.data_spc
	204	self.dataOutObj.data_cspc
	205	self.dataOutObj.data_dc
	206	self.dataOutObj.heightList
	207	self.dataOutObj.m_BasicHeader
	208	self.dataOutObj.m_ProcessingHeader
	209	self.dataOutObj.m_RadarControllerHeader
	210	self.dataOutObj.m_SystemHeader
	211	self.profIndex
	212	self.buffer
	213	self.dataOutObj.flagNoData
	214	self.dataOutObj.dataType
	215	self.dataOutObj.nPairs
	216	self.dataOutObj.nChannels
	217	self.dataOutObj.nProfiles
	218	self.dataOutObj.m_SystemHeader.numChannels
	219	self.dataOutObj.m_ProcessingHeader.totalSpectra
	220	self.dataOutObj.m_ProcessingHeader.profilesPerBlock
	221	self.dataOutObj.m_ProcessingHeader.numHeights
	222	self.dataOutObj.m_ProcessingHeader.spectraComb
	223	self.dataOutObj.m_ProcessingHeader.shif_fft
	224	"""
	225
	226	if self.dataInObj.flagNoData:
	227	return 0
	228
	229	fft_volt = numpy.fft.fft(self.buffer,axis=1)
	230	dc = fft_volt[:,0,:]
	231
	232	#calculo de self-spectra
	233	fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
	234	spc = fft_volt * numpy.conjugate(fft_volt)
	235	spc = spc.real
	236
	237	blocksize = 0
	238	blocksize += dc.size
	239	blocksize += spc.size
	240
	241	cspc = None
	242	pairIndex = 0
	243	if self.pairList != None:
	244	#calculo de cross-spectra
	245	cspc = numpy.zeros((self.nPairs, self.nFFTPoints, self.nHeights), dtype='complex')
	246	for pair in self.pairList:
	247	cspc[pairIndex,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
	248	pairIndex += 1
	249	blocksize += cspc.size
	250
	251	self.dataOutObj.data_spc = spc
	252	self.dataOutObj.data_cspc = cspc
	253	self.dataOutObj.data_dc = dc
	254	self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
	255	self.dataOutObj.m_BasicHeader.utc = self.dataInObj.m_BasicHeader.utc
	256
	257	# self.getNoise()
	258
	259	def addWriter(self, wrpath, profilesPerBlock, blocksPerFile):
	260	objWriter = SpectraWriter(self.dataOutObj, pairList)
	261	objWriter.setup(wrpath, profilesPerBlock, blocksPerFile)
	262	self.writerObjList.append(objWriter)
	263
	264	def addIntegrator(self,N,timeInterval):
	265
	266	objIncohInt = IncoherentIntegration(N,timeInterval)
	267	self.integratorObjList.append(objIncohInt)
	268
	269	def writeData(self, wrpath, profilesPerBlock, blocksPerFile):
	270	if self.dataOutObj.flagNoData:
	271	return 0
	272
	273	if len(self.writerObjList) <= self.writerObjIndex:
	274	self.addWriter(wrpath, profilesPerBlock, blocksPerFile)
	275
	276	self.writerObjList[self.writerObjIndex].putData()
	277
	278	self.writerObjIndex += 1
	279
	280	def integrator(self, N=None, timeInterval=None):
	281
	282	if self.dataOutObj.flagNoData:
	283	return 0
	284
	285	if len(self.integratorObjList) <= self.integratorObjIndex:
	286	self.addIntegrator(N,timeInterval)
	287
	288	myIncohIntObj = self.integratorObjList[self.integratorObjIndex]
	289	myIncohIntObj.exe(data=self.dataOutObj.data_spc,timeOfData=self.dataOutObj.m_BasicHeader.utc)
	290
	291	if myIncohIntObj.isReady:
	292	self.dataOutObj.data_spc = myIncohIntObj.data
	293	self.dataOutObj.nAvg = myIncohIntObj.navg
	294	self.dataOutObj.m_ProcessingHeader.incoherentInt = self.dataInObj.m_ProcessingHeader.incoherentInt*myIncohIntObj.navg
	295	#print "myIncohIntObj.navg: ",myIncohIntObj.navg
	296	self.dataOutObj.flagNoData = False
	297
	298	"""Calcular el ruido"""
	299	self.getNoise()
	300	else:
	301	self.dataOutObj.flagNoData = True
	302
	303	self.integratorObjIndex += 1
	304
	305
	306
	307
	308	class IncoherentIntegration:
	309
	310	integ_counter = None
	311	data = None
	312	navg = None
	313	buffer = None
	314	nIncohInt = None
	315
	316	def __init__(self, N = None, timeInterval = None):
	317	"""
	318	N
	319	timeInterval - interval time [min], integer value
	320	"""
	321
	322	self.data = None
	323	self.navg = None
	324	self.buffer = None
	325	self.timeOut = None
	326	self.exitCondition = False
	327	self.isReady = False
	328	self.nIncohInt = N
	329	self.integ_counter = 0
	330	if timeInterval!=None:
	331	self.timeIntervalInSeconds = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
	332
	333	if ((timeInterval==None) and (N==None)):
	334	print 'N = None ; timeInterval = None'
	335	sys.exit(0)
	336	elif timeInterval == None:
	337	self.timeFlag = False
	338	else:
	339	self.timeFlag = True
	340
	341
	342	def exe(self,data,timeOfData):
	343	"""
	344	data
	345
	346	timeOfData [seconds]
	347	"""
	348
	349	if self.timeFlag:
	350	if self.timeOut == None:
	351	self.timeOut = timeOfData + self.timeIntervalInSeconds
	352
	353	if timeOfData < self.timeOut:
	354	if self.buffer == None:
	355	self.buffer = data
	356	else:
	357	self.buffer = self.buffer + data
	358	self.integ_counter += 1
	359	else:
	360	self.exitCondition = True
	361
	362	else:
	363	if self.integ_counter < self.nIncohInt:
	364	if self.buffer == None:
	365	self.buffer = data
	366	else:
	367	self.buffer = self.buffer + data
	368
	369	self.integ_counter += 1
	370
	371	if self.integ_counter == self.nIncohInt:
	372	self.exitCondition = True
	373
	374	if self.exitCondition:
	375	self.data = self.buffer
	376	self.navg = self.integ_counter
	377	self.isReady = True
	378	self.buffer = None
	379	self.timeOut = None
	380	self.integ_counter = 0
	381	self.exitCondition = False
	382
	383	if self.timeFlag:
	384	self.buffer = data
	385	self.timeOut = timeOfData + self.timeIntervalInSeconds
	386	else:
	387	self.isReady = False
	388	No newline at end of file

schainpy2/Data/JROData.py +7 0

             import os, sys
             import copy
             import numpy
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from IO.JROHeader import SystemHeader, RadarControllerHeader
             class JROData:
             #    m_BasicHeader = BasicHeader()
             #    m_ProcessingHeader = ProcessingHeader()
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
             #    data = None
                 type = None
                 dtype = None
                 nChannels = None
                 nHeights = None
                 nProfiles = None
                 heightList = None
                 channelList = None
                 channelIndexList = None
                 flagNoData = False
                 flagTimeBlock = False
                 dataUtcTime = None
                 nCode = None
                 nBaud = None
                 code = None
+                flagDecodeData = True #asumo q la data esta decodificada
+                flagDeflipData = True #asumo q la data esta sin flip
+                flagShiftFFT = False
                 def __init__(self):
                     raise ValueError, "This class has not been implemented"
                 def copy(self, inputObj=None):
                     if inputObj == None:
                         return copy.deepcopy(self)
                     for key in inputObj.__dict__.keys():
                         self.__dict__[key] = inputObj.__dict__[key]
                 def deepcopy(self):
                     return copy.deepcopy(self)

schainpy2/IO/JRODataIO.py +13 -15

             import os, sys
             import glob
             import time
             import numpy
             import fnmatch
             import time, datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from JROHeader import *
             from Data.JROData import JROData
             def isNumber(str):
                 """
                 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
                 Excepciones:
                     Si un determinado string no puede ser convertido a numero
                 Input:
                     str, string al cual se le analiza para determinar si convertible a un numero o no
                 Return:
                     True    :    si el string es uno numerico
                     False   :    no es un string numerico
                 """
                 try:
                     float( str )
                     return True
                 except:
                     return False
             def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
                 """
                 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startUTSeconds      :    fecha inicial del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                     endUTSeconds        :    fecha final del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 basicHeaderObj = BasicHeader()
                 try:
                     fp = open(filename,'rb')
                 except:
                     raise IOError, "The file %s can't be opened" %(filename)
                 sts = basicHeaderObj.read(fp)
                 fp.close()
                 if not(sts):
                     print "Skipping the file %s because it has not a valid header" %(filename)
                     return 0
                 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
                     return 0
                 return 1
             class JRODataIO:
                 c = 3E8
                 basicHeaderObj = BasicHeader()
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
                 processingHeaderObj = ProcessingHeader()
                 online = 0
                 dtype = None
                 pathList = []
                 filenameList = []
                 filename = None
                 ext = None
                 flagNoMoreFiles = 0
                 flagIsNewFile = 1
                 flagTimeBlock = 0
                 flagIsNewBlock = 0
                 fp = None
                 firstHeaderSize = 0
                 basicHeaderSize = 24
                 versionFile = 1103
                 fileSize = None
                 ippSeconds = None
                 fileSizeByHeader = None
                 fileIndex = None
                 profileIndex = None
                 blockIndex = None
                 nTotalBlocks = None
                 maxTimeStep = 30
                 lastUTTime = None
                 datablock = None
                 dataOutObj = None
                 blocksize = None
                 def __init__(self):
                     pass
             class JRODataReader(JRODataIO):
                 nReadBlocks = 0
                 def __init__(self):
                     pass
                 def createObjByDefault(self):
                     """
                     """
                     raise ValueError, "This method has not been implemented"
                 def getBlockDimension(self):
                     raise ValueError, "No implemented"
                 def __searchFilesOffLine(self,
                                         path,
                                         startDate,
                                         endDate,
                                         startTime=datetime.time(0,0,0),
                                         endTime=datetime.time(23,59,59),
                                         set=None,
                                         expLabel="",
                                         ext=".r"):
                     dirList = []
                     for thisPath in os.listdir(path):
                         if os.path.isdir(os.path.join(path,thisPath)):
                             dirList.append(thisPath)
                     if not(dirList):
                         return None, None
                     pathList = []
                     dateList = []
                     thisDate = startDate
                     while(thisDate <= endDate):
                         year = thisDate.timetuple().tm_year
                         doy = thisDate.timetuple().tm_yday
                         match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
                         if len(match) == 0:
                             thisDate += datetime.timedelta(1)
                             continue
                         pathList.append(os.path.join(path,match[0],expLabel))
                         dateList.append(thisDate)
                         thisDate += datetime.timedelta(1)
                     filenameList = []
                     for index in range(len(pathList)):
                         thisPath = pathList[index]
                         fileList = glob.glob1(thisPath, "*%s" %ext)
                         fileList.sort()
                         #Busqueda de datos en el rango de horas indicados
                         thisDate = dateList[index]
                         startDT = datetime.datetime.combine(thisDate, startTime)
                         endDT = datetime.datetime.combine(thisDate, endTime)
                         startUtSeconds = time.mktime(startDT.timetuple())
                         endUtSeconds = time.mktime(endDT.timetuple())
                         for file in fileList:
                             filename = os.path.join(thisPath,file)
                             if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
                                 filenameList.append(filename)
                     if not(filenameList):
                         return None, None
                     self.filenameList = filenameList
                     return pathList, filenameList
                 def setup(self,dataOutObj=None,
                             path=None,
                             startDate=None,
                             endDate=None,
                             startTime=datetime.time(0,0,0),
                             endTime=datetime.time(23,59,59),
                             set=0,
                             expLabel = "",
                             ext = None,
                             online = 0):
                     if path == None:
                         raise ValueError, "The path is not valid"
                     if ext == None:
                         ext = self.ext
                     if dataOutObj == None:
                         dataOutObj = self.createObjByDefault()
                     self.dataOutObj = dataOutObj
                     if online:
                         pass
                     else:
                         print "Searching file in offline mode"
                         pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)
                         if not(pathList):
                             print "No files in range: %s - %s"%(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
                             return None
                         self.fileIndex = -1
                         self.pathList = pathList
                         self.filenameList = filenameList
                     self.online = online
                     ext = ext.lower()
                     self.ext = ext
                     if not(self.setNextFile()):
                         if (startDate!=None) and (endDate!=None):
                             print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
                         elif startDate != None:
                             print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
                         else:
                             print "No files"
                         return None
             #        self.updateDataHeader()
                     return self.dataOutObj
                 def __setNextFileOffline(self):
                     idFile = self.fileIndex
                     while (True):
                         idFile += 1
                         if not(idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
                             print "No more Files"
                             return 0
                         filename = self.filenameList[idFile]
                         if not(self.__verifyFile(filename)):
                             continue
                         fileSize = os.path.getsize(filename)
                         fp = open(filename,'rb')
                         break
                     self.flagIsNewFile = 1
                     self.fileIndex = idFile
                     self.filename = filename
                     self.fileSize = fileSize
                     self.fp = fp
                     print "Setting the file: %s"%self.filename
                     return 1
                 def setNextFile(self):
                     if self.fp != None:
                         self.fp.close()
                     if self.online:
                         newFile = self.__setNextFileOnline()
                     else:
                         newFile = self.__setNextFileOffline()
                     if not(newFile):
                         return 0
                     self.__readFirstHeader()
                     self.nReadBlocks = 0
                     return 1
                 def __setNewBlock(self):
                     if self.fp == None:
                         return 0
                     if self.flagIsNewFile:
                         return 1
                     self.lastUTTime = self.basicHeaderObj.utc
                     currentSize = self.fileSize - self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     if (currentSize >= neededSize):
                         self.__rdBasicHeader()
                         return 1
                     if not(self.setNextFile()):
                         return 0
                     deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
                     self.flagTimeBlock = 0
                     if deltaTime > self.maxTimeStep:
                         self.flagTimeBlock = 1
                     return 1
                 def readNextBlock(self):
                     if not(self.__setNewBlock()):
                         return 0
                     if not(self.readBlock()):
                         return 0
                     return 1
                 def __rdProcessingHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.processingHeaderObj.read(fp)
                 def __rdRadarControllerHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.radarControllerHeaderObj.read(fp)
                 def __rdSystemHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.systemHeaderObj.read(fp)
                 def __rdBasicHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.basicHeaderObj.read(fp)
                 def __readFirstHeader(self):
                     self.__rdBasicHeader()
                     self.__rdSystemHeader()
                     self.__rdRadarControllerHeader()
                     self.__rdProcessingHeader()
                     self.firstHeaderSize = self.basicHeaderObj.size
                     datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
                     if datatype == 0:
                         datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
                     elif datatype == 1:
                         datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
                     elif datatype == 2:
                         datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
                     elif datatype == 3:
                         datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
                     elif datatype == 4:
                         datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
                     elif datatype == 5:
                         datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
                     else:
                         raise ValueError, 'Data type was not defined'
                     self.dtype = datatype_str
                     self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
                     self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
             #        self.dataOutObj.channelList = numpy.arange(self.systemHeaderObj.numChannels)
             #        self.dataOutObj.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
                     self.getBlockDimension()
                 def __verifyFile(self, filename, msgFlag=True):
                     msg = None
                     try:
                         fp = open(filename, 'rb')
                         currentPosition = fp.tell()
                     except:
                         if msgFlag:
                             print "The file %s can't be opened" % (filename)
                         return False
                     neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
                     if neededSize == 0:
                         basicHeaderObj = BasicHeader()
                         systemHeaderObj = SystemHeader()
                         radarControllerHeaderObj = RadarControllerHeader()
                         processingHeaderObj = ProcessingHeader()
                         try:
                             if not( basicHeaderObj.read(fp) ): raise ValueError
                             if not( systemHeaderObj.read(fp) ): raise ValueError
                             if not( radarControllerHeaderObj.read(fp) ): raise ValueError
                             if not( processingHeaderObj.read(fp) ): raise ValueError
                             data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
                             neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
                         except:
                             if msgFlag:
                                 print "\tThe file %s is empty or it hasn't enough data" % filename
                             fp.close()
                             return False
                     else:
                         msg = "\tSkipping the file %s due to it hasn't enough data" %filename
                     fp.close()
                     fileSize = os.path.getsize(filename)
                     currentSize = fileSize - currentPosition
                     if currentSize < neededSize:
                         if msgFlag and (msg != None):
                             print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
                         return False
                     return True
                 def getData():
                     pass
                 def hasNotDataInBuffer():
                     pass
                 def readBlock():
                     pass
             class JRODataWriter(JRODataIO):
                 """
                 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 blockIndex = 0
                 path = None
                 setFile = None
                 profilesPerBlock = None
                 blocksPerFile = None
+                nWriteBlocks = 0
                 def __init__(self, dataOutObj=None):
                     raise ValueError, "Not implemented"
                 def hasAllDataInBuffer(self):
                     raise ValueError, "Not implemented"
                 def setBlockDimension(self):
                     raise ValueError, "Not implemented"
                 def writeBlock(self):
                     raise ValueError, "No implemented"
                 def putData(self):
                     raise ValueError, "No implemented"
                 def __writeFirstHeader(self):
                     """
                     Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
                     Affected:
                         __dataType
                     Return:
                         None
                     """
             #        CALCULAR PARAMETROS
-                    sizeLongHeader = 0#XXXX
+                    sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
-                    self.basicHeaderObj.size = 24 + sizeLongHeader
+                    self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
                     self.__writeBasicHeader()
                     self.__wrSystemHeader()
                     self.__wrRadarControllerHeader()
                     self.__wrProcessingHeader()
                     self.dtype = self.dataOutObj.dtype
                 def __writeBasicHeader(self, fp=None):
                     """
                     Escribe solo el Basic header en el file creado
                     Return:
                         None
                     """
                     if fp == None:
                         fp = self.fp
-                    self.dataOutObj.basicHeaderObj.write(fp)
+                    self.basicHeaderObj.write(fp)
                 def __wrSystemHeader(self, fp=None):
                     """
                     Escribe solo el System header en el file creado
                     Return:
                         None
                     """
                     if fp == None:
                         fp = self.fp
-                    self.dataOutObj.systemHeaderObj.write(fp)
+                    self.systemHeaderObj.write(fp)
                 def __wrRadarControllerHeader(self, fp=None):
                     """
                     Escribe solo el RadarController header en el file creado
                     Return:
                         None
                     """
                     if fp == None:
                         fp = self.fp
-                    self.dataOutObj.radarControllerHeaderObj.write(fp)
+                    self.radarControllerHeaderObj.write(fp)
                 def __wrProcessingHeader(self, fp=None):
                     """
                     Escribe solo el Processing header en el file creado
                     Return:
                         None
                     """
                     if fp == None:
                         fp = self.fp
-                    self.dataOutObj.processingHeaderObj.write(fp)
+                    self.processingHeaderObj.write(fp)
                 def setNextFile(self):
                     """
                     Determina el siguiente file que sera escrito
                     Affected:
                         self.filename
                         self.subfolder
                         self.fp
                         self.setFile
                         self.flagIsNewFile
                     Return:
 :    Si el archivo no puede ser escrito
 :    Si el archivo esta listo para ser escrito
                     """
                     ext = self.ext
                     path = self.path
                     if self.fp != None:
                         self.fp.close()
                     timeTuple = time.localtime( self.dataOutObj.dataUtcTime)
                     subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
                     doypath = os.path.join( path, subfolder )
                     if not( os.path.exists(doypath) ):
                         os.mkdir(doypath)
                         self.setFile = -1 #inicializo mi contador de seteo
                     else:
                         filesList = os.listdir( doypath )
                         if len( filesList ) > 0:
                             filesList = sorted( filesList, key=str.lower )
                             filen = filesList[-1]
                             # el filename debera tener el siguiente formato
                             # 0 1234 567 89A BCDE (hex)
                             # x YYYY DDD SSS .ext
                             if isNumber( filen[8:11] ):
                                 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
                             else:
                                 self.setFile = -1
                         else:
                             self.setFile = -1 #inicializo mi contador de seteo
                     setFile = self.setFile
                     setFile += 1
                     file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
                                                     timeTuple.tm_year,
                                                     timeTuple.tm_yday,
                                                     setFile,
                                                     ext )
                     filename = os.path.join( path, subfolder, file )
                     fp = open( filename,'wb' )
                     self.blockIndex = 0
                     #guardando atributos
                     self.filename = filename
                     self.subfolder = subfolder
                     self.fp = fp
                     self.setFile = setFile
                     self.flagIsNewFile = 1
+                    self.getDataHeader()
                     print 'Writing the file: %s'%self.filename
                     self.__writeFirstHeader()
                     return 1
                 def __setNewBlock(self):
                     """
                     Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
                     Return:
 :    si no pudo escribir nada
 :    Si escribio el Basic el First Header
                     """
                     if self.fp == None:
                         self.setNextFile()
                     if self.flagIsNewFile:
                         return 1
                     if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
                         self.__writeBasicHeader()
                         return 1
                     if not( self.setNextFile() ):
                         return 0
                     return 1
                 def writeNextBlock(self):
                     """
                     Selecciona el bloque siguiente de datos y los escribe en un file
                     Return:
 :    Si no hizo pudo escribir el bloque de datos
 :    Si no pudo escribir el bloque de datos
                     """
                     if not( self.__setNewBlock() ):
                         return 0
                     self.writeBlock()
                     return 1
                 def getDataHeader(self):
                     """Obtiene una copia del First Header  Affected: self.basicHeaderObj     self.
                     systemHeaderObj self.radarControllerHeaderObj     self.processingHeaderObj self.
                     dtype  Return:     None
                     """
                     raise ValueError, "No implemented"
                 def setup(self, path, profilesPerBlock, blocksPerFile, set=0, ext=None):
                     """
                     Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
                     Inputs:
                         path      :    el path destino en el cual se escribiran los files a crear
                         format    :    formato en el cual sera salvado un file
                         set       :    el setebo del file
                     Return:
 :    Si no realizo un buen seteo
 :    Si realizo un buen seteo
                     """
                     if ext == None:
                         ext = self.ext
                     ext = ext.lower()
                     self.ext = ext
                     self.path = path
                     self.setFile = set - 1
                     self.profilesPerBlock = profilesPerBlock
                     self.blocksPerFile = blocksPerFile
+                    if not(self.setNextFile()):
+                        print "There isn't a next file"
+                        return 0
-                    self.getDataHeader()
                     self.setBlockDimension()
-                    if not( self.setNextFile() ):
-                        print "There isn't a next file"
-                        return 0
                     return 1

schainpy2/IO/JROHeader.py +3 -3

             '''
             Created on 23/01/2012
             @author $Author: vsarmiento $
             @version $Id: HeaderIO.py 37 2012-03-26 22:55:13Z vsarmiento $
             '''
             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
                     self.nCode = None
                     self.nBaud = None
                     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:
                             self.nCode = numpy.fromfile(fp,'<u4',1)
                             self.nBaud = numpy.fromfile(fp,'<u4',1)
                             self.code = numpy.empty([self.nCode,self.nBaud],dtype='u1')
                             tempList = []
                             for ic in range(self.nCode):
                                 temp = numpy.fromfile(fp,'u1',4*numpy.ceil(self.nBaud/32.))
                                 tempList.append(temp)
                                 self.code[ic] = numpy.unpackbits(temp[::-1])[-1*self.nBaud:]
                             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
                     self.dataType = 0
                     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
-                    self.nCode = 0
+                    self.nCode = None
-                    self.code = 0
+                    self.code = None
-                    self.nBaud = 0
+                    self.nBaud = None
                     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]
                         self.dataType = header['nDataType'][0]
                         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):
                             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)
                         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,
                                    self.dataType,
                                    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:
                         nCode = self.nCode
                         nCode.tofile(fp)
                         nBaud = self.nBaud
                         nBaud.tofile(fp)
                         code = self.code.reshape(nCode*nBaud)
                         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)
                 ACQ_SYS_MASK = numpy.uint32(0x001C0000)

schainpy2/IO/SpectraIO.py +214 -40

             '''
             File: SpectraIO.py
             Created on 20/02/2012
             @author $Author: dsuarez $
             @version $Id: SpectraIO.py 110 2012-07-19 15:18:18Z dsuarez $
             '''
             import os, sys
             import numpy
             import glob
             import fnmatch
             import time, datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from IO.JROHeader import *
             from Data.Spectra import Spectra
             from JRODataIO import JRODataReader
             from JRODataIO import JRODataWriter
             from JRODataIO import isNumber
             class SpectraReader(JRODataReader):
                 """
                 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
                 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
                                     paresCanalesIguales    * alturas * perfiles  (Self Spectra)
                                     paresCanalesDiferentes * alturas * perfiles  (Cross Spectra)
                                     canales * alturas                            (DC Channels)
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
                 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
                 Example:
                     dpath = "/home/myuser/data"
                     startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
                     endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
                     readerObj = SpectraReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         readerObj.getData()
                         print readerObj.dataOutObj.data
                         if readerObj.flagNoMoreFiles:
                             break
                 """
                 pts2read_SelfSpectra = 0
                 pts2read_CrossSpectra = 0
                 pts2read_DCchannels = 0
                 ext = ".pdata"
                 optchar = "P"
                 dataOutObj = None
                 nRdChannels = None
                 nRdPairs = None
                 rdPairList = []
                 def __init__(self, dataOutObj=None):
                     """
                     Inicializador de la clase SpectraReader para la lectura de datos de espectros.
                     Inputs:
                         dataOutObj    :    Objeto de la clase Spectra. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           bloque de datos.
                                           Si este parametro no es pasado se creara uno internamente.
                     Affected:
                         self.dataOutObj
                     Return      : None
                     """
                     self.pts2read_SelfSpectra = 0
                     self.pts2read_CrossSpectra = 0
                     self.pts2read_DCchannels = 0
                     self.datablock = None
                     self.utc = None
                     self.ext = ".pdata"
                     self.optchar = "P"
                     self.basicHeaderObj = BasicHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.online = 0
                     self.fp = None
                     self.idFile = None
                     self.dtype = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.filename = None
                     self.fileSize = None
                     self.firstHeaderSize = 0
                     self.basicHeaderSize = 24
                     self.pathList = []
                     self.lastUTTime = 0
                     self.maxTimeStep = 30
                     self.flagNoMoreFiles = 0
                     self.set = 0
                     self.path = None
                     self.delay  = 3   #seconds
                     self.nTries = 3  #quantity tries
                     self.nFiles = 3   #number of files for searching
                     self.nReadBlocks = 0
                     self.flagIsNewFile = 1
                     self.ippSeconds = 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     self.nTotalBlocks = 0
                     self.blocksize = 0
                 def createObjByDefault(self):
                     dataObj = Spectra()
                     return dataObj
                 def __hasNotDataInBuffer(self):
                     return 1
                 def getBlockDimension(self):
                     """
                     Obtiene la cantidad de puntos a leer por cada bloque de datos
                     Affected:
                         self.nRdChannels
                         self.nRdPairs
                         self.pts2read_SelfSpectra
                         self.pts2read_CrossSpectra
                         self.pts2read_DCchannels
                         self.blocksize
                         self.dataOutObj.nChannels
                         self.dataOutObj.nPairs
                     Return:
                         None
                     """
                     self.nRdChannels = 0
                     self.nRdPairs = 0
                     self.rdPairList = []
-                    for i in range( 0, self.processingHeaderObj.totalSpectra*2, 2 ):
+                    for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
                         if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
-                            self.nRdChannels = self.nRdChannels + 1   #par de canales iguales
+                            self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
                         else:
                             self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
-                            self.rdPairList.append( (self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]) )
+                            self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
                     pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
                     self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
                     self.blocksize = self.pts2read_SelfSpectra
                     if self.processingHeaderObj.flag_cspc:
                         self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
                         self.blocksize += self.pts2read_CrossSpectra
                     if self.processingHeaderObj.flag_dc:
                         self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)
                         self.blocksize += self.pts2read_DCchannels
             #        self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
                 def readBlock(self):
                     """
                     Lee el bloque de datos desde la posicion actual del puntero del archivo
                     (self.fp) y actualiza todos los parametros relacionados al bloque de datos
                     (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
                     es seteado a 0
                     Return: None
                     Variables afectadas:
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Exceptions:
                         Si un bloque leido no es un bloque valido
                     """
                     blockOk_flag = False
                     fpointer = self.fp.tell()
                     spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )
                     spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
                     if self.processingHeaderObj.flag_cspc:
                         cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )
                         cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
                     if self.processingHeaderObj.flag_dc:
                         dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
                         dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D
                     if not(self.processingHeaderObj.shif_fft):
                         spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                         if self.processingHeaderObj.flag_cspc:
                             cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                     spc = numpy.transpose( spc, (0,2,1) )
                     self.data_spc = spc
                     if self.processingHeaderObj.flag_cspc:
                         cspc = numpy.transpose( cspc, (0,2,1) )
                         self.data_cspc = cspc['real'] + cspc['imag']*1j
                     else:
                         self.data_cspc = None
                     if self.processingHeaderObj.flag_dc:
                         self.data_dc = dc['real'] + dc['imag']*1j
                     else:
                         self.data_dc = None
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def getData(self):
                     """
                     Copia el buffer de lectura a la clase "Spectra",
                     con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
                     lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
                     Return:
 :    Si no hay mas archivos disponibles
 :    Si hizo una buena copia del buffer
                     Affected:
                         self.dataOutObj
                         self.flagTimeBlock
                         self.flagIsNewBlock
                     """
                     if self.flagNoMoreFiles: return 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not( self.readNextBlock() ):
                             return 0
             #            self.updateDataHeader()
                     if self.flagNoMoreFiles == 1:
                         print 'Process finished'
                         return 0
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.data_dc == None:
                         self.dataOutObj.flagNoData = True
                         return 0
                     self.dataOutObj.data_spc = self.data_spc
                     self.dataOutObj.data_cspc = self.data_cspc
                     self.dataOutObj.data_dc = self.data_dc
                     self.dataOutObj.flagTimeBlock = self.flagTimeBlock
                     self.dataOutObj.flagNoData = False
                     self.dataOutObj.dtype = self.dtype
                     self.dataOutObj.nChannels = self.nRdChannels
                     self.dataOutObj.nPairs = self.nRdPairs
                     self.dataOutObj.pairsList = self.rdPairList
                     self.dataOutObj.nHeights = self.processingHeaderObj.nHeights
                     self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
                     self.dataOutObj.nFFTPoints = self.processingHeaderObj.profilesPerBlock
                     self.dataOutObj.nIncohInt = self.processingHeaderObj.nIncohInt
                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
                     self.dataOutObj.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
                     self.dataOutObj.channelList = range(self.systemHeaderObj.nChannels)
                     self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
                     self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc #+ self.profileIndex * self.ippSeconds
+                    self.dataOutObj.flagShiftFFT = self.processingHeaderObj.shif_fft
             #        self.profileIndex += 1
                     self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                     return 1
             class SpectraWriter(JRODataWriter):
                 """
                 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
+                ext = ".pdata"
+                optchar = "P"
                 shape_spc_Buffer = None
                 shape_cspc_Buffer = None
                 shape_dc_Buffer = None
-                dataOutObj = None
+                data_spc = None
+                data_cspc = None
+                data_dc = None
+                wrPairList = []
+                nWrPairs = 0
+                nWrChannels = 0
+            #    dataOutObj = None
                 def __init__(self, dataOutObj=None):
                     """
                     Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
                     Affected:
                         self.dataOutObj
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj
                     Return: None
                     """
                     if dataOutObj == None:
                         dataOutObj = Spectra()
                     if not( isinstance(dataOutObj, Spectra) ):
                         raise ValueError, "in SpectraReader, dataOutObj must be an Spectra class object"
                     self.dataOutObj = dataOutObj
-                    self.ext = ".pdata"
-                    self.optchar = "P"
-                    self.shape_spc_Buffer = None
-                    self.shape_cspc_Buffer = None
-                    self.shape_dc_Buffer = None
-                    self.data_spc = None
-                    self.data_cspc = None
-                    self.data_dc = None
-                    ####################################
-                    self.fp = None
-                    self.nWriteBlocks = 0
+                    self.nTotalBlocks = 0
-                    self.flagIsNewFile = 1
+                    self.nWrChannels = self.dataOutObj.nChannels
-                    self.nTotalBlocks = 0
+            #        if len(pairList) > 0:
+            #            self.wrPairList = pairList
+            #
+            #            self.nWrPairs = len(pairList)
-                    self.flagIsNewBlock = 0
+                    self.wrPairList = self.dataOutObj.pairList
-                    self.flagNoMoreFiles = 0
+                    self.nWrPairs = self.dataOutObj.nPairs
-                    self.setFile = None
-                    self.dtype = None
-                    self.path = None
-                    self.noMoreFiles = 0
-                    self.filename = None
+            #        self.data_spc = None
-                    self.basicHeaderObj = BasicHeader()
+            #        self.data_cspc = None
+            #        self.data_dc = None
-                    self.systemHeaderObj = SystemHeader()
+            #        self.fp = None
-                    self.radarControllerHeaderObj = RadarControllerHeader()
+            #        self.flagIsNewFile = 1
-                    self.processingHeaderObj = ProcessingHeader()
+            #        self.nTotalBlocks = 0
+            #
+            #        self.flagIsNewBlock = 0
+            #
+            #        self.flagNoMoreFiles = 0
+            #
+            #        self.setFile = None
+            #
+            #        self.dtype = None
+            #
+            #        self.path = None
+            #
+            #        self.noMoreFiles = 0
+            #
+            #        self.filename = None
+            #
+            #        self.basicHeaderObj = BasicHeader()
+            #
+            #        self.systemHeaderObj = SystemHeader()
+            #
+            #        self.radarControllerHeaderObj = RadarControllerHeader()
+            #
+            #        self.processingHeaderObj = ProcessingHeader()
                 def hasAllDataInBuffer(self):
                     return 1
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     Affected:
                         self.shape_spc_Buffer
                         self.shape_cspc_Buffer
                         self.shape_dc_Buffer
                     Return: None
                     """
                     self.shape_spc_Buffer = (self.dataOutObj.nChannels,
                                              self.processingHeaderObj.nHeights,
                                              self.processingHeaderObj.profilesPerBlock)
                     self.shape_cspc_Buffer = (self.dataOutObj.nPairs,
                                               self.processingHeaderObj.nHeights,
                                               self.processingHeaderObj.profilesPerBlock)
                     self.shape_dc_Buffer = (self.systemHeaderObj.nChannels,
                                             self.processingHeaderObj.nHeights)
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.nWriteBlocks
                     Return: None
                     """
                     spc = numpy.transpose( self.data_spc, (0,2,1) )
                     if not( self.processingHeaderObj.shif_fft ):
                         spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                     data = spc.reshape((-1))
                     data.tofile(self.fp)
                     if self.data_cspc != None:
                         data = numpy.zeros( self.shape_cspc_Buffer, self.dtype )
                         cspc = numpy.transpose( self.data_cspc, (0,2,1) )
                         if not( self.processingHeaderObj.shif_fft ):
                             cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                         data['real'] = cspc.real
                         data['imag'] = cspc.imag
                         data = data.reshape((-1))
                         data.tofile(self.fp)
                     data = numpy.zeros( self.shape_dc_Buffer, self.dtype )
                     dc = self.data_dc
                     data['real'] = dc.real
                     data['imag'] = dc.imag
                     data = data.reshape((-1))
                     data.tofile(self.fp)
                     self.data_spc.fill(0)
                     self.data_dc.fill(0)
                     if self.data_cspc != None:
                         self.data_cspc.fill(0)
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nWriteBlocks += 1
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
                     self.flagIsNewBlock = 0
                     if self.dataOutObj.flagNoData:
                         return 0
                     if self.dataOutObj.flagTimeBlock:
                         self.data_spc.fill(0)
                         self.data_cspc.fill(0)
                         self.data_dc.fill(0)
                         self.setNextFile()
                     self.data_spc = self.dataOutObj.data_spc
                     self.data_cspc = self.dataOutObj.data_cspc
                     self.data_dc = self.dataOutObj.data_dc
                     # #self.processingHeaderObj.dataBlocksPerFile)
                     if self.hasAllDataInBuffer():
                         self.getDataHeader()
                         self.writeNextBlock()
                     if self.flagNoMoreFiles:
                         #print 'Process finished'
                         return 0
-                    return 1
  No newline at end of file
+                    return 1
+                def __getProcessFlags(self):
+                    processFlags = 0
+                    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')])
+                    dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
+                    datatypeValueList =  [PROCFLAG.DATATYPE_CHAR,
+                                       PROCFLAG.DATATYPE_SHORT,
+                                       PROCFLAG.DATATYPE_LONG,
+                                       PROCFLAG.DATATYPE_INT64,
+                                       PROCFLAG.DATATYPE_FLOAT,
+                                       PROCFLAG.DATATYPE_DOUBLE]
+                    for index in range(len(dtypeList)):
+                        if self.dataOutObj.dtype == dtypeList[index]:
+                            dtypeValue = datatypeValueList[index]
+                            break
+                    processFlags += dtypeValue
+                    if self.dataOutObj.flagDecodeData:
+                        processFlags += PROCFLAG.DECODE_DATA
+                    if self.dataOutObj.flagDeflipData:
+                        processFlags += PROCFLAG.DEFLIP_DATA
+                    if self.dataOutObj.code != None:
+                        processFlags += PROCFLAG.DEFINE_PROCESS_CODE
+                    if self.dataOutObj.nIncohInt > 1:
+                        processFlags += PROCFLAG.INCOHERENT_INTEGRATION
+                    if self.dataOutObj.data_dc != None:
+                        processFlags += PROCFLAG.SAVE_CHANNELS_DC
+                    return processFlags
+                def __getBlockSize(self):
+                    '''
+                    Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
+                    '''
+                    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')])
+                    dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
+                    datatypeValueList = [1,2,4,8,4,8]
+                    for index in range(len(dtypeList)):
+                        if self.dataOutObj.dtype == dtypeList[index]:
+                            datatypeValue = datatypeValueList[index]
+                            break
+                    pts2write = self.dataOutObj.nHeights * self.dataOutObj.nFFTPoints
+                    pts2write_SelfSpectra = int(self.nWrChannels * pts2write)
+                    blocksize = pts2write_SelfSpectra
+                    if self.dataOutObj.data_cspc != None:
+                        pts2write_CrossSpectra = int(self.nWrPairs * pts2write)
+                        blocksize += pts2write_CrossSpectra
+                    if self.dataOutObj.data_dc != None:
+                        pts2write_DCchannels = int(self.nWrChannels * self.dataOutObj.nHeights)
+                        blocksize += pts2write_DCchannels
+                    blocksize = blocksize * datatypeValue * 2
+                    return blocksize
+                def getBasicHeader(self):
+                    self.basicHeaderObj.size = self.basicHeaderSize #bytes
+                    self.basicHeaderObj.version = self.versionFile
+                    self.basicHeaderObj.dataBlock = self.nTotalBlocks
+                    utc = numpy.floor(self.dataOutObj.dataUtcTime)
+                    milisecond  = (self.dataOutObj.dataUtcTime - utc)* 1000.0
+                    self.basicHeaderObj.utc = utc
+                    self.basicHeaderObj.miliSecond = milisecond
+                    self.basicHeaderObj.timeZone = 0
+                    self.basicHeaderObj.dstFlag = 0
+                    self.basicHeaderObj.errorCount = 0
+                def getDataHeader(self):
+                    """
+                    Obtiene una copia del First Header
+                    Affected:
+                        self.systemHeaderObj
+                        self.radarControllerHeaderObj
+                        self.dtype
+                    Return:
+                        None
+                    """
+                    self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
+                    self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
+                    self.getBasicHeader()
+                    processingHeaderSize = 40 # bytes
+                    self.processingHeaderObj.dtype = 0 # Voltage
+                    self.processingHeaderObj.blockSize = self.__getBlockSize()
+                    self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
+                    self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
+                    self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOutObj.processingHeaderObj.nWindows
+                    self.processingHeaderObj.processFlags = self.__getProcessFlags()
+                    self.processingHeaderObj.nCohInt = self.dataOutObj.nCohInt
+                    self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
+                    self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
+                    if self.dataOutObj.code != None:
+                        self.processingHeaderObj.code = self.dataOutObj.code
+                        self.processingHeaderObj.nCode = self.dataOutObj.nCode
+                        self.processingHeaderObj.nBaud = self.dataOutObj.nBaud
+                        codesize = int(8 + 4 * self.dataOutObj.nCode * self.dataOutObj.nBaud)
+                        processingHeaderSize += codesize
+                    if self.processingHeaderObj.nWindows != 0:
+                        self.processingHeaderObj.firstHeight = self.dataOutObj.heightList[0]
+                        self.processingHeaderObj.deltaHeight = self.dataOutObj.heightList[1] - self.dataOutObj.heightList[0]
+                        self.processingHeaderObj.nHeights = self.dataOutObj.nHeights
+                        self.processingHeaderObj.samplesWin = self.dataOutObj.nHeights
+                        processingHeaderSize += 12
+                    self.processingHeaderObj.size = processingHeaderSize
+  No newline at end of file

schainpy2/IO/VoltageIO.py +70 -33

             '''
             Created on 23/01/2012
             @author $Author: dsuarez $
             @version $Id: VoltageIO.py 110 2012-07-19 15:18:18Z dsuarez $
             '''
             import os, sys
             import numpy
             import glob
             import fnmatch
             import time, datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from JROHeader import *
             from JRODataIO import JRODataReader
             from JRODataIO import JRODataWriter
             from Data.Voltage import Voltage
             class VoltageReader(JRODataReader):
                 """
                 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
                 perfiles*alturas*canales) son almacenados en la variable "buffer".
                                          perfiles * alturas * canales
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
                 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
                 Example:
                     dpath = "/home/myuser/data"
                     startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
                     endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
                     readerObj = VoltageReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         #to get one profile
                         profile =  readerObj.getData()
                         #print the profile
                         print profile
                         #If you want to see all datablock
                         print readerObj.datablock
                         if readerObj.flagNoMoreFiles:
                             break
                 """
                 ext = ".r"
                 optchar = "D"
                 dataOutObj = None
                 def __init__(self, dataOutObj=None):
                     """
                     Inicializador de la clase VoltageReader para la lectura de datos de voltage.
                     Input:
                         dataOutObj    :    Objeto de la clase Voltage. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           bloque de datos.
                                           Si este parametro no es pasado se creara uno internamente.
                     Variables afectadas:
                         self.dataOutObj
                     Return:
                         None
                     """
                     self.datablock = None
                     self.utc = 0
                     self.ext = ".r"
                     self.optchar = "D"
                     self.basicHeaderObj = BasicHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.online = 0
                     self.fp = None
                     self.idFile = None
                     self.dtype = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.filename = None
                     self.fileSize = None
                     self.firstHeaderSize = 0
                     self.basicHeaderSize = 24
                     self.pathList = []
                     self.filenameList = []
                     self.lastUTTime = 0
                     self.maxTimeStep = 30
                     self.flagNoMoreFiles = 0
                     self.set = 0
                     self.path = None
                     self.profileIndex = 9999
                     self.delay  = 3   #seconds
                     self.nTries  = 3  #quantity tries
                     self.nFiles = 3   #number of files for searching
                     self.nReadBlocks = 0
                     self.flagIsNewFile = 1
                     self.ippSeconds = 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     self.nTotalBlocks = 0
                     self.blocksize = 0
                 def createObjByDefault(self):
                     dataObj = Voltage()
                     return dataObj
                 def __hasNotDataInBuffer(self):
                     if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
                         return 1
                     return 0
                 def getBlockDimension(self):
                     """
                     Obtiene la cantidad de puntos a leer por cada bloque de datos
                     Affected:
                         self.blocksize
                     Return:
                         None
                     """
                     pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
                     self.blocksize = pts2read
                 def readBlock(self):
                     """
                     readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
                     (self.fp) y actualiza todos los parametros relacionados al bloque de datos
                     (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
                     es seteado a 0
                     Inputs:
                         None
                     Return:
                         None
                     Affected:
                         self.profileIndex
                         self.datablock
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                     Exceptions:
                         Si un bloque leido no es un bloque valido
                     """
                     junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
                     try:
                         junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
                     except:
                         print "The read block (%3d) has not enough data" %self.nReadBlocks
                         return 0
                     junk = numpy.transpose(junk, (2,0,1))
                     self.datablock = junk['real'] + junk['imag']*1j
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def getData(self):
                     """
                     getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
                     con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
                     lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
                     Ademas incrementa el contador del buffer en 1.
                     Return:
                         data    :    retorna un perfil de voltages (alturas * canales) copiados desde el
                                      buffer. Si no hay mas archivos a leer retorna None.
                     Variables afectadas:
                         self.dataOutObj
                         self.profileIndex
                     Affected:
                         self.dataOutObj
                         self.profileIndex
                         self.flagTimeBlock
                         self.flagIsNewBlock
                     """
                     if self.flagNoMoreFiles: return 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not( self.readNextBlock() ):
                             return 0
             #            self.updateDataHeader()
                     if self.flagNoMoreFiles == 1:
                         print 'Process finished'
                         return 0
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.datablock == None:
                         self.dataOutObj.flagNoData = True
                         return 0
                     self.dataOutObj.data = self.datablock[:,self.profileIndex,:]
                     self.dataOutObj.dtype = self.dtype
                     self.dataOutObj.nChannels = self.systemHeaderObj.nChannels
                     self.dataOutObj.nHeights = self.processingHeaderObj.nHeights
                     self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
                     self.dataOutObj.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
                     self.dataOutObj.channelList = range(self.systemHeaderObj.nChannels)
                     self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
                     self.dataOutObj.flagTimeBlock = self.flagTimeBlock
                     self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc + self.profileIndex * self.ippSeconds
                     self.dataOutObj.nCohInt = self.processingHeaderObj.nCohInt
+                    self.dataOutObj.flagShiftFFT = False
+                    if self.processingHeaderObj.code != None:
+                        self.dataOutObj.nCode = self.processingHeaderObj.nCode
+                        self.dataOutObj.nBaud = self.processingHeaderObj.nBaud
+                        self.dataOutObj.code = self.processingHeaderObj.code
                     self.profileIndex += 1
                     self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                     self.dataOutObj.flagNoData = False
                     return 1
             class VoltageWriter(JRODataWriter):
                 """
                 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 ext = ".r"
                 optchar = "D"
                 shapeBuffer = None
                 def __init__(self, dataOutObj=None):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                     Affected:
                         self.dataOutObj
                     Return: None
                     """
                     if dataOutObj == None:
                         dataOutObj = Voltage()
                     if not( isinstance(dataOutObj, Voltage) ):
                         raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object"
                     self.dataOutObj = dataOutObj
+                    self.nTotalBlocks = 0
+                    self.profileIndex = 0
                 def hasAllDataInBuffer(self):
                     if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
                         return 1
                     return 0
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     Affected:
                         self.shape_spc_Buffer
                         self.shape_cspc_Buffer
                         self.shape_dc_Buffer
                     Return: None
                     """
                     self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
                                         self.processingHeaderObj.nHeights,
                                         self.systemHeaderObj.nChannels)
                     self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
                                                  self.processingHeaderObj.profilesPerBlock,
                                                  self.processingHeaderObj.nHeights),
                                                  dtype=numpy.dtype('complex'))
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.profileIndex
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.blockIndex
                     Return: None
                     """
                     data = numpy.zeros( self.shapeBuffer, self.dtype )
                     junk = numpy.transpose(self.datablock, (1,2,0))
                     data['real'] = junk.real
                     data['imag'] = junk.imag
                     data = data.reshape( (-1) )
                     data.tofile( self.fp )
                     self.datablock.fill(0)
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.blockIndex += 1
                     self.nTotalBlocks += 1
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.flagIsNewBlock
                         self.profileIndex
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
                     self.flagIsNewBlock = 0
                     if self.dataOutObj.flagNoData:
                         return 0
                     if self.dataOutObj.flagTimeBlock:
                         self.datablock.fill(0)
                         self.profileIndex = 0
                         self.setNextFile()
+                    if self.profileIndex == 0:
+                        self.getBasicHeader()
                     self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
                     self.profileIndex += 1
                     if self.hasAllDataInBuffer():
                         #if self.flagIsNewFile:
-                        self.getDataHeader()
                         self.writeNextBlock()
+            #            self.getDataHeader()
                     if self.flagNoMoreFiles:
                         #print 'Process finished'
                         return 0
                     return 1
-                def __getProcessFlag(self):
+                def __getProcessFlags(self):
                     processFlags = 0
                     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')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList =  [PROCFLAG.DATATYPE_CHAR,
                                        PROCFLAG.DATATYPE_SHORT,
                                        PROCFLAG.DATATYPE_LONG,
                                        PROCFLAG.DATATYPE_INT64,
                                        PROCFLAG.DATATYPE_FLOAT,
                                        PROCFLAG.DATATYPE_DOUBLE]
                     for index in range(len(dtypeList)):
-                        if dtypeList == self.dataOutObj.dtype:
+                        if self.dataOutObj.dtype == dtypeList[index]:
                             dtypeValue = datatypeValueList[index]
                             break
                     processFlags += dtypeValue
                     if self.dataOutObj.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
                     if self.dataOutObj.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
+                    if self.dataOutObj.code != None:
+                        processFlags += PROCFLAG.DEFINE_PROCESS_CODE
                     if self.dataOutObj.nCohInt > 1:
                         processFlags += PROCFLAG.COHERENT_INTEGRATION
+                    return processFlags
                 def __getBlockSize(self):
+                    '''
+                    Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
+                    '''
                     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')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
-                    datatypeValueList
+                    datatypeValueList = [1,2,4,8,4,8]
                     for index in range(len(dtypeList)):
-                        if dtypeList == self.dataOutObj.dtype:
+                        if self.dataOutObj.dtype == dtypeList[index]:
-                            datatypeValue = index
+                            datatypeValue = datatypeValueList[index]
                             break
-                    self.dataOutObj.nHeights * self.dataOutObj.nChannels * self.dataOutObj.nProfiles * datatypeValue * 2
+                    blocksize = int(self.dataOutObj.nHeights * self.dataOutObj.nChannels * self.dataOutObj.nProfiles * datatypeValue * 2)
+                    return blocksize
+                def getBasicHeader(self):
+                    self.basicHeaderObj.size = self.basicHeaderSize #bytes
+                    self.basicHeaderObj.version = self.versionFile
+                    self.basicHeaderObj.dataBlock = self.nTotalBlocks
+                    utc = numpy.floor(self.dataOutObj.dataUtcTime)
+                    milisecond  = (self.dataOutObj.dataUtcTime - utc)* 1000.0
+                    self.basicHeaderObj.utc = utc
+                    self.basicHeaderObj.miliSecond = milisecond
+                    self.basicHeaderObj.timeZone = 0
+                    self.basicHeaderObj.dstFlag = 0
+                    self.basicHeaderObj.errorCount = 0
                 def getDataHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.dtype
                     Return:
                         None
                     """
-            #        CALCULAR PARAMETROS
                     self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
                     self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
-                    self.basicHeaderObj.size = self.basicHeaderSize #bytes
+                    self.getBasicHeader()
-                    self.basicHeaderObj.version = self.versionFile
-                    self.basicHeaderObj.dataBlock = self.nTotalBlocks
-                    self.basicHeaderObj.utc = self.dataOutObj.dataUtcTime
-                    self.basicHeaderObj.miliSecond = 0
-                    self.basicHeaderObj.timeZone = 0
-                    self.basicHeaderObj.dstFlag = 0
-                    self.basicHeaderObj.errorCount = 0
-                    staticProcessingHeaderSize = 40 # bytes
+                    processingHeaderSize = 40 # bytes
-                    dynProcessingHeaderSize = 0 # bytes
-                    self.processingHeaderObj.size = staticProcessingHeaderSize + dynProcessingHeaderSize
                     self.processingHeaderObj.dtype = 0 # Voltage
-            #        self.processingHeaderObj.dtype = self.dataOutObj.dtype
+                    self.processingHeaderObj.blockSize = self.__getBlockSize()
-                    self.processingHeaderObj.blockSize = 0 # debe calcular el size en bytes del bloque de datos:
+                    self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
-                    # usar funcion getBlockSize
-                    self.processingHeaderObj.profilesPerBlock = self.dataOutObj.nProfiles
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
-                    self.processingHeaderObj.numWindows = 1
+                    self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOutObj.processingHeaderObj.nWindows
                     self.processingHeaderObj.processFlags = self.__getProcessFlags()
-                    self.processingHeaderObj.coherentInt = self.dataOutObj.nCohInt
+                    self.processingHeaderObj.nCohInt = self.dataOutObj.nCohInt
-                    self.processingHeaderObj.incoherentInt = 1 # Cuando la data de origen sea de tipo Voltage
+                    self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
-                    self.processingHeaderObj.totalSpectra = 0
+                    self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
-                    self.dtype = self.dataOutObj.dtype
+                    if self.dataOutObj.code != None:
-  No newline at end of file
+                        self.processingHeaderObj.code = self.dataOutObj.code
+                        self.processingHeaderObj.nCode = self.dataOutObj.nCode
+                        self.processingHeaderObj.nBaud = self.dataOutObj.nBaud
+                        codesize = int(8 + 4 * self.dataOutObj.nCode * self.dataOutObj.nBaud)
+                        processingHeaderSize += codesize
+                    if self.processingHeaderObj.nWindows != 0:
+                        self.processingHeaderObj.firstHeight = self.dataOutObj.heightList[0]
+                        self.processingHeaderObj.deltaHeight = self.dataOutObj.heightList[1] - self.dataOutObj.heightList[0]
+                        self.processingHeaderObj.nHeights = self.dataOutObj.nHeights
+                        self.processingHeaderObj.samplesWin = self.dataOutObj.nHeights
+                        processingHeaderSize += 12
+                    self.processingHeaderObj.size = processingHeaderSize
+  No newline at end of file

schainpy2/testSchainExp.py +16 -7

             import os, sys
             import time, datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Data.Voltage import Voltage
             from IO.VoltageIO import *
             from Processing.VoltageProcessor import *
             class TestSChain():
                 def __init__(self):
                     self.setValues()
                     self.createObjects()
                     self.testSChain()
                 def setValues(self):
                     self.path = "/Users/danielangelsuarezmunoz/Data/EW_Drifts"
+                    self.startDate = datetime.date(2011,11,28)
+                    self.endDate = datetime.date(2011,11,30)
+            #        self.path = "/Users/danielangelsuarezmunoz/Data/Imaging_rawdata"
+            #        self.startDate = datetime.date(2011,10,4)
+            #        self.endDate = datetime.date(2011,10,4)
+                    # Probando los escritos por Signal Chain
+                    self.path = "/Users/danielangelsuarezmunoz/Data/testWR"
                     self.startDate = datetime.date(2011,11,28)
                     self.endDate = datetime.date(2011,11,30)
                     self.startTime = datetime.time(0,0,0)
                     self.endTime = datetime.time(23,59,59)
-                    self.wrpath = "/Users/jro/Documents/RadarData/wr_data"
+                    self.wrpath = "/Users/danielangelsuarezmunoz/Data/testWR"
                     self.profilesPerBlock = 40
                     self.blocksPerFile = 50
                 def createObjects(self):
                     self.readerObj = VoltageReader()
                     self.voltObj1 = self.readerObj.setup(
                                                path = self.path,
                                                startDate = self.startDate,
                                                endDate = self.endDate,
                                                startTime = self.startTime,
                                                endTime = self.endTime,
                                                expLabel = '',
                                                online = 0)
                     self.voltObjProc = VoltageProcessor()
                     self.voltObj2 = self.voltObjProc.setup(dataInObj = self.voltObj1)
                 def testSChain(self):
                     ini = time.time()
                     while(True):
                         self.readerObj.getData()
-                        self.voltObjProc.init()
+            #            self.voltObjProc.init()
+            #
-                        self.voltObjProc.writeData(self.wrpath,self.profilesPerBlock,self.blocksPerFile)
+            #            self.voltObjProc.writeData(self.wrpath,self.profilesPerBlock,self.blocksPerFile)
                         if self.readerObj.flagNoMoreFiles:
                             break
                         if self.readerObj.flagIsNewBlock:
-                            print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
+            #                print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks, datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
-                                                              datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
+                            print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
+                                                              datetime.datetime.utcfromtimestamp(self.readerObj.basicHeaderObj.utc + self.readerObj.basicHeaderObj.miliSecond/1000.0),)
             if __name__ == '__main__':
                 TestSChain()

schainpy2/testSchainSpecExp.py +19 -7

             import os, sys
             import time, datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
-            from Data.Voltage import Voltage
             from Data.Spectra import Spectra
-            from IO.VoltageIO import *
             from IO.SpectraIO import *
-            from Processing.VoltageProcessor import *
+            from Processing.SpectraProcessor import *
             class TestSChain:
                 def __init__(self):
                     self.setValues()
                     self.createObjects()
                     self.testSChain()
                 def setValues(self):
                     self.path = "/Users/jro/Documents/RadarData/MST_ISR/MST"
             #        self.path = "/home/roj-idl71/Data/RAWDATA/IMAGING"
                     self.path = "/Users/danielangelsuarezmunoz/Data/EW_Drifts"
                     self.path = "/Users/danielangelsuarezmunoz/Data/IMAGING"
-                    self.wrpath = "/Users/jro/Documents/RadarData/wr_data"
                     self.startDate = datetime.date(2012,3,1)
                     self.endDate = datetime.date(2012,3,30)
                     self.startTime = datetime.time(0,0,0)
                     self.endTime = datetime.time(14,1,1)
+                    # paramatros para Escritura de Pdata
+                    self.wrpath = "/Users/danielangelsuarezmunoz/Data/testWR_pdata"
+                    self.profilesPerBlock = 16
+                    self.blocksPerFile = 5
+            #        self.pairList = [(0,1),(0,2)]
                 def createObjects(self):
                     self.readerObj = SpectraReader()
-                    self.voltObj1 = self.readerObj.setup(
+                    self.specObj1 = self.readerObj.setup(
                                                path = self.path,
                                                startDate = self.startDate,
                                                endDate = self.endDate,
                                                startTime = self.startTime,
                                                endTime = self.endTime,
                                                expLabel = '',
                                                online = 0)
+                    # new lines
+                    self.specObjProc = SpectraProcessor()
+                    self.specObj2 = self.specObjProc.setup(dataInObj = self.specObj1)
                 def testSChain(self):
                     ini = time.time()
                     while(True):
                         self.readerObj.getData()
+                        self.specObjProc.init()
+                        self.specObjProc.writeData(self.wrpath,self.profilesPerBlock,self.blocksPerFile)
                         if self.readerObj.flagNoMoreFiles:
                             break
                         if self.readerObj.flagIsNewBlock:
                             print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
-                                                              datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
+                                                              datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc))
             if __name__ == '__main__':
                 TestSChain()

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages