schain-jc Commit - r122:1ab50a21fdd6

En esta version se las funciones de LECTURA de rawdata y pdata operan satisfactoriamente.

Daniel Valdez -

r122:1ab50a21fdd6

parent child

Context file:

r122:1ab50a21fdd6

Collapse all files

schainpy2/__init__.py created 644 +1 0

			@@ -0,0 +1,1
		1

schainpy2/testSchainSpecExp.py created 644 +68 0

			@@ -0,0 +1,68
		1
		2	import os, sys
		3	import time, datetime
		4
		5	path = os.path.split(os.getcwd())[0]
		6	sys.path.append(path)
		7
		8	from Data.Voltage import Voltage
		9	from Data.Spectra import Spectra
		10	from IO.VoltageIO import *
		11	from IO.SpectraIO import *
		12	from Processing.VoltageProcessor import *
		13
		14
		15
		16	class TestSChain:
		17
		18	def __init__(self):
		19	self.setValues()
		20	self.createObjects()
		21	self.testSChain()
		22
		23	def setValues(self):
		24	self.path = "/Users/jro/Documents/RadarData/MST_ISR/MST"
		25	# self.path = "/home/roj-idl71/Data/RAWDATA/IMAGING"
		26	self.path = "/Users/danielangelsuarezmunoz/Data/EW_Drifts"
		27	self.path = "/Users/danielangelsuarezmunoz/Data/IMAGING"
		28
		29	self.wrpath = "/Users/jro/Documents/RadarData/wr_data"
		30
		31	self.startDate = datetime.date(2012,3,1)
		32	self.endDate = datetime.date(2012,3,30)
		33
		34	self.startTime = datetime.time(0,0,0)
		35	self.endTime = datetime.time(14,1,1)
		36
		37	def createObjects(self):
		38
		39	self.readerObj = SpectraReader()
		40
		41	self.voltObj1 = self.readerObj.setup(
		42	path = self.path,
		43	startDate = self.startDate,
		44	endDate = self.endDate,
		45	startTime = self.startTime,
		46	endTime = self.endTime,
		47	expLabel = '',
		48	online = 0)
		49
		50
		51
		52	def testSChain(self):
		53
		54	ini = time.time()
		55
		56	while(True):
		57	self.readerObj.getData()
		58
		59	if self.readerObj.flagNoMoreFiles:
		60	break
		61
		62	if self.readerObj.flagIsNewBlock:
		63	print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
		64	datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
		65
		66
		67	if __name__ == '__main__':
		68	TestSChain() No newline at end of file

schainpy2/Data/JROData.py +56 -56

		@@ -1,57 +1,57
1		import os, sys
2		import copy
3		import numpy
4
5		path = os.path.split(os.getcwd())[0]
6		sys.path.append(path)
7
8		from IO.JROHeader import SystemHeader, RadarControllerHeader
9
10		class JROData():
11
12		# m_BasicHeader = BasicHeader()
13		# m_ProcessingHeader = ProcessingHeader()
14
15		systemHeaderObj = SystemHeader()
16
17		radarControllerHeaderObj = RadarControllerHeader()
18
19		data = None
20
21		type = None
22
23		dtype = None
24
25		nChannels = None
26
27		nHeights = None
28
29		nProfiles = None
30
31		heightList = None
32
33		channelList = None
34
35		channelIndexList = None
36
37		flagNoData = False
38
39		flagTimeBlock = False
40
41		dataUtcTime = None
42
43		def __init__(self):
44
45		raise ValueError, "This class has not been implemented"
46
47		def copy(self, inputObj=None):
48
49		if inputObj == None:
50		return copy.deepcopy(self)
51
52		for key in inputObj.__dict__.keys():
53		self.__dict__[key] = inputObj.__dict__[key]
54
55		def deepcopy(self):
56
	1	import os, sys
	2	import copy
	3	import numpy
	4
	5	path = os.path.split(os.getcwd())[0]
	6	sys.path.append(path)
	7
	8	from IO.JROHeader import SystemHeader, RadarControllerHeader
	9
	10	class JROData:
	11
	12	# m_BasicHeader = BasicHeader()
	13	# m_ProcessingHeader = ProcessingHeader()
	14
	15	systemHeaderObj = SystemHeader()
	16
	17	radarControllerHeaderObj = RadarControllerHeader()
	18
	19	# data = None
	20
	21	type = None
	22
	23	dtype = None
	24
	25	nChannels = None
	26
	27	nHeights = None
	28
	29	nProfiles = None
	30
	31	heightList = None
	32
	33	channelList = None
	34
	35	channelIndexList = None
	36
	37	flagNoData = False
	38
	39	flagTimeBlock = False
	40
	41	dataUtcTime = None
	42
	43	def __init__(self):
	44
	45	raise ValueError, "This class has not been implemented"
	46
	47	def copy(self, inputObj=None):
	48
	49	if inputObj == None:
	50	return copy.deepcopy(self)
	51
	52	for key in inputObj.__dict__.keys():
	53	self.__dict__[key] = inputObj.__dict__[key]
	54
	55	def deepcopy(self):
	56
57	57	return copy.deepcopy(self) No newline at end of file

schainpy2/Data/Spectra.py +59 -59

		@@ -1,60 +1,60
1		import os, sys
2		import numpy
3
4		path = os.path.split(os.getcwd())[0]
5		sys.path.append(path)
6
7		from JROData import JROData
8		from IO.JROHeader import SystemHeader, RadarControllerHeader
9
10		class Spectra(JROData):
11		data_spc = None
12
13		data_cspc = None
14
15		data_dc = None
16
17		nFFTPoints = None
18
19		nPairs = None
20
21		pairsList = None
22
23		nIncohInt = None
24
25		def __init__(self):
26		'''
27		Constructor
28		'''
29
30		self.m_RadarControllerHeader = RadarControllerHeader()
31
32		self.m_SystemHeader = SystemHeader()
33
34		self.type = "Spectra"
35
36		#data es un numpy array de 2 dmensiones ( canales, alturas)
37		# self.data = None
38
39		self.dtype = None
40
41		self.nChannels = 0
42
43		self.nHeights = 0
44
45		self.nProfiles = None
46
47		self.heightList = None
48
49		self.channelList = None
50
51		self.channelIndexList = None
52
53		self.flagNoData = True
54
55		self.flagTimeBlock = False
56
57		self.dataUtcTime = None
58
59		self.nIncohInt = None
	1	import os, sys
	2	import numpy
	3
	4	path = os.path.split(os.getcwd())[0]
	5	sys.path.append(path)
	6
	7	from JROData import JROData
	8	from IO.JROHeader import SystemHeader, RadarControllerHeader
	9
	10	class Spectra(JROData):
	11	data_spc = None
	12
	13	data_cspc = None
	14
	15	data_dc = None
	16
	17	nFFTPoints = None
	18
	19	nPairs = None
	20
	21	pairsList = None
	22
	23	nIncohInt = None
	24
	25	def __init__(self):
	26	'''
	27	Constructor
	28	'''
	29
	30	self.m_RadarControllerHeader = RadarControllerHeader()
	31
	32	self.m_SystemHeader = SystemHeader()
	33
	34	self.type = "Spectra"
	35
	36	#data es un numpy array de 2 dmensiones ( canales, alturas)
	37	# self.data = None
	38
	39	self.dtype = None
	40
	41	self.nChannels = 0
	42
	43	self.nHeights = 0
	44
	45	self.nProfiles = None
	46
	47	self.heightList = None
	48
	49	self.channelList = None
	50
	51	self.channelIndexList = None
	52
	53	self.flagNoData = True
	54
	55	self.flagTimeBlock = False
	56
	57	self.dataUtcTime = None
	58
	59	self.nIncohInt = None
60	60	No newline at end of file

schainpy2/Data/Voltage.py +50 -48

		@@ -1,48 +1,50
1		import os, sys
2		import numpy
3
4		path = os.path.split(os.getcwd())[0]
5		sys.path.append(path)
6
7		from JROData import JROData
8		from IO.JROHeader import SystemHeader, RadarControllerHeader
9
10		class Voltage(JROData):
11
12		nCohInt = None
13
14		def __init__(self):
15		'''
16		Constructor
17		~~'''~~
18
19		self.m_RadarControllerHeader = RadarControllerHeader()
20
21		self.m_~~System~~Header = ~~System~~Header()
22
23		self.type = "Voltage"
24
25		#data es un numpy array de 2 dmensiones ( canales, alturas)
26		self.data = None
27
28		self.d~~type~~ = None
29
30		self.~~nChannels~~ = 0
31
32		self.n~~Height~~s = 0
33
34		self.n~~Profile~~s = ~~None~~
35
36		self.~~heightList~~ = None
37
38		self.~~channel~~List = None
39
40		self.channel~~Index~~List = None
41
42		self.flagNoData = True
43
44		self.flag~~TimeBlock~~ = ~~Fals~~e
45
46		self.~~dataUtcTime~~ = ~~Non~~e
47
48		self.~~nCohInt~~ = None
	1	import os, sys
	2	import numpy
	3
	4	path = os.path.split(os.getcwd())[0]
	5	sys.path.append(path)
	6
	7	from JROData import JROData
	8	from IO.JROHeader import SystemHeader, RadarControllerHeader
	9
	10	class Voltage(JROData):
	11
	12	nCohInt = None
	13
	14	data = None
	15
	16	def __init__(self):
	17	'''
	18	Constructor
	19	'''
	20
	21	self.m_RadarControllerHeader = RadarControllerHeader()
	22
	23	self.m_SystemHeader = SystemHeader()
	24
	25	self.type = "Voltage"
	26
	27	#data es un numpy array de 2 dmensiones ( canales, alturas)
	28	self.data = None
	29
	30	self.dtype = None
	31
	32	self.nChannels = 0
	33
	34	self.nHeights = 0
	35
	36	self.nProfiles = None
	37
	38	self.heightList = None
	39
	40	self.channelList = None
	41
	42	self.channelIndexList = None
	43
	44	self.flagNoData = True
	45
	46	self.flagTimeBlock = False
	47
	48	self.dataUtcTime = None
	49
	50	self.nCohInt = None

schainpy2/IO/JRODataIO.py +738 -727

This diff has been collapsed as it changes many lines, (1465 lines changed) Show them Hide them
			@@ -1,727 +1,738
	1		import os, sys
	2		import glob
	3		import time
	4		import numpy
	5		import fnmatch
	6		import time, datetime
	7
	8		path = os.path.split(os.getcwd())[0]
	9		sys.path.append(path)
	10
	11		from JROHeader import *
	12		from Data.JROData import JROData
	13
	14		def isNumber(str):
	15		"""
	16		Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
	17
	18		Excepciones:
	19		Si un determinado string no puede ser convertido a numero
	20		Input:
	21		str, string al cual se le analiza para determinar si convertible a un numero o no
	22
	23		Return:
	24		True : si el string es uno numerico
	25		False : no es un string numerico
	26		"""
	27		try:
	28		float( str )
	29		return True
	30		except:
	31		return False
	32
	33		def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
	34		"""
	35		Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
	36
	37		Inputs:
	38		filename : nombre completo del archivo de datos en formato Jicamarca (.r)
	39
	40		startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
	41		segundos contados desde 01/01/1970.
	42		endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
	43		segundos contados desde 01/01/1970.
	44
	45		Return:
	46		Boolean : Retorna True si el archivo de datos contiene datos en el rango de
	47		fecha especificado, de lo contrario retorna False.
	48
	49		Excepciones:
	50		Si el archivo no existe o no puede ser abierto
	51		Si la cabecera no puede ser leida.
	52
	53		"""
	54		basicHeaderObj = BasicHeader()
	55
	56		try:
	57		fp = open(filename,'rb')
	58		except:
	59		raise IOError, "The file %s can't be opened" %(filename)
	60
	61		sts = basicHeaderObj.read(fp)
	62		fp.close()
	63
	64		if not(sts):
	65		print "Skipping the file %s because it has not a valid header" %(filename)
	66		return 0
	67
	68		if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
	69		return 0
	70
	71		return 1
	72
	73
	74
	75
	76		class JRODataIO:
	77
	78		c = 3E8
	79
	80		basicHeaderObj = BasicHeader()
	81
	82		systemHeaderObj = SystemHeader()
	83
	84		radarControllerHeaderObj = RadarControllerHeader()
	85
	86		processingHeaderObj = ProcessingHeader()
	87
	88		online = 0
	89
	90		dtype = None
	91
	92		pathList = []
	93
	94		filenameList = []
	95
	96		filename = None
	97
	98		ext = None
	99
	100		flagNoMoreFiles = 0
	101
	102		flagIsNewFile = 1
	103
	104		flagTimeBlock = 0
	105
	106		flagIsNewBlock = 0
	107
	108		fp = None
	109
	110		firstHeaderSize = 0
	111
	112		basicHeaderSize = 24
	113
	114		versionFile = 1103
	115
	116		fileSize = None
	117
	118		ippSeconds = None
	119
	120		fileSizeByHeader = None
	121
	122		fileIndex = None
	123
	124		profileIndex = None
	125
	126		blockIndex = None
	127
	128		nTotalBlocks = None
	129
	130		maxTimeStep = 30
	131
	132		lastUTTime = None
	133
	134		def __init__(self):
	135		pass
	136
	137		class JRODataReader(JRODataIO):
	138		def __init__(self):
	139		pass
	140
	141		def createObjByDefault(self):
	142		"""
	143
	144		"""
	145		raise ValueError, "This method has not been implemented"
	146
	147		def getBlockDimension(self):
	148
	149		raise ValueError, "No implemented"
	150
	151		def __searchFilesOffLine(self,
	152		path,
	153		startDate,
	154		endDate,
	155		startTime=datetime.time(0,0,0),
	156		endTime=datetime.time(23,59,59),
	157		set=None,
	158		expLabel="",
	159		ext=".r"):
	160		dirList = []
	161		for thisPath in os.listdir(path):
	162		if os.path.isdir(os.path.join(path,thisPath)):
	163		dirList.append(thisPath)
	164
	165		if not(dirList):
	166		return None, None
	167
	168		pathList = []
	169		dateList = []
	170
	171		~~thisDate~~ = ~~startDate~~
	172
	173		while(thisDate <= endDate):
	174		year = thisDate.timetuple().tm_year
	175		doy = thisDate.timetuple().tm_yday
	176
	177		match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
	178		if len(match) == 0:
	179		thisDate += datetime.timedelta(1)
	180		continue
	181
	182		pathList.append(os.path.join(path,match[0],expLabel))
	183		dateList.append(thisDate)
	184		~~thisDate~~ += ~~datetim~~e.time~~delta~~(1)
	185
	186		filenameList = []
	187		for index in range(len(pathList)):
	188
	189		~~thisPath~~ = ~~pathList~~[~~index~~]
	190		fileList = glob.glob1(thisPath, "*%s" %ext)
	191		~~fileList~~.~~sort~~()
	192
	193		#Busqueda de datos en el rango de horas indicados
	194		thisDate = date~~List~~[~~index~~]
	195		startDT = datetime.datetime.combine(thisDate, startTime)
	196		endDT = datetime.datetime.combine(thisDate, endTime)
	197
	198		startUtSeconds = time.mktime(startDT.timetuple())
	199		endUtSeconds = time.mktime(endDT.timetuple())
	200
	201		~~for~~ ~~file~~ in fileList:
	202
	203		filename = os.path.join(thisPath,file)
	204
	205		if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
	206		filenameList.append(filename)
	207
	208		if not(filenameList):
	209		return None, None
	210
	211		self.filenameList = filenameList
	212
	213		return pathList, filenameList
	214
	215		def setup(self,dataOutObj=None,
	216		path=None,startDate=None,
	217		~~endDate~~=~~None~~,
	218		startTime=datetime.time(0,0,0),
	219		endTime=datetime.time(23,59,59),
	220		set=0,
	221		expLabel = "",
	222		ext = None,
	223		online = 0):
	224
	225		if path == None:
	226		raise ValueError, "The path is not valid"
	227
	228		if ~~ext~~ == ~~None~~:
	229		ext = self.ext
	230
	231		if dataOutObj == None:
	232		dataOutObj = self.createObjByDefault()
	233
	234		self.dataOutObj = dataOutObj
	235
	236		if o~~nli~~ne:
	237		pass
	238
	239		~~els~~e:
	240		print "Searching file in offline mode"
	241		pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)
	242		if not(pathList):
	243		print "No files in range: %s - %s"%(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
	244		return None
	245		self.fileIndex = -1
	246		self.pathList = pathList
	247		self.filenameList = filenameList
	248
	249		self.online = online
	250		ext = ext.lower()
	251		self.ext = ext
	252
	253		if not(self.setNextFile()):
	254		if (startDate!=None) and (endDate!=None):
	255		print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
	256		elif startDate != None:
	257		print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
	258		else:
	259		print "No files"
	260
	261		return None
	262
	263		# self.updateDataHeader()
	264
	265		return self.dataOutObj
	266
	267		def __setNextFileOffline(self):
	268		idFile = self.fileIndex
	269
	270		while (True):
	271		idFile += 1
	272		if not(idFile < len(self.filenameList)):
	273		self.flagNoMoreFiles = 1
	274		print "No more Files"
	275		return 0
	276
	277		filename = self.filenameList[idFile]
	278
	279		if not(self.__verifyFile(filename)):
	280		continue
	281
	282		fileSize = os.path.getsize(filename)
	283		fp = open(filename,~~'rb'~~)
	284		break
	285
	286		self.flagIsNewFile = 1
	287		self.fileIndex = idFile
	288		~~self~~.filename = filename
	289		self.fileSize = fileSize
	290		self.fp = fp
	291
	292		print "Setting the file: %s"%self.filename
	293
	294		return 1
	295
	296
	297
	298		def setNextFile(self):
	299		if self.fp != ~~None~~:
	300		self.fp.close()
	301
	302		if self.online:
	303		newFile = self.__setNextFileOnline()
	304		else:
	305		newFile = self.__setNextFileOffline()
	306
	307		if not(newFile):
	308		return 0
	309
	310		self.__readFirstHeader()
	311		self.nReadBlocks = 0
	312		return 1
	313
	314		def __setNewBlock(self):
	315		if self.fp == None:
	316		return 0
	317
	318		if ~~self~~.~~flagIsN~~ewFile:
	319		return 1
	320
	321		self.lastUTTime = self.basicHeaderObj.utc
	322		currentSize = self.fileSize - self.fp.tell()
	323		neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
	324
	325		if (currentSize >= neededSize):
	326		self.__rdBasicHeader()
	327		return 1
	328
	329		if ~~not~~(self.~~setNextFile())~~:
	330		return 0
	331
	332		~~delta~~Time = self.basicHeaderObj.utc - ~~self~~.~~lastUTTime~~ #
	333
	334		self.flagTimeBlock = 0
	335
	336		if deltaTime > self.maxTimeStep:
	337		self.flagTimeBlock = 1
	338
	339		return 1
	340
	341
	342		def readNextBlock(self):
	343		if not(self.__setNewBlock()):
	344		return 0
	345
	346		if not(self.readBlock()):
	347		return 0
	348
	349		return 1
	350
	351		def __rdProcessingHeader(self, fp=None):
	352		if fp == None:
	353		fp = self.fp
	354
	355		self.processingHeaderObj.read(fp)
	356
	357		def __rdRadarControllerHeader(self, fp=None):
	358		if fp == None:
	359		fp = self.fp
	360
	361		self.radarControllerHeaderObj.read(fp)
	362
	363		def __rdSystemHeader(self, fp=None):
	364		if fp == ~~None~~:
	365		fp = self.fp
	366
	367		self.systemHeaderObj.read(fp)
	368
	369		def __rdBasicHeader(self, fp=None):
	370		if fp == ~~None~~:
	371		fp = self.fp
	372
	373		self.basicHeaderObj.read(fp)
	374
	375
	376		def __readFirstHeader(self):
	377		self.__rdBasicHeader()
	378		self.~~__rdS~~ystemHeader()
	379		self.__rdRadarControllerHeader()
	380		self.__rdProcessingHeader()
	381
	382		self.firstHeaderSize = self.basicHeaderObj.size
	383
	384		datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
	385		if datatype == 0:
	386		datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
	387		elif datatype == 1:
	388		datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
	389		elif datatype == 2:
	390		datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
	391		elif datatype == 3:
	392		datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
	393		elif datatype == 4:
	394		datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
	395		elif datatype == 5:
	396		datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
	397		else:
	398		raise ValueError, 'Data type was not defined'
	399
	400		self.~~dtype~~ = ~~datatype_str~~
	401		self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
	402		self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
	403		# self.dataOutObj.channelList = numpy.arange(self.systemHeaderObj.numChannels)
	404		# self.dataOutObj.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
	405		self.getBlockDimension()
	406
	407
	408		def __verifyFile(self, filename, msgFlag=True):
	409		msg = None
	410		try:
	411		fp = open(filename, 'rb')
	412		currentPosition = fp.tell()
	413		except:
	414		if msgFlag:
	415		print "The file %s can't be opened" % (filename)
	416		return False
	417
	418		neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
	419
	420		if neededSize == 0:
	421		basicHeaderObj = BasicHeader()
	422		systemHeaderObj = SystemHeader()
	423		radarControllerHeaderObj = RadarControllerHeader()
	424		processingHeaderObj = ProcessingHeader()
	425
	426		try:
	427		if not( basicHeaderObj.read(fp) ): raise ValueError
	428		if not( systemHeaderObj.read(fp) ): raise ValueError
	429		if not( radarControllerHeaderObj.read(fp) ): raise ValueError
	430		if not( processingHeaderObj.read(fp) ): raise ValueError
	431		data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
	432
	433		neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
	434
	435		except:
	436		if msgFlag:
	437		print "\tThe file %s is empty or it hasn't enough data" % filename
	438
	439		fp.close()
	440		return False
	441		else:
	442		msg = "\tSkipping the file %s due to it hasn't enough data" %filename
	443
	444		fp.close()
	445		fileSize = os.path.getsize(filename)
	446		currentSize = fileSize - currentPosition
	447		if currentSize < neededSize:
	448		if msgFlag and (msg != None):
	449		print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
	450		~~return~~ ~~False~~
	451
	452		~~return~~ ~~True~~
	453
	454		class JRODataWriter(JRODataIO):
	455
	456		"""
	457		Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
	458		de los datos siempre se realiza por bloques.
	459		"""
	460
	461		blockIndex = 0
	462
	463		setFile = None
	464
	465
	466		def __init__(self, dataOutObj=None):
	467		raise ValueError, "Not implemented"
	468
	469
	470		def hasAllDataInBuffer(self):
	471		raise ValueError, "Not implemented"
	472
	473
	474		def setBlockDimension(self):
	475		raise ValueError, "Not implemented"
	476
	477
	478		def writeBlock(self):
	479		raise ValueError, "No implemented"
	480
	481
	482		def putData(self):
	483		raise ValueError, "No implemented"
	484
	485
	486		def __writeFirstHeader(self):
	487		"""
	488		Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
	489
	490		Affected:
	491		__dataType
	492
	493		Return:
	494		None
	495		"""
	496
	497		# CALCULAR PARAMETROS
	498
	499		sizeLongHeader = 0#XXXX
	500		self.basicHeaderObj.size = 24 + sizeLongHeader
	501
	502		self.__writeBasicHeader()
	503		self.__wrSystemHeader()
	504		self.__wrRadarControllerHeader()
	505		self.__wrProcessingHeader()
	506		self.dtype = self.dataOutObj.dtype
	507
	508
	509		def __writeBasicHeader(self, fp=None):
	510		"""
	511		Escribe solo el Basic header en el file creado
	512
	513		Return:
	514		None
	515		"""
	516		if fp == None:
	517		fp = self.fp
	518
	519		self.dataOutObj.basicHeaderObj.write(fp)
	520
	521
	522		def __wrSystemHeader(self, fp=None):
	523		"""
	524		Escribe solo el System header en el file creado
	525
	526		Return:
	527		~~None~~
	528		~~"""~~
	529		if fp == None:
	530		fp = self.fp
	531
	532		self.dataOutObj.systemHeaderObj.write(fp)
	533
	534
	535		def __wrRadarControllerHeader(self, fp=None):
	536		"""
	537		Escribe solo el RadarController header en el file creado
	538
	539		Return:
	540		None
	541		"""
	542		if fp == None:
	543		fp = self.fp
	544
	545		self.dataOutObj.radarControllerHeaderObj.write(fp)
	546
	547
	548		def __wrProcessingHeader(self, fp=None):
	549		"""
	550		Escribe solo el Processing header en el file creado
	551
	552		Return:
	553		None
	554		"""
	555		if fp == None:
	556		fp = self.fp
	557
	558		self.dataOutObj.processingHeaderObj.write(fp)
	559
	560
	561		def setNextFile(self):
	562		"""
	563		Determina el siguiente file que sera escrito
	564
	565		Affected:
	566		self.filename
	567		self.subfolder
	568		self.fp
	569		self.setFile
	570		self.flagIsNewFile
	571
	572		Return:
	573		0 : Si el archivo no puede ser escrito
	574		1 : Si el archivo esta listo para ser escrito
	575		"""
	576		~~ext~~ = self.~~ext~~
	577		path = self.path
	578
	579		if self.fp != None:
	580		self.fp.close()
	581
	582		timeTuple = time.localtime( self.dataOutObj.dataUtcTime)
	583		subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
	584
	585		doypath = os.path.join( path, subfolder )
	586		if not( os.path.exists(doypath) ):
	587		os.mkdir(doypath)
	588		self.setFile = -1 #inicializo mi contador de seteo
	589		~~else~~:
	590		filesList = os.listdir( doypath )
	591		if len( filesList ) > 0:
	592		filesList = sorted( filesList, key=str.lower )
	593		filen = filesList[-1]
	594		# el filename debera tener el siguiente formato
	595		# 0 1234 567 89A BCDE (hex)
	596		# x YYYY DDD SSS .ext
	597		if isNumber( filen[8:11] ):
	598		self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
	599		else:
	600		self.setFile = -1
	601		~~else~~:
	602		self.setFile = -1 #inicializo mi contador de seteo
	603
	604		setFile = self.setFile
	605		setFile += 1
	606
	607		file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
	608		timeTuple.tm_year,
	609		timeTuple.tm_yday,
	610		setFile,
	611		ext )
	612
	613		filename = os.path.join( path, subfolder, file )
	614
	615		fp = open( filename,'wb' )
	616
	617		self.blockIndex = 0
	618
	619		#guardando atributos
	620		self.filename = filename
	621		self.subfolder = subfolder
	622		self.fp = fp
	623		self.setFile = setFile
	624		self.flagIsNewFile = 1
	625
	626		print 'Writing the file: %s'%self.filename
	627
	628		self.__writeFirstHeader()
	629
	630		return 1
	631
	632
	633		def __setNewBlock(self):
	634		"""
	635		Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
	636
	637		Return:
	638		0 : si no pudo escribir nada
	639		1 : Si escribio el Basic el First Header
	640		"""
	641		if self.fp == ~~None~~:
	642		self.setNextFile()
	643
	644		if self.flagIsNewFile:
	645		return 1
	646
	647		if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
	648		self.__write~~Basic~~Header()
	649		return 1
	650
	651		if not( self.setNextFile() ):
	652		return 0
	653
	654		return 1
	655
	656
	657		def writeNextBlock(self):
	658		"""
	659		Selecciona el bloque siguiente de datos y los escribe en un file
	660
	661		Return:
	662		0 : Si no hizo pudo escribir el bloque de datos
	663		1 : Si no pudo escribir el bloque de datos
	664		"""
	665		if not( self.__setNewBlock() ):
	666		return 0
	667
	668		self.writeB~~lock~~()
	669
	670		~~return~~ 1
	671
	672
	673		def getDataHeader(self):
	674		"""
	675		Obtiene una copia del First Header
	676
	677		Affected:
	678		self.basicHeaderObj
	679		self.systemHeaderObj
	680		self.radarControllerHeaderObj
	681		self.processingHeaderObj
	682		self.dtype
	683
	684		Return:
	685		None
	686		"""
	687
	688		raise ValueError, "No implemented"
	689
	690		def setup(self, path, set=0, ext=None):
	691		"""
	692		Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
	693
	694		Inputs:
	695		path : el path destino en el cual se escribiran los files a crear
	696		format : formato en el cual sera salvado un file
	697		set : el setebo del file
	698
	699		Return:
	700		0 : Si no realizo un buen seteo
	701		1 : Si realizo un buen seteo
	702		~~"""~~
	703
	704		if ~~ext~~ == ~~None~~:
	705		ext = self.ext
	706
	707		ext = ext.lower()
	708
	709		self.path = path
	710		self.setFile = set - 1
	711		self.ext = ext
	712		#self.format = format
	713		self.getDataHeader()
	714
	715		self.setBlockDimension()
	716
	717		if not( self.setNextFile() ):
	718		print "There isn't a next file"
	719		return 0
	720
	721		return 1
	722
	723
	724
	725
	726
	727
		1	import os, sys
		2	import glob
		3	import time
		4	import numpy
		5	import fnmatch
		6	import time, datetime
		7
		8	path = os.path.split(os.getcwd())[0]
		9	sys.path.append(path)
		10
		11	from JROHeader import *
		12	from Data.JROData import JROData
		13
		14	def isNumber(str):
		15	"""
		16	Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
		17
		18	Excepciones:
		19	Si un determinado string no puede ser convertido a numero
		20	Input:
		21	str, string al cual se le analiza para determinar si convertible a un numero o no
		22
		23	Return:
		24	True : si el string es uno numerico
		25	False : no es un string numerico
		26	"""
		27	try:
		28	float( str )
		29	return True
		30	except:
		31	return False
		32
		33	def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
		34	"""
		35	Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
		36
		37	Inputs:
		38	filename : nombre completo del archivo de datos en formato Jicamarca (.r)
		39
		40	startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
		41	segundos contados desde 01/01/1970.
		42	endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
		43	segundos contados desde 01/01/1970.
		44
		45	Return:
		46	Boolean : Retorna True si el archivo de datos contiene datos en el rango de
		47	fecha especificado, de lo contrario retorna False.
		48
		49	Excepciones:
		50	Si el archivo no existe o no puede ser abierto
		51	Si la cabecera no puede ser leida.
		52
		53	"""
		54	basicHeaderObj = BasicHeader()
		55
		56	try:
		57	fp = open(filename,'rb')
		58	except:
		59	raise IOError, "The file %s can't be opened" %(filename)
		60
		61	sts = basicHeaderObj.read(fp)
		62	fp.close()
		63
		64	if not(sts):
		65	print "Skipping the file %s because it has not a valid header" %(filename)
		66	return 0
		67
		68	if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
		69	return 0
		70
		71	return 1
		72
		73
		74
		75
		76	class JRODataIO:
		77
		78	c = 3E8
		79
		80	basicHeaderObj = BasicHeader()
		81
		82	systemHeaderObj = SystemHeader()
		83
		84	radarControllerHeaderObj = RadarControllerHeader()
		85
		86	processingHeaderObj = ProcessingHeader()
		87
		88	online = 0
		89
		90	dtype = None
		91
		92	pathList = []
		93
		94	filenameList = []
		95
		96	filename = None
		97
		98	ext = None
		99
		100	flagNoMoreFiles = 0
		101
		102	flagIsNewFile = 1
		103
		104	flagTimeBlock = 0
		105
		106	flagIsNewBlock = 0
		107
		108	fp = None
		109
		110	firstHeaderSize = 0
		111
		112	basicHeaderSize = 24
		113
		114	versionFile = 1103
		115
		116	fileSize = None
		117
		118	ippSeconds = None
		119
		120	fileSizeByHeader = None
		121
		122	fileIndex = None
		123
		124	profileIndex = None
		125
		126	blockIndex = None
		127
		128	nTotalBlocks = None
		129
		130	maxTimeStep = 30
		131
		132	lastUTTime = None
		133
		134	datablock = None
		135
		136	dataOutObj = None
		137
		138	blocksize = None
		139
		140	def __init__(self):
		141	pass
		142
		143	class JRODataReader(JRODataIO):
		144
		145	nReadBlocks = 0
		146
		147	def __init__(self):
		148
		149	pass
		150
		151	def createObjByDefault(self):
		152	"""
		153
		154	"""
		155	raise ValueError, "This method has not been implemented"
		156
		157	def getBlockDimension(self):
		158
		159	raise ValueError, "No implemented"
		160
		161	def __searchFilesOffLine(self,
		162	path,
		163	startDate,
		164	endDate,
		165	startTime=datetime.time(0,0,0),
		166	endTime=datetime.time(23,59,59),
		167	set=None,
		168	expLabel="",
		169	ext=".r"):
		170	dirList = []
		171	for thisPath in os.listdir(path):
		172	if os.path.isdir(os.path.join(path,thisPath)):
		173	dirList.append(thisPath)
		174
		175	if not(dirList):
		176	return None, None
		177
		178	pathList = []
		179	dateList = []
		180
		181	thisDate = startDate
		182
		183	while(thisDate <= endDate):
		184	year = thisDate.timetuple().tm_year
		185	doy = thisDate.timetuple().tm_yday
		186
		187	match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
		188	if len(match) == 0:
		189	thisDate += datetime.timedelta(1)
		190	continue
		191
		192	pathList.append(os.path.join(path,match[0],expLabel))
		193	dateList.append(thisDate)
		194	thisDate += datetime.timedelta(1)
		195
		196	filenameList = []
		197	for index in range(len(pathList)):
		198
		199	thisPath = pathList[index]
		200	fileList = glob.glob1(thisPath, "*%s" %ext)
		201	fileList.sort()
		202
		203	#Busqueda de datos en el rango de horas indicados
		204	thisDate = dateList[index]
		205	startDT = datetime.datetime.combine(thisDate, startTime)
		206	endDT = datetime.datetime.combine(thisDate, endTime)
		207
		208	startUtSeconds = time.mktime(startDT.timetuple())
		209	endUtSeconds = time.mktime(endDT.timetuple())
		210
		211	for file in fileList:
		212
		213	filename = os.path.join(thisPath,file)
		214
		215	if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
		216	filenameList.append(filename)
		217
		218	if not(filenameList):
		219	return None, None
		220
		221	self.filenameList = filenameList
		222
		223	return pathList, filenameList
		224
		225	def setup(self,dataOutObj=None,
		226	path=None,
		227	startDate=None,
		228	endDate=None,
		229	startTime=datetime.time(0,0,0),
		230	endTime=datetime.time(23,59,59),
		231	set=0,
		232	expLabel = "",
		233	ext = None,
		234	online = 0):
		235
		236	if path == None:
		237	raise ValueError, "The path is not valid"
		238
		239	if ext == None:
		240	ext = self.ext
		241
		242	if dataOutObj == None:
		243	dataOutObj = self.createObjByDefault()
		244
		245	self.dataOutObj = dataOutObj
		246
		247	if online:
		248	pass
		249
		250	else:
		251	print "Searching file in offline mode"
		252	pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)
		253	if not(pathList):
		254	print "No files in range: %s - %s"%(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
		255	return None
		256	self.fileIndex = -1
		257	self.pathList = pathList
		258	self.filenameList = filenameList
		259
		260	self.online = online
		261	ext = ext.lower()
		262	self.ext = ext
		263
		264	if not(self.setNextFile()):
		265	if (startDate!=None) and (endDate!=None):
		266	print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
		267	elif startDate != None:
		268	print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
		269	else:
		270	print "No files"
		271
		272	return None
		273
		274	# self.updateDataHeader()
		275
		276	return self.dataOutObj
		277
		278	def __setNextFileOffline(self):
		279	idFile = self.fileIndex
		280
		281	while (True):
		282	idFile += 1
		283	if not(idFile < len(self.filenameList)):
		284	self.flagNoMoreFiles = 1
		285	print "No more Files"
		286	return 0
		287
		288	filename = self.filenameList[idFile]
		289
		290	if not(self.__verifyFile(filename)):
		291	continue
		292
		293	fileSize = os.path.getsize(filename)
		294	fp = open(filename,'rb')
		295	break
		296
		297	self.flagIsNewFile = 1
		298	self.fileIndex = idFile
		299	self.filename = filename
		300	self.fileSize = fileSize
		301	self.fp = fp
		302
		303	print "Setting the file: %s"%self.filename
		304
		305	return 1
		306
		307
		308
		309	def setNextFile(self):
		310	if self.fp != None:
		311	self.fp.close()
		312
		313	if self.online:
		314	newFile = self.__setNextFileOnline()
		315	else:
		316	newFile = self.__setNextFileOffline()
		317
		318	if not(newFile):
		319	return 0
		320
		321	self.__readFirstHeader()
		322	self.nReadBlocks = 0
		323	return 1
		324
		325	def __setNewBlock(self):
		326	if self.fp == None:
		327	return 0
		328
		329	if self.flagIsNewFile:
		330	return 1
		331
		332	self.lastUTTime = self.basicHeaderObj.utc
		333	currentSize = self.fileSize - self.fp.tell()
		334	neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
		335
		336	if (currentSize >= neededSize):
		337	self.__rdBasicHeader()
		338	return 1
		339
		340	if not(self.setNextFile()):
		341	return 0
		342
		343	deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
		344
		345	self.flagTimeBlock = 0
		346
		347	if deltaTime > self.maxTimeStep:
		348	self.flagTimeBlock = 1
		349
		350	return 1
		351
		352
		353	def readNextBlock(self):
		354	if not(self.__setNewBlock()):
		355	return 0
		356
		357	if not(self.readBlock()):
		358	return 0
		359
		360	return 1
		361
		362	def __rdProcessingHeader(self, fp=None):
		363	if fp == None:
		364	fp = self.fp
		365
		366	self.processingHeaderObj.read(fp)
		367
		368	def __rdRadarControllerHeader(self, fp=None):
		369	if fp == None:
		370	fp = self.fp
		371
		372	self.radarControllerHeaderObj.read(fp)
		373
		374	def __rdSystemHeader(self, fp=None):
		375	if fp == None:
		376	fp = self.fp
		377
		378	self.systemHeaderObj.read(fp)
		379
		380	def __rdBasicHeader(self, fp=None):
		381	if fp == None:
		382	fp = self.fp
		383
		384	self.basicHeaderObj.read(fp)
		385
		386
		387	def __readFirstHeader(self):
		388	self.__rdBasicHeader()
		389	self.__rdSystemHeader()
		390	self.__rdRadarControllerHeader()
		391	self.__rdProcessingHeader()
		392
		393	self.firstHeaderSize = self.basicHeaderObj.size
		394
		395	datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
		396	if datatype == 0:
		397	datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
		398	elif datatype == 1:
		399	datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
		400	elif datatype == 2:
		401	datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
		402	elif datatype == 3:
		403	datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
		404	elif datatype == 4:
		405	datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
		406	elif datatype == 5:
		407	datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
		408	else:
		409	raise ValueError, 'Data type was not defined'
		410
		411	self.dtype = datatype_str
		412	self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
		413	self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
		414	# self.dataOutObj.channelList = numpy.arange(self.systemHeaderObj.numChannels)
		415	# self.dataOutObj.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
		416	self.getBlockDimension()
		417
		418
		419	def __verifyFile(self, filename, msgFlag=True):
		420	msg = None
		421	try:
		422	fp = open(filename, 'rb')
		423	currentPosition = fp.tell()
		424	except:
		425	if msgFlag:
		426	print "The file %s can't be opened" % (filename)
		427	return False
		428
		429	neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
		430
		431	if neededSize == 0:
		432	basicHeaderObj = BasicHeader()
		433	systemHeaderObj = SystemHeader()
		434	radarControllerHeaderObj = RadarControllerHeader()
		435	processingHeaderObj = ProcessingHeader()
		436
		437	try:
		438	if not( basicHeaderObj.read(fp) ): raise ValueError
		439	if not( systemHeaderObj.read(fp) ): raise ValueError
		440	if not( radarControllerHeaderObj.read(fp) ): raise ValueError
		441	if not( processingHeaderObj.read(fp) ): raise ValueError
		442	data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
		443
		444	neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
		445
		446	except:
		447	if msgFlag:
		448	print "\tThe file %s is empty or it hasn't enough data" % filename
		449
		450	fp.close()
		451	return False
		452	else:
		453	msg = "\tSkipping the file %s due to it hasn't enough data" %filename
		454
		455	fp.close()
		456	fileSize = os.path.getsize(filename)
		457	currentSize = fileSize - currentPosition
		458	if currentSize < neededSize:
		459	if msgFlag and (msg != None):
		460	print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
		461	return False
		462
		463	return True
		464
		465	def getData():
		466	pass
		467
		468	def hasNotDataInBuffer():
		469	pass
		470
		471	def readBlock():
		472	pass
		473
		474	class JRODataWriter(JRODataIO):
		475
		476	"""
		477	Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
		478	de los datos siempre se realiza por bloques.
		479	"""
		480
		481	blockIndex = 0
		482
		483	setFile = None
		484
		485
		486	def __init__(self, dataOutObj=None):
		487	raise ValueError, "Not implemented"
		488
		489
		490	def hasAllDataInBuffer(self):
		491	raise ValueError, "Not implemented"
		492
		493
		494	def setBlockDimension(self):
		495	raise ValueError, "Not implemented"
		496
		497
		498	def writeBlock(self):
		499	raise ValueError, "No implemented"
		500
		501
		502	def putData(self):
		503	raise ValueError, "No implemented"
		504
		505
		506	def __writeFirstHeader(self):
		507	"""
		508	Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
		509
		510	Affected:
		511	__dataType
		512
		513	Return:
		514	None
		515	"""
		516
		517	# CALCULAR PARAMETROS
		518
		519	sizeLongHeader = 0#XXXX
		520	self.basicHeaderObj.size = 24 + sizeLongHeader
		521
		522	self.__writeBasicHeader()
		523	self.__wrSystemHeader()
		524	self.__wrRadarControllerHeader()
		525	self.__wrProcessingHeader()
		526	self.dtype = self.dataOutObj.dtype
		527
		528
		529	def __writeBasicHeader(self, fp=None):
		530	"""
		531	Escribe solo el Basic header en el file creado
		532
		533	Return:
		534	None
		535	"""
		536	if fp == None:
		537	fp = self.fp
		538
		539	self.dataOutObj.basicHeaderObj.write(fp)
		540
		541
		542	def __wrSystemHeader(self, fp=None):
		543	"""
		544	Escribe solo el System header en el file creado
		545
		546	Return:
		547	None
		548	"""
		549	if fp == None:
		550	fp = self.fp
		551
		552	self.dataOutObj.systemHeaderObj.write(fp)
		553
		554
		555	def __wrRadarControllerHeader(self, fp=None):
		556	"""
		557	Escribe solo el RadarController header en el file creado
		558
		559	Return:
		560	None
		561	"""
		562	if fp == None:
		563	fp = self.fp
		564
		565	self.dataOutObj.radarControllerHeaderObj.write(fp)
		566
		567
		568	def __wrProcessingHeader(self, fp=None):
		569	"""
		570	Escribe solo el Processing header en el file creado
		571
		572	Return:
		573	None
		574	"""
		575	if fp == None:
		576	fp = self.fp
		577
		578	self.dataOutObj.processingHeaderObj.write(fp)
		579
		580
		581	def setNextFile(self):
		582	"""
		583	Determina el siguiente file que sera escrito
		584
		585	Affected:
		586	self.filename
		587	self.subfolder
		588	self.fp
		589	self.setFile
		590	self.flagIsNewFile
		591
		592	Return:
		593	0 : Si el archivo no puede ser escrito
		594	1 : Si el archivo esta listo para ser escrito
		595	"""
		596	ext = self.ext
		597	path = self.path
		598
		599	if self.fp != None:
		600	self.fp.close()
		601
		602	timeTuple = time.localtime( self.dataOutObj.dataUtcTime)
		603	subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
		604
		605	doypath = os.path.join( path, subfolder )
		606	if not( os.path.exists(doypath) ):
		607	os.mkdir(doypath)
		608	self.setFile = -1 #inicializo mi contador de seteo
		609	else:
		610	filesList = os.listdir( doypath )
		611	if len( filesList ) > 0:
		612	filesList = sorted( filesList, key=str.lower )
		613	filen = filesList[-1]
		614	# el filename debera tener el siguiente formato
		615	# 0 1234 567 89A BCDE (hex)
		616	# x YYYY DDD SSS .ext
		617	if isNumber( filen[8:11] ):
		618	self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
		619	else:
		620	self.setFile = -1
		621	else:
		622	self.setFile = -1 #inicializo mi contador de seteo
		623
		624	setFile = self.setFile
		625	setFile += 1
		626
		627	file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
		628	timeTuple.tm_year,
		629	timeTuple.tm_yday,
		630	setFile,
		631	ext )
		632
		633	filename = os.path.join( path, subfolder, file )
		634
		635	fp = open( filename,'wb' )
		636
		637	self.blockIndex = 0
		638
		639	#guardando atributos
		640	self.filename = filename
		641	self.subfolder = subfolder
		642	self.fp = fp
		643	self.setFile = setFile
		644	self.flagIsNewFile = 1
		645
		646	print 'Writing the file: %s'%self.filename
		647
		648	self.__writeFirstHeader()
		649
		650	return 1
		651
		652
		653	def __setNewBlock(self):
		654	"""
		655	Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
		656
		657	Return:
		658	0 : si no pudo escribir nada
		659	1 : Si escribio el Basic el First Header
		660	"""
		661	if self.fp == None:
		662	self.setNextFile()
		663
		664	if self.flagIsNewFile:
		665	return 1
		666
		667	if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
		668	self.__writeBasicHeader()
		669	return 1
		670
		671	if not( self.setNextFile() ):
		672	return 0
		673
		674	return 1
		675
		676
		677	def writeNextBlock(self):
		678	"""
		679	Selecciona el bloque siguiente de datos y los escribe en un file
		680
		681	Return:
		682	0 : Si no hizo pudo escribir el bloque de datos
		683	1 : Si no pudo escribir el bloque de datos
		684	"""
		685	if not( self.__setNewBlock() ):
		686	return 0
		687
		688	self.writeBlock()
		689
		690	return 1
		691
		692
		693	def getDataHeader(self):
		694	"""Obtiene una copia del First Header Affected: self.basicHeaderObj self.
		695	systemHeaderObj self.radarControllerHeaderObj self.processingHeaderObj self.
		696	dtype Return: None
		697	"""
		698
		699	raise ValueError, "No implemented"
		700
		701	def setup(self, path, set=0, ext=None):
		702	"""
		703	Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
		704
		705	Inputs:
		706	path : el path destino en el cual se escribiran los files a crear
		707	format : formato en el cual sera salvado un file
		708	set : el setebo del file
		709
		710	Return:
		711	0 : Si no realizo un buen seteo
		712	1 : Si realizo un buen seteo
		713	"""
		714
		715	if ext == None:
		716	ext = self.ext
		717
		718	ext = ext.lower()
		719
		720	self.path = path
		721	self.setFile = set - 1
		722	self.ext = ext
		723	#self.format = format
		724	self.getDataHeader()
		725
		726	self.setBlockDimension()
		727
		728	if not( self.setNextFile() ):
		729	print "There isn't a next file"
		730	return 0
		731
		732	return 1
		733
		734
		735
		736
		737
		738

schainpy2/IO/JROHeader.py +505 -505

This diff has been collapsed as it changes many lines, (1010 lines changed) Show them Hide them
			@@ -1,506 +1,506
	1		'''
	2		Created on 23/01/2012
	3
	4		@author $Author: vsarmiento $
	5		@version $Id: HeaderIO.py 37 2012-03-26 22:55:13Z vsarmiento $
	6		'''
	7
	8		import numpy
	9		import copy
	10
	11		class Header:
	12
	13		def __init__(self):
	14		raise
	15
	16		def copy(self):
	17		return copy.deepcopy(self)
	18
	19		def read():
	20		pass
	21
	22		def write():
	23		pass
	24
	25		class BasicHeader(Header):
	26
	27		size = None
	28		version = None
	29		dataBlock = None
	30		utc = None
	31		miliSecond = None
	32		timeZone = None
	33		dstFlag = None
	34		errorCount = None
	35		struct = None
	36
	37		def __init__(self):
	38
	39		self.size = 0
	40		self.version = 0
	41		self.dataBlock = 0
	42		self.utc = 0
	43		self.miliSecond = 0
	44		self.timeZone = 0
	45		self.dstFlag = 0
	46		self.errorCount = 0
	47		self.struct = numpy.dtype([
	48		('nSize','<u4'),
	49		('nVersion','<u2'),
	50		('nDataBlockId','<u4'),
	51		('nUtime','<u4'),
	52		('nMilsec','<u2'),
	53		('nTimezone','<i2'),
	54		('nDstflag','<i2'),
	55		('nErrorCount','<u4')
	56		])
	57
	58
	59		def read(self, fp):
	60		try:
	61		header = numpy.fromfile(fp, self.struct,1)
	62		self.size = header['nSize'][0]
	63		self.version = header['nVersion'][0]
	64		self.dataBlock = header['nDataBlockId'][0]
	65		self.utc = header['nUtime'][0]
	66		self.miliSecond = header['nMilsec'][0]
	67		self.timeZone = header['nTimezone'][0]
	68		self.dstFlag = header['nDstflag'][0]
	69		self.errorCount = header['nErrorCount'][0]
	70		except:
	71		return 0
	72
	73		return 1
	74
	75		def write(self, fp):
	76		headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
	77		header = numpy.array(headerTuple,self.struct)
	78		header.tofile(fp)
	79
	80		return 1
	81
	82		class SystemHeader(Header):
	83
	84		size = None
	85		nSamples = None
	86		nProfiles = None
	87		nChannels = None
	88		adcResolution = None
	89		pciDioBusWidth = None
	90		struct = None
	91
	92		def __init__(self):
	93		self.size = 0
	94		self.nSamples = 0
	95		self.nProfiles = 0
	96		self.nChannels = 0
	97		self.adcResolution = 0
	98		self.pciDioBusWidth = 0
	99		self.struct = numpy.dtype([
	100		('nSize','<u4'),
	101		('nNumSamples','<u4'),
	102		('nNumProfiles','<u4'),
	103		('nNumChannels','<u4'),
	104		('nADCResolution','<u4'),
	105		('nPCDIOBusWidth','<u4'),
	106		])
	107
	108
	109		def read(self, fp):
	110		try:
	111		header = numpy.fromfile(fp,self.struct,1)
	112		self.size = header['nSize'][0]
	113		self.nSamples = header['nNumSamples'][0]
	114		self.nProfiles = header['nNumProfiles'][0]
	115		self.nChannels = header['nNumChannels'][0]
	116		self.adcResolution = header['nADCResolution'][0]
	117		self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
	118		except:
	119		return 0
	120
	121		return 1
	122
	123		def write(self, fp):
	124		headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
	125		header = numpy.array(headerTuple,self.struct)
	126		header.tofile(fp)
	127
	128		return 1
	129
	130		class RadarControllerHeader(Header):
	131
	132		size = None
	133		expType = None
	134		nTx = None
	135		ipp = None
	136		txA = None
	137		txB = None
	138		nWindows = None
	139		numTaus = None
	140		codeType = None
	141		line6Function = None
	142		line5Function = None
	143		fClock = None
	144		prePulseBefore = None
	145		prePulserAfter = None
	146		rangeIpp = None
	147		rangeTxA = None
	148		rangeTxB = None
	149		struct = None
	150
	151		def __init__(self):
	152		self.size = 0
	153		self.expType = 0
	154		self.nTx = 0
	155		self.ipp = 0
	156		self.txA = 0
	157		self.txB = 0
	158		self.nWindows = 0
	159		self.numTaus = 0
	160		self.codeType = 0
	161		self.line6Function = 0
	162		self.line5Function = 0
	163		self.fClock = 0
	164		self.prePulseBefore = 0
	165		self.prePulserAfter = 0
	166		self.rangeIpp = 0
	167		self.rangeTxA = 0
	168		self.rangeTxB = 0
	169		self.struct = numpy.dtype([
	170		('nSize','<u4'),
	171		('nExpType','<u4'),
	172		('nNTx','<u4'),
	173		('fIpp','<f4'),
	174		('fTxA','<f4'),
	175		('fTxB','<f4'),
	176		('nNumWindows','<u4'),
	177		('nNumTaus','<u4'),
	178		('nCodeType','<u4'),
	179		('nLine6Function','<u4'),
	180		('nLine5Function','<u4'),
	181		('fClock','<f4'),
	182		('nPrePulseBefore','<u4'),
	183		('nPrePulseAfter','<u4'),
	184		('sRangeIPP','<a20'),
	185		('sRangeTxA','<a20'),
	186		('sRangeTxB','<a20'),
	187		])
	188
	189		self.samplingWindowStruct = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
	190
	191		self.samplingWindow = None
	192		self.nHeights = None
	193		self.firstHeight = None
	194		self.deltaHeight = None
	195		self.samplesWin = None
	196
	197		self.numCode = None
	198		self.numBaud = None
	199		self.code = None
	200		self.flip1 = None
	201		self.flip2 = None
	202
	203		self.dynamic = numpy.array([],numpy.dtype('byte'))
	204
	205
	206		def read(self, fp):
	207		try:
	208		startFp = fp.tell()
	209		header = numpy.fromfile(fp,self.struct,1)
	210		self.size = header['nSize'][0]
	211		self.expType = header['nExpType'][0]
	212		self.nTx = header['nNTx'][0]
	213		self.ipp = header['fIpp'][0]
	214		self.txA = header['fTxA'][0]
	215		self.txB = header['fTxB'][0]
	216		self.nWindows = header['nNumWindows'][0]
	217		self.numTaus = header['nNumTaus'][0]
	218		self.codeType = header['nCodeType'][0]
	219		self.line6Function = header['nLine6Function'][0]
	220		self.line5Function = header['nLine5Function'][0]
	221		self.fClock = header['fClock'][0]
	222		self.prePulseBefore = header['nPrePulseBefore'][0]
	223		self.prePulserAfter = header['nPrePulseAfter'][0]
	224		self.rangeIpp = header['sRangeIPP'][0]
	225		self.rangeTxA = header['sRangeTxA'][0]
	226		self.rangeTxB = header['sRangeTxB'][0]
	227		# jump Dynamic Radar Controller Header
	228		jumpFp = self.size - 116
	229		self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpFp)
	230		#pointer backward to dynamic header and read
	231		backFp = fp.tell() - jumpFp
	232		fp.seek(backFp)
	233
	234		self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.nWindows)
	235		self.nHeights = numpy.sum(self.samplingWindow['nsa'])
	236		self.firstHeight = self.samplingWindow['h0']
	237		self.deltaHeight = self.samplingWindow['dh']
	238		self.samplesWin = self.samplingWindow['nsa']
	239
	240		self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
	241
	242		if self.codeType != 0:
	243		self.numCode = numpy.fromfile(fp,'<u4',1)
	244		self.numBaud = numpy.fromfile(fp,'<u4',1)
	245		self.code = numpy.empty([self.numCode,self.numBaud],dtype='u1')
	246		tempList = []
	247		for ic in range(self.numCode):
	248		temp = numpy.fromfile(fp,'u1',4*numpy.ceil(self.numBaud/32.))
	249		tempList.append(temp)
	250		self.code[ic] = numpy.unpackbits(temp[::-1])[-1*self.numBaud:]
	251		self.code = 2.0*self.code - 1.0
	252
	253		if self.line5Function == RCfunction.FLIP:
	254		self.flip1 = numpy.fromfile(fp,'<u4',1)
	255
	256		if self.line6Function == RCfunction.FLIP:
	257		self.flip2 = numpy.fromfile(fp,'<u4',1)
	258
	259		endFp = self.size + startFp
	260		jumpFp = endFp - fp.tell()
	261		if jumpFp > 0:
	262		fp.seek(jumpFp)
	263
	264		except:
	265		return 0
	266
	267		return 1
	268
	269		def write(self, fp):
	270		headerTuple = (self.size,
	271		self.expType,
	272		self.nTx,
	273		self.ipp,
	274		self.txA,
	275		self.txB,
	276		self.nWindows,
	277		self.numTaus,
	278		self.codeType,
	279		self.line6Function,
	280		self.line5Function,
	281		self.fClock,
	282		self.prePulseBefore,
	283		self.prePulserAfter,
	284		self.rangeIpp,
	285		self.rangeTxA,
	286		self.rangeTxB)
	287
	288		header = numpy.array(headerTuple,self.struct)
	289		header.tofile(fp)
	290
	291		dynamic = self.dynamic
	292		dynamic.tofile(fp)
	293
	294		return 1
	295
	296
	297
	298		class ProcessingHeader(Header):
	299
	300		size = None
	301		dtype = None
	302		blockSize = None
	303		profilesPerBlock = None
	304		dataBlocksPerFile = None
	305		nWindows = None
	306		processFlags = None
	307		nCohInt = None
	308		nIncohInt = None
	309		totalSpectra = None
	310		struct = None
	311		flag_dc = None
	312		flag_cspc = None
	313
	314		def __init__(self):
	315		self.size = 0
	316		self.dataType = 0
	317		self.blockSize = 0
	318		self.profilesPerBlock = 0
	319		self.dataBlocksPerFile = 0
	320		self.nWindows = 0
	321		self.processFlags = 0
	322		self.nCohInt = 0
	323		self.nIncohInt = 0
	324		self.totalSpectra = 0
	325		self.struct = numpy.dtype([
	326		('nSize','<u4'),
	327		('nDataType','<u4'),
	328		('nSizeOfDataBlock','<u4'),
	329		('nProfilesperBlock','<u4'),
	330		('nDataBlocksperFile','<u4'),
	331		('nNumWindows','<u4'),
	332		('nProcessFlags','<u4'),
	333		('nCoherentIntegrations','<u4'),
	334		('nIncoherentIntegrations','<u4'),
	335		('nTotalSpectra','<u4')
	336		])
	337		self.samplingWindow = 0
	338		self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
	339		self.nHeights = 0
	340		self.firstHeight = 0
	341		self.deltaHeight = 0
	342		self.samplesWin = 0
	343		self.spectraComb = 0
	344		self.numCode = 0
	345		self.code = 0
	346		self.numBaud = 0
	347		self.shif_fft = False
	348		self.flag_dc = False
	349		self.flag_cspc = False
	350
	351		def read(self, fp):
	352		try:
	353		header = numpy.fromfile(fp,self.struct,1)
	354		self.size = header['nSize'][0]
	355		self.dataType = header['nDataType'][0]
	356		self.blockSize = header['nSizeOfDataBlock'][0]
	357		self.profilesPerBlock = header['nProfilesperBlock'][0]
	358		self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
	359		self.nWindows = header['nNumWindows'][0]
	360		self.processFlags = header['nProcessFlags']
	361		self.nCohInt = header['nCoherentIntegrations'][0]
	362		self.nIncohInt = header['nIncoherentIntegrations'][0]
	363		self.totalSpectra = header['nTotalSpectra'][0]
	364		self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.nWindows)
	365		self.nHeights = numpy.sum(self.samplingWindow['nsa'])
	366		self.firstHeight = self.samplingWindow['h0'][0]
	367		self.deltaHeight = self.samplingWindow['dh'][0]
	368		self.samplesWin = self.samplingWindow['nsa']
	369		self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
	370
	371		if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
	372		self.numCode = numpy.fromfile(fp,'<u4',1)
	373		self.numBaud = numpy.fromfile(fp,'<u4',1)
	374		self.code = numpy.fromfile(fp,'<f4',self.numCode*self.numBaud).reshape(self.numBaud,self.numCode)
	375
	376		if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
	377		self.shif_fft = True
	378		else:
	379		self.shif_fft = False
	380
	381		if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
	382		self.flag_dc = True
	383
	384		nChannels = 0
	385		nPairs = 0
	386		pairList = []
	387
	388		for i in range( 0, self.totalSpectra*2, 2 ):
	389		if self.spectraComb[i] == self.spectraComb[i+1]:
	390		nChannels = nChannels + 1 #par de canales iguales
	391		else:
	392		nPairs = nPairs + 1 #par de canales diferentes
	393		pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
	394
	395		self.flag_cspc = False
	396		if nPairs > 0:
	397		self.flag_cspc = True
	398
	399		except:
	400		return 0
	401
	402		return 1
	403
	404		def write(self, fp):
	405		headerTuple = (self.size,
	406		self.dataType,
	407		self.blockSize,
	408		self.profilesPerBlock,
	409		self.dataBlocksPerFile,
	410		self.nWindows,
	411		self.processFlags,
	412		self.nCohInt,
	413		self.nIncohInt,
	414		self.totalSpectra)
	415
	416		header = numpy.array(headerTuple,self.struct)
	417		header.tofile(fp)
	418
	419		if self.nWindows != 0:
	420		sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
	421		samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
	422		samplingWindow.tofile(fp)
	423
	424
	425		if self.totalSpectra != 0:
	426		spectraComb = numpy.array([],numpy.dtype('u1'))
	427		spectraComb = self.spectraComb
	428		spectraComb.tofile(fp)
	429
	430
	431		if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
	432		numCode = self.numCode
	433		numCode.tofile(fp)
	434
	435		numBaud = self.numBaud
	436		numBaud.tofile(fp)
	437
	438		code = self.code.reshape(numCode*numBaud)
	439		code.tofile(fp)
	440
	441		return 1
	442
	443		class RCfunction:
	444		NONE=0
	445		FLIP=1
	446		CODE=2
	447		SAMPLING=3
	448		LIN6DIV256=4
	449		SYNCHRO=5
	450
	451		class nCodeType:
	452		NONE=0
	453		USERDEFINE=1
	454		BARKER2=2
	455		BARKER3=3
	456		BARKER4=4
	457		BARKER5=5
	458		BARKER7=6
	459		BARKER11=7
	460		BARKER13=8
	461		AC128=9
	462		COMPLEMENTARYCODE2=10
	463		COMPLEMENTARYCODE4=11
	464		COMPLEMENTARYCODE8=12
	465		COMPLEMENTARYCODE16=13
	466		COMPLEMENTARYCODE32=14
	467		COMPLEMENTARYCODE64=15
	468		COMPLEMENTARYCODE128=16
	469		CODE_BINARY28=17
	470
	471		class PROCFLAG:
	472		COHERENT_INTEGRATION = numpy.uint32(0x00000001)
	473		DECODE_DATA = numpy.uint32(0x00000002)
	474		SPECTRA_CALC = numpy.uint32(0x00000004)
	475		INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
	476		POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
	477		SHIFT_FFT_DATA = numpy.uint32(0x00000020)
	478
	479		DATATYPE_CHAR = numpy.uint32(0x00000040)
	480		DATATYPE_SHORT = numpy.uint32(0x00000080)
	481		DATATYPE_LONG = numpy.uint32(0x00000100)
	482		DATATYPE_INT64 = numpy.uint32(0x00000200)
	483		DATATYPE_FLOAT = numpy.uint32(0x00000400)
	484		DATATYPE_DOUBLE = numpy.uint32(0x00000800)
	485
	486		DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
	487		DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
	488		DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
	489
	490		SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
	491		DEFLIP_DATA = numpy.uint32(0x00010000)
	492		DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
	493
	494		ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
	495		ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
	496		ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
	497		ACQ_SYS_JULIA = numpy.uint32(0x00100000)
	498		ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
	499
	500		EXP_NAME_ESP = numpy.uint32(0x00200000)
	501		CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
	502
	503		OPERATION_MASK = numpy.uint32(0x0000003F)
	504		DATATYPE_MASK = numpy.uint32(0x00000FC0)
	505		DATAARRANGE_MASK = numpy.uint32(0x00007000)
		1	'''
		2	Created on 23/01/2012
		3
		4	@author $Author: vsarmiento $
		5	@version $Id: HeaderIO.py 37 2012-03-26 22:55:13Z vsarmiento $
		6	'''
		7
		8	import numpy
		9	import copy
		10
		11	class Header:
		12
		13	def __init__(self):
		14	raise
		15
		16	def copy(self):
		17	return copy.deepcopy(self)
		18
		19	def read():
		20	pass
		21
		22	def write():
		23	pass
		24
		25	class BasicHeader(Header):
		26
		27	size = None
		28	version = None
		29	dataBlock = None
		30	utc = None
		31	miliSecond = None
		32	timeZone = None
		33	dstFlag = None
		34	errorCount = None
		35	struct = None
		36
		37	def __init__(self):
		38
		39	self.size = 0
		40	self.version = 0
		41	self.dataBlock = 0
		42	self.utc = 0
		43	self.miliSecond = 0
		44	self.timeZone = 0
		45	self.dstFlag = 0
		46	self.errorCount = 0
		47	self.struct = numpy.dtype([
		48	('nSize','<u4'),
		49	('nVersion','<u2'),
		50	('nDataBlockId','<u4'),
		51	('nUtime','<u4'),
		52	('nMilsec','<u2'),
		53	('nTimezone','<i2'),
		54	('nDstflag','<i2'),
		55	('nErrorCount','<u4')
		56	])
		57
		58
		59	def read(self, fp):
		60	try:
		61	header = numpy.fromfile(fp, self.struct,1)
		62	self.size = header['nSize'][0]
		63	self.version = header['nVersion'][0]
		64	self.dataBlock = header['nDataBlockId'][0]
		65	self.utc = header['nUtime'][0]
		66	self.miliSecond = header['nMilsec'][0]
		67	self.timeZone = header['nTimezone'][0]
		68	self.dstFlag = header['nDstflag'][0]
		69	self.errorCount = header['nErrorCount'][0]
		70	except:
		71	return 0
		72
		73	return 1
		74
		75	def write(self, fp):
		76	headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
		77	header = numpy.array(headerTuple,self.struct)
		78	header.tofile(fp)
		79
		80	return 1
		81
		82	class SystemHeader(Header):
		83
		84	size = None
		85	nSamples = None
		86	nProfiles = None
		87	nChannels = None
		88	adcResolution = None
		89	pciDioBusWidth = None
		90	struct = None
		91
		92	def __init__(self):
		93	self.size = 0
		94	self.nSamples = 0
		95	self.nProfiles = 0
		96	self.nChannels = 0
		97	self.adcResolution = 0
		98	self.pciDioBusWidth = 0
		99	self.struct = numpy.dtype([
		100	('nSize','<u4'),
		101	('nNumSamples','<u4'),
		102	('nNumProfiles','<u4'),
		103	('nNumChannels','<u4'),
		104	('nADCResolution','<u4'),
		105	('nPCDIOBusWidth','<u4'),
		106	])
		107
		108
		109	def read(self, fp):
		110	try:
		111	header = numpy.fromfile(fp,self.struct,1)
		112	self.size = header['nSize'][0]
		113	self.nSamples = header['nNumSamples'][0]
		114	self.nProfiles = header['nNumProfiles'][0]
		115	self.nChannels = header['nNumChannels'][0]
		116	self.adcResolution = header['nADCResolution'][0]
		117	self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
		118	except:
		119	return 0
		120
		121	return 1
		122
		123	def write(self, fp):
		124	headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
		125	header = numpy.array(headerTuple,self.struct)
		126	header.tofile(fp)
		127
		128	return 1
		129
		130	class RadarControllerHeader(Header):
		131
		132	size = None
		133	expType = None
		134	nTx = None
		135	ipp = None
		136	txA = None
		137	txB = None
		138	nWindows = None
		139	numTaus = None
		140	codeType = None
		141	line6Function = None
		142	line5Function = None
		143	fClock = None
		144	prePulseBefore = None
		145	prePulserAfter = None
		146	rangeIpp = None
		147	rangeTxA = None
		148	rangeTxB = None
		149	struct = None
		150
		151	def __init__(self):
		152	self.size = 0
		153	self.expType = 0
		154	self.nTx = 0
		155	self.ipp = 0
		156	self.txA = 0
		157	self.txB = 0
		158	self.nWindows = 0
		159	self.numTaus = 0
		160	self.codeType = 0
		161	self.line6Function = 0
		162	self.line5Function = 0
		163	self.fClock = 0
		164	self.prePulseBefore = 0
		165	self.prePulserAfter = 0
		166	self.rangeIpp = 0
		167	self.rangeTxA = 0
		168	self.rangeTxB = 0
		169	self.struct = numpy.dtype([
		170	('nSize','<u4'),
		171	('nExpType','<u4'),
		172	('nNTx','<u4'),
		173	('fIpp','<f4'),
		174	('fTxA','<f4'),
		175	('fTxB','<f4'),
		176	('nNumWindows','<u4'),
		177	('nNumTaus','<u4'),
		178	('nCodeType','<u4'),
		179	('nLine6Function','<u4'),
		180	('nLine5Function','<u4'),
		181	('fClock','<f4'),
		182	('nPrePulseBefore','<u4'),
		183	('nPrePulseAfter','<u4'),
		184	('sRangeIPP','<a20'),
		185	('sRangeTxA','<a20'),
		186	('sRangeTxB','<a20'),
		187	])
		188
		189	self.samplingWindowStruct = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
		190
		191	self.samplingWindow = None
		192	self.nHeights = None
		193	self.firstHeight = None
		194	self.deltaHeight = None
		195	self.samplesWin = None
		196
		197	self.numCode = None
		198	self.numBaud = None
		199	self.code = None
		200	self.flip1 = None
		201	self.flip2 = None
		202
		203	self.dynamic = numpy.array([],numpy.dtype('byte'))
		204
		205
		206	def read(self, fp):
		207	try:
		208	startFp = fp.tell()
		209	header = numpy.fromfile(fp,self.struct,1)
		210	self.size = header['nSize'][0]
		211	self.expType = header['nExpType'][0]
		212	self.nTx = header['nNTx'][0]
		213	self.ipp = header['fIpp'][0]
		214	self.txA = header['fTxA'][0]
		215	self.txB = header['fTxB'][0]
		216	self.nWindows = header['nNumWindows'][0]
		217	self.numTaus = header['nNumTaus'][0]
		218	self.codeType = header['nCodeType'][0]
		219	self.line6Function = header['nLine6Function'][0]
		220	self.line5Function = header['nLine5Function'][0]
		221	self.fClock = header['fClock'][0]
		222	self.prePulseBefore = header['nPrePulseBefore'][0]
		223	self.prePulserAfter = header['nPrePulseAfter'][0]
		224	self.rangeIpp = header['sRangeIPP'][0]
		225	self.rangeTxA = header['sRangeTxA'][0]
		226	self.rangeTxB = header['sRangeTxB'][0]
		227	# jump Dynamic Radar Controller Header
		228	jumpFp = self.size - 116
		229	self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpFp)
		230	#pointer backward to dynamic header and read
		231	backFp = fp.tell() - jumpFp
		232	fp.seek(backFp)
		233
		234	self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.nWindows)
		235	self.nHeights = numpy.sum(self.samplingWindow['nsa'])
		236	self.firstHeight = self.samplingWindow['h0']
		237	self.deltaHeight = self.samplingWindow['dh']
		238	self.samplesWin = self.samplingWindow['nsa']
		239
		240	self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
		241
		242	if self.codeType != 0:
		243	self.numCode = numpy.fromfile(fp,'<u4',1)
		244	self.numBaud = numpy.fromfile(fp,'<u4',1)
		245	self.code = numpy.empty([self.numCode,self.numBaud],dtype='u1')
		246	tempList = []
		247	for ic in range(self.numCode):
		248	temp = numpy.fromfile(fp,'u1',4*numpy.ceil(self.numBaud/32.))
		249	tempList.append(temp)
		250	self.code[ic] = numpy.unpackbits(temp[::-1])[-1*self.numBaud:]
		251	self.code = 2.0*self.code - 1.0
		252
		253	if self.line5Function == RCfunction.FLIP:
		254	self.flip1 = numpy.fromfile(fp,'<u4',1)
		255
		256	if self.line6Function == RCfunction.FLIP:
		257	self.flip2 = numpy.fromfile(fp,'<u4',1)
		258
		259	endFp = self.size + startFp
		260	jumpFp = endFp - fp.tell()
		261	if jumpFp > 0:
		262	fp.seek(jumpFp)
		263
		264	except:
		265	return 0
		266
		267	return 1
		268
		269	def write(self, fp):
		270	headerTuple = (self.size,
		271	self.expType,
		272	self.nTx,
		273	self.ipp,
		274	self.txA,
		275	self.txB,
		276	self.nWindows,
		277	self.numTaus,
		278	self.codeType,
		279	self.line6Function,
		280	self.line5Function,
		281	self.fClock,
		282	self.prePulseBefore,
		283	self.prePulserAfter,
		284	self.rangeIpp,
		285	self.rangeTxA,
		286	self.rangeTxB)
		287
		288	header = numpy.array(headerTuple,self.struct)
		289	header.tofile(fp)
		290
		291	dynamic = self.dynamic
		292	dynamic.tofile(fp)
		293
		294	return 1
		295
		296
		297
		298	class ProcessingHeader(Header):
		299
		300	size = None
		301	dtype = None
		302	blockSize = None
		303	profilesPerBlock = None
		304	dataBlocksPerFile = None
		305	nWindows = None
		306	processFlags = None
		307	nCohInt = None
		308	nIncohInt = None
		309	totalSpectra = None
		310	struct = None
		311	flag_dc = None
		312	flag_cspc = None
		313
		314	def __init__(self):
		315	self.size = 0
		316	self.dataType = 0
		317	self.blockSize = 0
		318	self.profilesPerBlock = 0
		319	self.dataBlocksPerFile = 0
		320	self.nWindows = 0
		321	self.processFlags = 0
		322	self.nCohInt = 0
		323	self.nIncohInt = 0
		324	self.totalSpectra = 0
		325	self.struct = numpy.dtype([
		326	('nSize','<u4'),
		327	('nDataType','<u4'),
		328	('nSizeOfDataBlock','<u4'),
		329	('nProfilesperBlock','<u4'),
		330	('nDataBlocksperFile','<u4'),
		331	('nNumWindows','<u4'),
		332	('nProcessFlags','<u4'),
		333	('nCoherentIntegrations','<u4'),
		334	('nIncoherentIntegrations','<u4'),
		335	('nTotalSpectra','<u4')
		336	])
		337	self.samplingWindow = 0
		338	self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
		339	self.nHeights = 0
		340	self.firstHeight = 0
		341	self.deltaHeight = 0
		342	self.samplesWin = 0
		343	self.spectraComb = 0
		344	self.numCode = 0
		345	self.code = 0
		346	self.numBaud = 0
		347	self.shif_fft = False
		348	self.flag_dc = False
		349	self.flag_cspc = False
		350
		351	def read(self, fp):
		352	try:
		353	header = numpy.fromfile(fp,self.struct,1)
		354	self.size = header['nSize'][0]
		355	self.dataType = header['nDataType'][0]
		356	self.blockSize = header['nSizeOfDataBlock'][0]
		357	self.profilesPerBlock = header['nProfilesperBlock'][0]
		358	self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
		359	self.nWindows = header['nNumWindows'][0]
		360	self.processFlags = header['nProcessFlags']
		361	self.nCohInt = header['nCoherentIntegrations'][0]
		362	self.nIncohInt = header['nIncoherentIntegrations'][0]
		363	self.totalSpectra = header['nTotalSpectra'][0]
		364	self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.nWindows)
		365	self.nHeights = numpy.sum(self.samplingWindow['nsa'])
		366	self.firstHeight = self.samplingWindow['h0'][0]
		367	self.deltaHeight = self.samplingWindow['dh'][0]
		368	self.samplesWin = self.samplingWindow['nsa']
		369	self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
		370
		371	if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
		372	self.numCode = numpy.fromfile(fp,'<u4',1)
		373	self.numBaud = numpy.fromfile(fp,'<u4',1)
		374	self.code = numpy.fromfile(fp,'<f4',self.numCode*self.numBaud).reshape(self.numBaud,self.numCode)
		375
		376	if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
		377	self.shif_fft = True
		378	else:
		379	self.shif_fft = False
		380
		381	if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
		382	self.flag_dc = True
		383
		384	nChannels = 0
		385	nPairs = 0
		386	pairList = []
		387
		388	for i in range( 0, self.totalSpectra*2, 2 ):
		389	if self.spectraComb[i] == self.spectraComb[i+1]:
		390	nChannels = nChannels + 1 #par de canales iguales
		391	else:
		392	nPairs = nPairs + 1 #par de canales diferentes
		393	pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
		394
		395	self.flag_cspc = False
		396	if nPairs > 0:
		397	self.flag_cspc = True
		398
		399	except:
		400	return 0
		401
		402	return 1
		403
		404	def write(self, fp):
		405	headerTuple = (self.size,
		406	self.dataType,
		407	self.blockSize,
		408	self.profilesPerBlock,
		409	self.dataBlocksPerFile,
		410	self.nWindows,
		411	self.processFlags,
		412	self.nCohInt,
		413	self.nIncohInt,
		414	self.totalSpectra)
		415
		416	header = numpy.array(headerTuple,self.struct)
		417	header.tofile(fp)
		418
		419	if self.nWindows != 0:
		420	sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
		421	samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
		422	samplingWindow.tofile(fp)
		423
		424
		425	if self.totalSpectra != 0:
		426	spectraComb = numpy.array([],numpy.dtype('u1'))
		427	spectraComb = self.spectraComb
		428	spectraComb.tofile(fp)
		429
		430
		431	if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
		432	numCode = self.numCode
		433	numCode.tofile(fp)
		434
		435	numBaud = self.numBaud
		436	numBaud.tofile(fp)
		437
		438	code = self.code.reshape(numCode*numBaud)
		439	code.tofile(fp)
		440
		441	return 1
		442
		443	class RCfunction:
		444	NONE=0
		445	FLIP=1
		446	CODE=2
		447	SAMPLING=3
		448	LIN6DIV256=4
		449	SYNCHRO=5
		450
		451	class nCodeType:
		452	NONE=0
		453	USERDEFINE=1
		454	BARKER2=2
		455	BARKER3=3
		456	BARKER4=4
		457	BARKER5=5
		458	BARKER7=6
		459	BARKER11=7
		460	BARKER13=8
		461	AC128=9
		462	COMPLEMENTARYCODE2=10
		463	COMPLEMENTARYCODE4=11
		464	COMPLEMENTARYCODE8=12
		465	COMPLEMENTARYCODE16=13
		466	COMPLEMENTARYCODE32=14
		467	COMPLEMENTARYCODE64=15
		468	COMPLEMENTARYCODE128=16
		469	CODE_BINARY28=17
		470
		471	class PROCFLAG:
		472	COHERENT_INTEGRATION = numpy.uint32(0x00000001)
		473	DECODE_DATA = numpy.uint32(0x00000002)
		474	SPECTRA_CALC = numpy.uint32(0x00000004)
		475	INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
		476	POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
		477	SHIFT_FFT_DATA = numpy.uint32(0x00000020)
		478
		479	DATATYPE_CHAR = numpy.uint32(0x00000040)
		480	DATATYPE_SHORT = numpy.uint32(0x00000080)
		481	DATATYPE_LONG = numpy.uint32(0x00000100)
		482	DATATYPE_INT64 = numpy.uint32(0x00000200)
		483	DATATYPE_FLOAT = numpy.uint32(0x00000400)
		484	DATATYPE_DOUBLE = numpy.uint32(0x00000800)
		485
		486	DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
		487	DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
		488	DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
		489
		490	SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
		491	DEFLIP_DATA = numpy.uint32(0x00010000)
		492	DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
		493
		494	ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
		495	ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
		496	ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
		497	ACQ_SYS_JULIA = numpy.uint32(0x00100000)
		498	ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
		499
		500	EXP_NAME_ESP = numpy.uint32(0x00200000)
		501	CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
		502
		503	OPERATION_MASK = numpy.uint32(0x0000003F)
		504	DATATYPE_MASK = numpy.uint32(0x00000FC0)
		505	DATAARRANGE_MASK = numpy.uint32(0x00007000)
	506	506	ACQ_SYS_MASK = numpy.uint32(0x001C0000) No newline at end of file

schainpy2/IO/SpectraIO.py +83 -48

              '''
              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 Model.JROHeader import *
-             from Model.Spectra import Spectra
+             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
                  """
-                 dataOutObj = None
-                 datablock = None
                  pts2read_SelfSpectra = 0
                  pts2read_CrossSpectra = 0
                  pts2read_DCchannels = 0
                  ext = ".pdata"
                  optchar = "P"
-                 flag_cspc = False
+                 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_DCs = 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.nChannels
-                         self.nPairs
+                         self.nRdChannels
+                         self.nRdPairs
                          self.pts2read_SelfSpectra
                          self.pts2read_CrossSpectra
                          self.pts2read_DCchannels
                          self.blocksize
                          self.dataOutObj.nChannels
                          self.dataOutObj.nPairs
                      Return:
                          None
                      """
-                     self.nChannels = 0
-                     self.nPairs = 0
-                     self.pairList = []
+                     self.nRdChannels = 0
+                     self.nRdPairs = 0
+                     self.rdPairList = []
                      for i in range( 0, self.processingHeaderObj.totalSpectra*2, 2 ):
                          if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
-                             self.nChannels = self.nChannels + 1   #par de canales iguales
+                             self.nRdChannels = self.nRdChannels + 1   #par de canales iguales
                          else:
-                             self.nPairs = self.nPairs + 1 #par de canales diferentes
-                             self.pairList.append( (self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]) )
+                             self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
+                             self.rdPairList.append( (self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]) )
-                     pts2read = self.processingHeaderObj.numHeights * self.processingHeaderObj.profilesPerBlock
+                     pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
-                     self.pts2read_SelfSpectra = int(self.nChannels * pts2read)
+                     self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
                      self.blocksize = self.pts2read_SelfSpectra
                      if self.processingHeaderObj.flag_cspc:
-                         self.pts2read_CrossSpectra = int(self.nPairs * pts2read)
+                         self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
                          self.blocksize += self.pts2read_CrossSpectra
                      if self.processingHeaderObj.flag_dc:
-                         self.pts2read_DCchannels = int(self.systemHeaderObj.numChannels * self.processingHeaderObj.numHeights)
+                         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.datablockIndex
                          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.dataType[0], self.pts2read_SelfSpectra )
-                     spc = spc.reshape( (self.nChannels, self.processingHeaderObj.numHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
+                     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.flag_cspc:
-                         cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
-                         cspc = cspc.reshape( (self.nPairs, self.processingHeaderObj.numHeights, 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.dataType, self.pts2read_DCchannels ) #int(self.processingHeaderObj.numHeights*self.systemHeaderObj.numChannels) )
-                         dc = dc.reshape( (self.systemHeaderObj.numChannels, self.processingHeaderObj.numHeights) ) #transforma a un arreglo 2D
+                         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.flag_cspc:
+                         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.flag_cspc:
+                     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.datablockIndex = 0
                      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.datablockIndex
                          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()
+             #            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.flagNoData = False
-                     self.dataOutObj.flagTimeBlock = self.flagTimeBlock
                      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.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.
                  """
-                 dataOutObj = None
                  shape_spc_Buffer = None
                  shape_cspc_Buffer = None
                  shape_dc_Buffer = None
-                 data_spc = None
-                 data_cspc = None
-                 data_dc = None
+                 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.flagIsNewFile = 1
                      self.nTotalBlocks = 0
                      self.flagIsNewBlock = 0
                      self.flagNoMoreFiles = 0
                      self.setFile = None
-                     self.dataType = 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.numHeights,
+                                              self.processingHeaderObj.nHeights,
                                               self.processingHeaderObj.profilesPerBlock)
                      self.shape_cspc_Buffer = (self.dataOutObj.nPairs,
-                                               self.processingHeaderObj.numHeights,
+                                               self.processingHeaderObj.nHeights,
                                                self.processingHeaderObj.profilesPerBlock)
-                     self.shape_dc_Buffer = (self.systemHeaderObj.numChannels,
-                                             self.processingHeaderObj.numHeights)
+                     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.dataType )
+                         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.dataType )
+                     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

schainpy2/IO/VoltageIO.py +480 -489

This diff has been collapsed as it changes many lines, (969 lines changed) Show them Hide them
			@@ -1,490 +1,481
	1		'''
	2		Created on 23/01/2012
	3
	4		@author $Author: dsuarez $
	5		@version $Id: VoltageIO.py 110 2012-07-19 15:18:18Z dsuarez $
	6		'''
	7
	8		import os, sys
	9		import numpy
	10		import glob
	11		import fnmatch
	12		import time, datetime
	13
	14		path = os.path.split(os.getcwd())[0]
	15		sys.path.append(path)
	16
	17		from JROHeader import *
	18		from JRODataIO import JRODataReader
	19		from JRODataIO import JRODataWriter
	20
	21		from Data.Voltage import Voltage
	22
	23		class VoltageReader(JRODataReader):
	24		"""
	25		Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
	26		de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
	27		perfilesalturascanales) son almacenados en la variable "buffer".
	28
	29		perfiles * alturas * canales
	30
	31		Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
	32		RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
	33		cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
	34		datos desde el "buffer" cada vez que se ejecute el metodo "getData".
	35
	36		Example:
	37
	38		dpath = "/home/myuser/data"
	39
	40		startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
	41
	42		endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
	43
	44		readerObj = VoltageReader()
	45
	46		readerObj.setup(dpath, startTime, endTime)
	47
	48		while(True):
	49
	50		#to get one profile
	51		profile = readerObj.getData()
	52
	53		#print the profile
	54		print profile
	55
	56		#If you want to see all datablock
	57		print readerObj.datablock
	58
	59		if readerObj.flagNoMoreFiles:
	60		break
	61
	62		"""
	63		dataOutObj = None
	64
	65		datablock = None
	66
	67		ext = ".r"
	68
	69		optchar = "D"
	70
	71
	72		def __init__(self, dataOutObj=None):
	73		~~"""~~
	74		Inicializador de la clase VoltageReader para la lectura de datos de voltage.
	75
	76		Input:
	77		dataOutObj : Objeto de la clase Voltage. Este objeto sera utilizado para
	78		almacenar un perfil de datos cada vez que se haga un requerimiento
	79		(getData). El perfil sera obtenido a partir del buffer de datos,
	80		si el buffer esta vacio se hara un nuevo proceso de lectura de un
	81		bloque de datos.
	82		Si este parametro no es pasado se creara uno internamente.
	83
	84		Variables afectadas:
	85		self.dataOutObj
	86
	87		~~Return:~~
	88		~~None~~
	89		"""
	90
	91		self.~~datablock~~ = ~~None~~
	92
	93		self.~~utc~~ = 0
	94
	95		self.~~ext~~ = ".r"
	96
	97		self.optchar = "D"
	98
	99		self.~~basic~~HeaderObj = ~~Basic~~Header()
	100
	101		self.~~system~~HeaderObj = ~~System~~Header()
	102
	103		self.~~radarController~~HeaderObj = ~~RadarController~~Header()
	104
	105		self.processingHeaderObj = ProcessingHeader()
	106
	107		self.~~online~~ = 0
	108
	109		self.fp = None
	110
	111		self.~~idFil~~e = None
	112
	113		self.~~dtype~~ = None
	114
	115		self.file~~SizeByHeader~~ = ~~None~~
	116
	117		self.filename~~List~~ = []
	118
	119		self.file~~nam~~e = None
	120
	121		self.fileSize = ~~None~~
	122
	123		self.~~first~~HeaderSize = 0
	124
	125		self.~~basicHeaderSize~~ = 24
	126
	127		self.~~path~~List = []
	128
	129		self.filena~~meLi~~st = []
	130
	131		self.~~lastUTTime~~ = 0
	132
	133		self.~~maxTimeStep~~ = 30
	134
	135		self.~~flagNoMoreFile~~s = 0
	136
	137		self.~~set~~ = 0
	138
	139		self.p~~ath~~ = ~~None~~
	140
	141		self.profileIndex = 9999
	142
	143		self.~~delay~~ = 3 ~~#second~~s
	144
	145		self.nTries = 3 #quantity tries
	146
	147		self.nFiles = 3 #number of files for searching
	148
	149		self.~~nReadBlocks~~ = 0
	150
	151		self.flagIsNewFile = 1
	152
	153		self.~~ippSeconds~~ = 0
	154
	155		self.flag~~Time~~Block = 0
	156
	157		self.~~flagIsNewBlock~~ = 0
	158
	159		self.~~nTotalBlocks~~ = 0
	160
	161		self.blocksize = 0
	162
	163		def createObjByDefault(self):
	164
	165		dataObj = ~~Voltage~~()
	166
	167		return dataObj
	168
	169		def __hasNotDataInBuffer(self):
	170		if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
	171		return 1
	172		return 0
	173
	174
	175		def getBlockDimension(self):
	176		~~"""~~
	177		Obtiene la cantidad de puntos a leer por cada bloque de datos
	178
	179		Affected:
	180		self.blocksize
	181
	182		~~Return:~~
	183		None
	184		"""
	185		pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
	186		self.blocksize = pts2read
	187
	188
	189		def readBlock(self):
	190		"""
	191		readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
	192		(self.fp) y actualiza todos los parametros relacionados al bloque de datos
	193		(metadata + data). La data leida es almacenada en el buffer y el contador del buffer
	194		es seteado a 0
	195
	196		Inputs:
	197		None
	198
	199		~~Return:~~
	200		None
	201
	202		Affected:
	203		self.~~pro~~file~~Index~~
	204		self.~~datab~~lock
	205		self.~~flagIsNewFile~~
	206		self.flagIsNewBlock
	207		self.nTotalBlocks
	208
	209		Exceptions:
	210		Si un bloque leido no es un bloque valido
	211		"""
	212
	213		junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
	214
	215		try:
	216		junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
	217		except:
	218		print "The read block (%3d) has not enough data" %self.nReadBlocks
	219		return 0
	220
	221		junk = numpy.transpose(junk, (2,0,1))
	222		self.datablock = junk['real'] + junk['imag']*1j
	223
	224		self.~~pro~~file~~Index~~ = 0
	225
	226		self.flagIsNewFile = 0
	227		self.~~flagIsNewBlock~~ = 1
	228
	229		self.nTotalBlocks += 1
	230		self.nReadBlocks += 1
	231
	232		return 1
	233
	234
	235		def getData(self):
	236		"""
	237		getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
	238		con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
	239		lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
	240
	241		Ademas incrementa el contador del buffer en 1.
	242
	243		Return:
	244		data : retorna un perfil de voltages (alturas * canales) copiados desde el
	245		buffer. Si no hay mas archivos a leer retorna None.
	246
	247		Variables afectadas:
	248		~~self.dataOutObj~~
	249		self.profileIndex
	250
	251		Affected:
	252		self.~~dataOutObj~~
	253		self.~~profileIndex~~
	254		self.flagTimeBlock
	255		self.flagIsNewBlock
	256		~~"""~~
	257		if self.flagNoMoreFiles: return 0
	258
	259		self.flagTimeBlock = 0
	260		self.flagIsNewBlock = 0
	261
	262		if self.__hasNotDataInBuffer():
	263
	264		if not( self.readNextBlock() ):
	265		return 0
	266
	267		# self.updateDataHeader()
	268
	269		if self.flagNoMoreFiles == 1:
	270		print 'Process finished'
	271		return 0
	272
	273		#data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
	274
	275		if self.datablock == None:
	276		self.dataOutObj.flagNoData = True
	277		return 0
	278
	279		self.dataOutObj.d~~ata~~ = self.d~~atablock[:,self~~.~~profileIndex,:]~~
	280
	281		self.dataOutObj.~~dtype~~ = self.d~~typ~~e
	282
	283		self.dataOutObj.n~~Channel~~s = self.~~system~~HeaderObj.n~~Channel~~s
	284
	285		self.dataOutObj.n~~Height~~s = self.processingHeaderObj.~~nHeights~~
	286
	287		self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
	288
	289		xf = self.processingHeaderObj.~~first~~Height + ~~self~~.~~processingHeaderObj~~.~~nHeights~~*~~self~~.~~processingHeaderObj~~.~~deltaHeight~~
	290
	291		self.dataOutObj.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
	292
	293		self.dataOutObj.channelList = range(self.systemHeaderObj.nChannels)
	294
	295		self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
	296
	297		self.dataOutObj.flagNoData = True
	298
	299		self.dataOutObj.flagTimeBlock = self.flagTimeBlock
	300
	301		self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc + self.profileIndex * self.ippSeconds
	302
	303		self.dataOutObj.~~nCohInt~~ = self.~~processing~~HeaderObj.~~nCohInt~~
	304
	305		self.profileIndex += 1
	306
	307		self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
	308
	309		self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
	310
	311		return 1
	312
	313
	314		class VoltageWriter(JRODataWriter):
	315		"""
	316		Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
	317		de los datos siempre se realiza por bloques.
	318		"""
	319		__configHeaderFile = 'wrSetHeadet.txt'
	320
	321		dataOutObj = None
	322
	323		ext = ".r"
	324
	325		optchar = "D"
	326
	327		datablock = None
	328
	329		profileIndex = 0
	330
	331		shapeBuffer = None
	332
	333
	334		~~def~~ ~~__init__~~(~~self~~, dataOutObj=None):
	335		"""
	336		Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
	337
	338		Affected:
	339		self.dataOutObj
	340
	341		Return: None
	342		"""
	343		if dataOutObj == None:
	344		dataOutObj = Voltage()
	345
	346		if not( isinstance(dataOutObj, Voltage) ):
	347		raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object"
	348
	349		self.dataOutObj = dataOutObj
	350
	351
	352		def hasAllDataInBuffer(self):
	353		if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
	354		return 1
	355		return 0
	356
	357
	358		def setBlockDimension(self):
	359		~~"""~~
	360		Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
	361
	362		Affected:
	363		self.shape_spc_Buffer
	364		self.shape_cspc_Buffer
	365		self.shape_dc_Buffer
	366
	367		Return: None
	368		"""
	369		self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
	370		self.processingHeaderObj.nHeights,
	371		self.systemHeaderObj.nChannels )
	372
	373		self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
	374		self.processingHeaderObj.profilesPerBlock,
	375		self.processingHeaderObj.nHeights),
	376		dtype=numpy.dtype('complex'))
	377
	378
	379		def writeBlock(self):
	380		~~"""~~
	381		Escribe el buffer en el file designado
	382
	383		Affected:
	384		self.profileIndex
	385		self.flagIsNewFile
	386		self.flagIsNewBlock
	387		self.nTotalBlocks
	388		self.blockIndex
	389
	390		Return: None
	391		~~"""~~
	392		data = numpy.zeros( self.shapeBuffer, self.dtype )
	393
	394		junk = numpy.transpose(self.datablock, (1,2,0))
	395
	396		data['real'] = junk.real
	397		data['imag'] = junk.imag
	398
	399		data = data.reshape( (-1) )
	400
	401		data.tofile( self.fp )
	402
	403		self.datablock.fill(0)
	404
	405		self.profileIndex = 0
	406		self.flagIsNewFile = 0
	407		self.flagIsNewBlock = 1
	408
	409		~~self~~.~~blockIndex~~ += 1
	410		self.nTotalBlocks += 1
	411
	412		def putData(self):
	413		"""
	414		Setea un bloque de datos y luego los escribe en un file
	415
	416		~~Affected:~~
	417		self.flagIsNewBlock
	418		~~self.profileIndex~~
	419
	420		Return:
	421		0 : Si no hay data o no hay mas files que puedan escribirse
	422		1 : Si se escribio la data de un bloque en un file
	423		"""
	424		self.flagIsNewBlock = 0
	425
	426		if self.dataOutObj.flagNoData:
	427		return 0
	428
	429		if self.dataOutObj.flagTimeBlock:
	430
	431		self.datablock.fill(0)
	432		self.~~profileIndex~~ = 0
	433		self.~~setNextFile~~()
	434
	435		self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
	436
	437		self.profileIndex += 1
	438
	439		if self.hasAllDataInBuffer():
	440		#if self.flagIsNewFile:
	441		~~self~~.getDataHeader()
	442		self.writeNextBlock()
	443
	444		if self.flagNoMoreFiles:
	445		#print 'Process finished'
	446		return 0
	447
	448		return 1
	449
	450		def getDataHeader(self):
	451
	452		"""
	453		Obtiene una copia del First Header
	454
	455		Affected:
	456		self.systemHeaderObj
	457		self.radarControllerHeaderObj
	458		self.dtype
	459
	460		Return:
	461		None
	462		"""
	463
	464		# CALCULAR PARAMETROS
	465
	466		self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
	467		self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
	468
	469		self.~~basic~~HeaderObj.size = ~~self~~.~~basicHeaderSize~~
	470		self.~~basic~~HeaderObj.~~version~~ = self.~~versionFil~~e
	471		self.~~basic~~HeaderObj.~~dataBlock~~ = ~~self~~.~~nTotalBlocks~~
	472		self.basicHeaderObj.utc = self.dataOutObj.dataUtcTime
	473		self.~~basic~~HeaderObj.~~miliSecond~~ = 0
	474		self.~~basic~~HeaderObj.~~timeZone~~ = 0
	475		self.~~basic~~HeaderObj.~~dstFlag~~ = 0
	476		self.~~basic~~HeaderObj.~~errorCou~~nt = 0
	477
	478		self.processingHeaderObj.~~size~~ = 0
	479		self.processingHeaderObj.dtype = self.dataOutObj.dtype
	480		self.processingHeaderObj.blockSize = 0
	481		self.processingHeaderObj.profilesPerBlock = 0
	482		self.processingHeaderObj.dataBlocksPerFile = 0
	483		self.processingHeaderObj.numWindows = 0
	484		self.processingHeaderObj.processFlags = 0
	485		self.processingHeaderObj.coherentInt = 0
	486		self.processingHeaderObj.incoherentInt = 0
	487		self.processingHeaderObj.totalSpectra = 0
	488
	489		self.dtype = self.dataOutObj.dtype
		1	'''
		2	Created on 23/01/2012
		3
		4	@author $Author: dsuarez $
		5	@version $Id: VoltageIO.py 110 2012-07-19 15:18:18Z dsuarez $
		6	'''
		7
		8	import os, sys
		9	import numpy
		10	import glob
		11	import fnmatch
		12	import time, datetime
		13
		14	path = os.path.split(os.getcwd())[0]
		15	sys.path.append(path)
		16
		17	from JROHeader import *
		18	from JRODataIO import JRODataReader
		19	from JRODataIO import JRODataWriter
		20
		21	from Data.Voltage import Voltage
		22
		23	class VoltageReader(JRODataReader):
		24	"""
		25	Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
		26	de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
		27	perfilesalturascanales) son almacenados en la variable "buffer".
		28
		29	perfiles * alturas * canales
		30
		31	Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
		32	RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
		33	cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
		34	datos desde el "buffer" cada vez que se ejecute el metodo "getData".
		35
		36	Example:
		37
		38	dpath = "/home/myuser/data"
		39
		40	startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
		41
		42	endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
		43
		44	readerObj = VoltageReader()
		45
		46	readerObj.setup(dpath, startTime, endTime)
		47
		48	while(True):
		49
		50	#to get one profile
		51	profile = readerObj.getData()
		52
		53	#print the profile
		54	print profile
		55
		56	#If you want to see all datablock
		57	print readerObj.datablock
		58
		59	if readerObj.flagNoMoreFiles:
		60	break
		61
		62	"""
		63
		64	ext = ".r"
		65
		66	optchar = "D"
		67	dataOutObj = None
		68
		69
		70	def __init__(self, dataOutObj=None):
		71	"""
		72	Inicializador de la clase VoltageReader para la lectura de datos de voltage.
		73
		74	Input:
		75	dataOutObj : Objeto de la clase Voltage. Este objeto sera utilizado para
		76	almacenar un perfil de datos cada vez que se haga un requerimiento
		77	(getData). El perfil sera obtenido a partir del buffer de datos,
		78	si el buffer esta vacio se hara un nuevo proceso de lectura de un
		79	bloque de datos.
		80	Si este parametro no es pasado se creara uno internamente.
		81
		82	Variables afectadas:
		83	self.dataOutObj
		84
		85	Return:
		86	None
		87	"""
		88
		89	self.datablock = None
		90
		91	self.utc = 0
		92
		93	self.ext = ".r"
		94
		95	self.optchar = "D"
		96
		97	self.basicHeaderObj = BasicHeader()
		98
		99	self.systemHeaderObj = SystemHeader()
		100
		101	self.radarControllerHeaderObj = RadarControllerHeader()
		102
		103	self.processingHeaderObj = ProcessingHeader()
		104
		105	self.online = 0
		106
		107	self.fp = None
		108
		109	self.idFile = None
		110
		111	self.dtype = None
		112
		113	self.fileSizeByHeader = None
		114
		115	self.filenameList = []
		116
		117	self.filename = None
		118
		119	self.fileSize = None
		120
		121	self.firstHeaderSize = 0
		122
		123	self.basicHeaderSize = 24
		124
		125	self.pathList = []
		126
		127	self.filenameList = []
		128
		129	self.lastUTTime = 0
		130
		131	self.maxTimeStep = 30
		132
		133	self.flagNoMoreFiles = 0
		134
		135	self.set = 0
		136
		137	self.path = None
		138
		139	self.profileIndex = 9999
		140
		141	self.delay = 3 #seconds
		142
		143	self.nTries = 3 #quantity tries
		144
		145	self.nFiles = 3 #number of files for searching
		146
		147	self.nReadBlocks = 0
		148
		149	self.flagIsNewFile = 1
		150
		151	self.ippSeconds = 0
		152
		153	self.flagTimeBlock = 0
		154
		155	self.flagIsNewBlock = 0
		156
		157	self.nTotalBlocks = 0
		158
		159	self.blocksize = 0
		160
		161	def createObjByDefault(self):
		162
		163	dataObj = Voltage()
		164
		165	return dataObj
		166
		167	def __hasNotDataInBuffer(self):
		168	if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
		169	return 1
		170	return 0
		171
		172
		173	def getBlockDimension(self):
		174	"""
		175	Obtiene la cantidad de puntos a leer por cada bloque de datos
		176
		177	Affected:
		178	self.blocksize
		179
		180	Return:
		181	None
		182	"""
		183	pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
		184	self.blocksize = pts2read
		185
		186
		187	def readBlock(self):
		188	"""
		189	readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
		190	(self.fp) y actualiza todos los parametros relacionados al bloque de datos
		191	(metadata + data). La data leida es almacenada en el buffer y el contador del buffer
		192	es seteado a 0
		193
		194	Inputs:
		195	None
		196
		197	Return:
		198	None
		199
		200	Affected:
		201	self.profileIndex
		202	self.datablock
		203	self.flagIsNewFile
		204	self.flagIsNewBlock
		205	self.nTotalBlocks
		206
		207	Exceptions:
		208	Si un bloque leido no es un bloque valido
		209	"""
		210
		211	junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
		212
		213	try:
		214	junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
		215	except:
		216	print "The read block (%3d) has not enough data" %self.nReadBlocks
		217	return 0
		218
		219	junk = numpy.transpose(junk, (2,0,1))
		220	self.datablock = junk['real'] + junk['imag']*1j
		221
		222	self.profileIndex = 0
		223
		224	self.flagIsNewFile = 0
		225	self.flagIsNewBlock = 1
		226
		227	self.nTotalBlocks += 1
		228	self.nReadBlocks += 1
		229
		230	return 1
		231
		232
		233	def getData(self):
		234	"""
		235	getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
		236	con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
		237	lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
		238
		239	Ademas incrementa el contador del buffer en 1.
		240
		241	Return:
		242	data : retorna un perfil de voltages (alturas * canales) copiados desde el
		243	buffer. Si no hay mas archivos a leer retorna None.
		244
		245	Variables afectadas:
		246	self.dataOutObj
		247	self.profileIndex
		248
		249	Affected:
		250	self.dataOutObj
		251	self.profileIndex
		252	self.flagTimeBlock
		253	self.flagIsNewBlock
		254	"""
		255	if self.flagNoMoreFiles: return 0
		256
		257	self.flagTimeBlock = 0
		258	self.flagIsNewBlock = 0
		259
		260	if self.__hasNotDataInBuffer():
		261
		262	if not( self.readNextBlock() ):
		263	return 0
		264
		265	# self.updateDataHeader()
		266
		267	if self.flagNoMoreFiles == 1:
		268	print 'Process finished'
		269	return 0
		270
		271	#data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
		272
		273	if self.datablock == None:
		274	self.dataOutObj.flagNoData = True
		275	return 0
		276
		277	self.dataOutObj.data = self.datablock[:,self.profileIndex,:]
		278
		279	self.dataOutObj.dtype = self.dtype
		280
		281	self.dataOutObj.nChannels = self.systemHeaderObj.nChannels
		282
		283	self.dataOutObj.nHeights = self.processingHeaderObj.nHeights
		284
		285	self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
		286
		287	xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
		288
		289	self.dataOutObj.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
		290
		291	self.dataOutObj.channelList = range(self.systemHeaderObj.nChannels)
		292
		293	self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
		294
		295	self.dataOutObj.flagTimeBlock = self.flagTimeBlock
		296
		297	self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc + self.profileIndex * self.ippSeconds
		298
		299	self.dataOutObj.nCohInt = self.processingHeaderObj.nCohInt
		300
		301	self.profileIndex += 1
		302
		303	self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
		304
		305	self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
		306
		307	self.dataOutObj.flagNoData = False
		308
		309	return 1
		310
		311
		312	class VoltageWriter(JRODataWriter):
		313	"""
		314	Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
		315	de los datos siempre se realiza por bloques.
		316	"""
		317
		318	ext = ".r"
		319
		320	optchar = "D"
		321
		322	shapeBuffer = None
		323
		324
		325	def __init__(self, dataOutObj=None):
		326	"""
		327	Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
		328
		329	Affected:
		330	self.dataOutObj
		331
		332	Return: None
		333	"""
		334	if dataOutObj == None:
		335	dataOutObj = Voltage()
		336
		337	if not( isinstance(dataOutObj, Voltage) ):
		338	raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object"
		339
		340	self.dataOutObj = dataOutObj
		341
		342
		343	def hasAllDataInBuffer(self):
		344	if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
		345	return 1
		346	return 0
		347
		348
		349	def setBlockDimension(self):
		350	"""
		351	Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
		352
		353	Affected:
		354	self.shape_spc_Buffer
		355	self.shape_cspc_Buffer
		356	self.shape_dc_Buffer
		357
		358	Return: None
		359	"""
		360	self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
		361	self.processingHeaderObj.nHeights,
		362	self.systemHeaderObj.nChannels )
		363
		364	self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
		365	self.processingHeaderObj.profilesPerBlock,
		366	self.processingHeaderObj.nHeights),
		367	dtype=numpy.dtype('complex'))
		368
		369
		370	def writeBlock(self):
		371	"""
		372	Escribe el buffer en el file designado
		373
		374	Affected:
		375	self.profileIndex
		376	self.flagIsNewFile
		377	self.flagIsNewBlock
		378	self.nTotalBlocks
		379	self.blockIndex
		380
		381	Return: None
		382	"""
		383	data = numpy.zeros( self.shapeBuffer, self.dtype )
		384
		385	junk = numpy.transpose(self.datablock, (1,2,0))
		386
		387	data['real'] = junk.real
		388	data['imag'] = junk.imag
		389
		390	data = data.reshape( (-1) )
		391
		392	data.tofile( self.fp )
		393
		394	self.datablock.fill(0)
		395
		396	self.profileIndex = 0
		397	self.flagIsNewFile = 0
		398	self.flagIsNewBlock = 1
		399
		400	self.blockIndex += 1
		401	self.nTotalBlocks += 1
		402
		403	def putData(self):
		404	"""
		405	Setea un bloque de datos y luego los escribe en un file
		406
		407	Affected:
		408	self.flagIsNewBlock
		409	self.profileIndex
		410
		411	Return:
		412	0 : Si no hay data o no hay mas files que puedan escribirse
		413	1 : Si se escribio la data de un bloque en un file
		414	"""
		415	self.flagIsNewBlock = 0
		416
		417	if self.dataOutObj.flagNoData:
		418	return 0
		419
		420	if self.dataOutObj.flagTimeBlock:
		421
		422	self.datablock.fill(0)
		423	self.profileIndex = 0
		424	self.setNextFile()
		425
		426	self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
		427
		428	self.profileIndex += 1
		429
		430	if self.hasAllDataInBuffer():
		431	#if self.flagIsNewFile:
		432	self.getDataHeader()
		433	self.writeNextBlock()
		434
		435	if self.flagNoMoreFiles:
		436	#print 'Process finished'
		437	return 0
		438
		439	return 1
		440
		441	def getDataHeader(self):
		442
		443	"""
		444	Obtiene una copia del First Header
		445
		446	Affected:
		447	self.systemHeaderObj
		448	self.radarControllerHeaderObj
		449	self.dtype
		450
		451	Return:
		452	None
		453	"""
		454
		455	# CALCULAR PARAMETROS
		456
		457	self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
		458	self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
		459
		460	self.basicHeaderObj.size = self.basicHeaderSize
		461	self.basicHeaderObj.version = self.versionFile
		462	self.basicHeaderObj.dataBlock = self.nTotalBlocks
		463	self.basicHeaderObj.utc = self.dataOutObj.dataUtcTime
		464	self.basicHeaderObj.miliSecond = 0
		465	self.basicHeaderObj.timeZone = 0
		466	self.basicHeaderObj.dstFlag = 0
		467	self.basicHeaderObj.errorCount = 0
		468
		469	self.processingHeaderObj.size = 0
		470	self.processingHeaderObj.dtype = self.dataOutObj.dtype
		471	self.processingHeaderObj.blockSize = 0
		472	self.processingHeaderObj.profilesPerBlock = 0
		473	self.processingHeaderObj.dataBlocksPerFile = 0
		474	self.processingHeaderObj.numWindows = 0
		475	self.processingHeaderObj.processFlags = 0
		476	self.processingHeaderObj.coherentInt = 0
		477	self.processingHeaderObj.incoherentInt = 0
		478	self.processingHeaderObj.totalSpectra = 0
		479
		480	self.dtype = self.dataOutObj.dtype
	490	481	No newline at end of file

schainpy2/Processing/VoltageProcessor.py +133 -133

		@@ -1,133 +1,133
1		import os
2		import sys
3		import numpy
4
5		path = os.path.split(os.getcwd())[0]
6		sys.path.append(path)
7
8		from Data.Voltage import Voltage
9
10
11		class VoltageProcessor:
12		dataInObj = None
13		dataOutObj = None
14		integratorObjIndex = None
15		writerObjIndex = None
16		integratorObjList = None
17		writerObjList = None
18
19		def __init__(self):
20		self.integratorObjIndex = None
21		self.writerObjIndex = None
22		self.integratorObjList = []
23		self.writerObjList = []
24
25		def setup(self,dataInObj=None,dataOutObj=None):
26		self.dataInObj = dataInObj
27
28		if self.dataOutObj == None:
29		dataOutObj = Voltage()
30
31		self.dataOutObj = dataOutObj
32
33		return self.dataOutObj
34
35		def init(self):
36		self.integratorObjIndex = 0
37		self.writerObjIndex = 0
38		# No necesita copiar en cada init() los atributos de dataInObj
39		# la copia deberia hacerse por cada nuevo bloque de datos
40
41		def addIntegrator(self,N,timeInterval):
42		objCohInt = CoherentIntegrator(N,timeInterval)
43		self.integratorObjList.append(objCohInt)
44
45		def addWriter(self):
46		pass
47
48		def integrator(self, N=None, timeInterval=None):
49		if self.dataOutObj.flagNoData:
50		return 0
51		if len(self.integratorObjList) <= self.integratorObjIndex:
52		self.addIntegrator(N,timeInterval)
53
54		myCohIntObj = self.integratorObjList[self.integratorObjIndex]
55		myCohIntObj.exe(data=self.dataOutObj.data,timeOfData=None)
56
57		pass
58
59		def writeData(self):
60		pass
61
62		class CoherentIntegrator:
63
64		integ_counter = None
65		data = None
66		navg = None
67		buffer = None
68		nCohInt = None
69
70		def __init__(self, N=None,timeInterval=None):
71
72		self.data = None
73		self.navg = None
74		self.buffer = None
75		self.timeOut = None
76		self.exitCondition = False
77		self.isReady = False
78		self.nCohInt = N
79		self.integ_counter = 0
80		if timeInterval!=None:
81		self.timeIntervalInSeconds = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
82
83		if ((timeInterval==None) and (N==None)):
84		raise ValueError, "N = None ; timeInterval = None"
85
86		if timeInterval == None:
87		self.timeFlag = False
88		else:
89		self.timeFlag = True
90
91		def exe(self, data, timeOfData):
92
93		if self.timeFlag:
94		if self.timeOut == None:
95		self.timeOut = timeOfData + self.timeIntervalInSeconds
96
97		if timeOfData < self.timeOut:
98		if self.buffer == None:
99		self.buffer = data
100		else:
101		self.buffer = self.buffer + data
102		self.integ_counter += 1
103		else:
104		self.exitCondition = True
105
106		else:
107		if self.integ_counter < self.nCohInt:
108		if self.buffer == None:
109		self.buffer = data
110		else:
111		self.buffer = self.buffer + data
112
113		self.integ_counter += 1
114
115		if self.integ_counter == self.nCohInt:
116		self.exitCondition = True
117
118		if self.exitCondition:
119		self.data = self.buffer
120		self.navg = self.integ_counter
121		self.isReady = True
122		self.buffer = None
123		self.timeOut = None
124		self.integ_counter = 0
125		self.exitCondition = False
126
127		if self.timeFlag:
128		self.buffer = data
129		self.timeOut = timeOfData + self.timeIntervalInSeconds
130		else:
131		self.isReady = False
132
133
	1	import os
	2	import sys
	3	import numpy
	4
	5	path = os.path.split(os.getcwd())[0]
	6	sys.path.append(path)
	7
	8	from Data.Voltage import Voltage
	9
	10
	11	class VoltageProcessor:
	12	dataInObj = None
	13	dataOutObj = None
	14	integratorObjIndex = None
	15	writerObjIndex = None
	16	integratorObjList = None
	17	writerObjList = None
	18
	19	def __init__(self):
	20	self.integratorObjIndex = None
	21	self.writerObjIndex = None
	22	self.integratorObjList = []
	23	self.writerObjList = []
	24
	25	def setup(self,dataInObj=None,dataOutObj=None):
	26	self.dataInObj = dataInObj
	27
	28	if self.dataOutObj == None:
	29	dataOutObj = Voltage()
	30
	31	self.dataOutObj = dataOutObj
	32
	33	return self.dataOutObj
	34
	35	def init(self):
	36	self.integratorObjIndex = 0
	37	self.writerObjIndex = 0
	38	# No necesita copiar en cada init() los atributos de dataInObj
	39	# la copia deberia hacerse por cada nuevo bloque de datos
	40
	41	def addIntegrator(self,N,timeInterval):
	42	objCohInt = CoherentIntegrator(N,timeInterval)
	43	self.integratorObjList.append(objCohInt)
	44
	45	def addWriter(self):
	46	pass
	47
	48	def integrator(self, N=None, timeInterval=None):
	49	if self.dataOutObj.flagNoData:
	50	return 0
	51	if len(self.integratorObjList) <= self.integratorObjIndex:
	52	self.addIntegrator(N,timeInterval)
	53
	54	myCohIntObj = self.integratorObjList[self.integratorObjIndex]
	55	myCohIntObj.exe(data=self.dataOutObj.data,timeOfData=None)
	56
	57	pass
	58
	59	def writeData(self):
	60	pass
	61
	62	class CoherentIntegrator:
	63
	64	integ_counter = None
	65	data = None
	66	navg = None
	67	buffer = None
	68	nCohInt = None
	69
	70	def __init__(self, N=None,timeInterval=None):
	71
	72	self.data = None
	73	self.navg = None
	74	self.buffer = None
	75	self.timeOut = None
	76	self.exitCondition = False
	77	self.isReady = False
	78	self.nCohInt = N
	79	self.integ_counter = 0
	80	if timeInterval!=None:
	81	self.timeIntervalInSeconds = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
	82
	83	if ((timeInterval==None) and (N==None)):
	84	raise ValueError, "N = None ; timeInterval = None"
	85
	86	if timeInterval == None:
	87	self.timeFlag = False
	88	else:
	89	self.timeFlag = True
	90
	91	def exe(self, data, timeOfData):
	92
	93	if self.timeFlag:
	94	if self.timeOut == None:
	95	self.timeOut = timeOfData + self.timeIntervalInSeconds
	96
	97	if timeOfData < self.timeOut:
	98	if self.buffer == None:
	99	self.buffer = data
	100	else:
	101	self.buffer = self.buffer + data
	102	self.integ_counter += 1
	103	else:
	104	self.exitCondition = True
	105
	106	else:
	107	if self.integ_counter < self.nCohInt:
	108	if self.buffer == None:
	109	self.buffer = data
	110	else:
	111	self.buffer = self.buffer + data
	112
	113	self.integ_counter += 1
	114
	115	if self.integ_counter == self.nCohInt:
	116	self.exitCondition = True
	117
	118	if self.exitCondition:
	119	self.data = self.buffer
	120	self.navg = self.integ_counter
	121	self.isReady = True
	122	self.buffer = None
	123	self.timeOut = None
	124	self.integ_counter = 0
	125	self.exitCondition = False
	126
	127	if self.timeFlag:
	128	self.buffer = data
	129	self.timeOut = timeOfData + self.timeIntervalInSeconds
	130	else:
	131	self.isReady = False
	132
	133

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