schain Commit - r174:101b91d0ba48 · Jicamarca Repository

-Optimizacion de los modulos de Signal Chain....

Miguel Valdez -

r174:101b91d0ba48

parent child

Context file:

r174:101b91d0ba48

Collapse all files

schainpy/Controller/controller.py created 644 +370 0

@@ -0,0 +1,370
	1	'''
	2	Created on September , 2012
	3	@author:
	4	'''
	5	from xml.etree.ElementTree import Element, SubElement, ElementTree
	6	from element import prettify
	7	from xml.etree import ElementTree as ET
	8	import sys
	9
	10
	11	#def save(a, b):
	12	#
	13	# nameP = "Alexnder"
	14	# descripcion = self.projectWindow.Text()
	15	# id = 1
	16	# x = self.data.projectWindow.cmbbox.value()
	17	#
	18	# projectObj = Project(id, name, description)
	19	#
	20	# projectObj.setup(id, name, description)
	21
	22	class Project():
	23
	24	id = None
	25	name = None
	26	description = None
	27	readBranchObjList = None
	28	procBranchObjList = None
	29
	30	def __init__(self):
	31
	32	# self.id = id
	33	# self.name = name
	34	# self.description = description
	35
	36	self.readBranchObjList = []
	37	self.procBranchObjList = []
	38
	39	def setParms(self, id, name, description):
	40
	41	self.id = id
	42	self.name = name
	43	self.description = description
	44
	45	def addReadBranch(self, dpath, dataformat, readMode, startDate='', endDate='', startTime='', endTime=''):
	46
	47	id = len(self.readBranchObjList) + 1
	48
	49	readBranchObj = ReadBranch(id, dpath, dataformat, readMode, startDate, endDate, startTime, endTime)
	50
	51	self.readBranchObjList.append(readBranchObj)
	52
	53	return readBranchObj
	54
	55	def addProcBranch(self, name):
	56
	57	id = len(self.procBranchObjList) + 1
	58
	59	procBranchObj = ProcBranch(id, name)
	60
	61	self.procBranchObjList.append(procBranchObj)
	62
	63	return procBranchObj
	64
	65	def makeXml(self):
	66
	67	projectElement = Element('Project')
	68	projectElement.set('id', str(self.id))
	69	projectElement.set('name', self.name)
	70	#projectElement.set('description', self.description)
	71
	72	se = SubElement(projectElement, 'description',description=self.description)#ESTO ES LO ULTIMO QUE SE TRABAJO
	73	#se.text = self.description #ULTIMA MODIFICACION PARA SACAR UN SUB ELEMENT
	74
	75	for readBranchObj in self.readBranchObjList:
	76	readBranchObj.makeXml(projectElement)
	77
	78	for procBranchObj in self.procBranchObjList:
	79	procBranchObj.makeXml(projectElement)
	80
	81	self.projectElement = projectElement
	82
	83	def writeXml(self, filename):
	84
	85	self.makeXml()
	86	ElementTree(self.projectElement).write(filename, method='xml')
	87	print prettify(self.projectElement)
	88
	89	def readXml(self,workspace):
	90	print "Aqui estoy leyendo"
	91	tree=ET.parse(workspace)
	92	root=tree.getroot()
	93	self.project=root.tag
	94	self.idProyect= root.attrib.get('id')
	95	self.nameProyect= root.attrib.get('name')
	96	for description in root.findall('description'):
	97	description = description.get('description')
	98
	99	self.description= description
	100
	101	for readBranch in root.findall('readBranch'):
	102	id = readBranch.get('id')
	103	self.idrb=id
	104
	105	for procBranch in root.findall('procBranch'):
	106	id = readBranch.get('id')
	107	name = readBranch.get('name')
	108	self.idpb=id
	109	self.nameBranch=name
	110	#
	111	#
	112	print self.project
	113	print self.idProyect
	114	print self.nameProyect
	115	print self.description
	116	print self.idrb
	117	print self.idpb
	118	print self.nameBranch
	119	#
	120	####ESTO DEL MEDIO ESTABA COMENTADO
	121	# print root.tag , root.attrib
	122	#
	123	# print root.attrib.get('id')
	124	# print root.attrib.get('name')
	125
	126
	127	# for description in root.findall('description'):
	128	# description = root.find('description').text
	129	# name = root.get('name')
	130	# print name, description
	131
	132	# description=root.find('description').text
	133	# print description
	134	# ESTO FUNCIONABA HACIA ABAJO
	135	print "Otra forma "
	136	root=tree.getroot()
	137	print root.tag , root.attrib
	138	for child in root:
	139	print child.tag ,child.attrib
	140	for child in child:
	141	print child.tag ,child.attrib
	142	for child in child:
	143	print child.tag ,child.attrib
	144	for child in child:
	145	print child.tag ,child.attrib
	146	#
	147	class ReadBranch():
	148
	149	id = None
	150	dpath = None
	151	dataformat = None
	152	readMode = None
	153	startDate = None
	154	endDate = None
	155	startTime = None
	156	endTime = None
	157
	158	def __init__(self, id, dpath, dataformat, readMode, startDate, endDate, startTime, endTime):
	159
	160	self.id = id
	161	self.dpath = dpath
	162	self.dataformat = dataformat
	163	self.readMode = readMode
	164	self.startDate = startDate
	165	self.endDate = endDate
	166	self.startTime = startTime
	167	self.endTime = endTime
	168
	169	def makeXml(self, projectElement):
	170
	171	readBranchElement = SubElement(projectElement, 'readBranch')
	172	readBranchElement.set('id', str(self.id))
	173
	174	# readBranchElement.set('dpath', self.dpath)
	175	# readBranchElement.set('dataformat', self.dataformat)
	176	# readBranchElement.set('startDate', self.startDate)
	177	# readBranchElement.set('endDate', self.endDate)
	178	# readBranchElement.set('startTime', self.startTime)
	179	# readBranchElement.set('endTime', self.endTime)
	180	# readBranchElement.set('readMode', str(self.readMode))
	181
	182	# se = SubElement(readBranchElement, 'dpath')#ESTO ES LO ULTIMO QUE SE TRABAJO
	183	# se.text = self.dpath
	184	#
	185	# se = SubElement(readBranchElement, 'dataformat')#ESTO ES LO ULTIMO QUE SE TRABAJO
	186	# se.text = self.dataformat
	187	#
	188	# se = SubElement(readBranchElement, 'startDate')#ESTO ES LO ULTIMO QUE SE TRABAJO
	189	# se.text = self.startDate
	190	#
	191	# se = SubElement(readBranchElement, 'endDate')#ESTO ES LO ULTIMO QUE SE TRABAJO
	192	# se.text = self.endDate
	193	#
	194	# se = SubElement(readBranchElement, 'startTime')#ESTO ES LO ULTIMO QUE SE TRABAJO
	195	# se.text = self.startTime
	196	#
	197	# se = SubElement(readBranchElement, 'endTime')#ESTO ES LO ULTIMO QUE SE TRABAJO
	198	# se.text = self.endTime
	199	#
	200	# se = SubElement(readBranchElement, 'readMode')#ESTO ES LO ULTIMO QUE SE TRABAJO
	201	# se.text = str(self.readMode)
	202
	203	##########################################################################
	204	se = SubElement(readBranchElement, 'parameter', name='dpath' , value=self.dpath)
	205	se = SubElement(readBranchElement, 'parameter', name='dataformat', value=self.dataformat)
	206	se = SubElement(readBranchElement, 'parameter', name='startDate' , value=self.startDate)
	207	se = SubElement(readBranchElement, 'parameter', name='endDate' , value=self.endDate)
	208	se = SubElement(readBranchElement, 'parameter', name='startTime' , value=self.startTime)
	209	se = SubElement(readBranchElement, 'parameter', name='endTime' , value=self.endTime)
	210	se = SubElement(readBranchElement, 'parameter', name='readMode' , value=str(self.readMode))
	211
	212
	213	class ProcBranch():
	214
	215	id = None
	216	name = None
	217
	218	upObjList = None
	219
	220	def __init__(self, id, name):
	221
	222	self.id = id
	223	self.name = name
	224
	225	self.upObjList = []
	226
	227	def addUP(self, name, type):
	228
	229	id = len(self.upObjList) + 1
	230
	231	upObj = UP(id, name, type)
	232
	233	self.upObjList.append(upObj)
	234
	235	return upObj
	236
	237	def makeXml(self, projectElement):
	238
	239	procBranchElement = SubElement(projectElement, 'procBranch')
	240	procBranchElement.set('id', str(self.id))
	241	procBranchElement.set('name', self.name)
	242
	243	for upObj in self.upObjList:
	244	upObj.makeXml(procBranchElement)
	245
	246	class UP():
	247
	248	id = None
	249	name = None
	250	type = None
	251
	252	opObjList = []
	253
	254	def __init__(self, id, name, type):
	255
	256	self.id = id
	257	self.name = name
	258	self.type = type
	259
	260	self.opObjList = []
	261
	262	def addOperation(self, name, priority):
	263
	264	id = len(self.opObjList) + 1
	265
	266	opObj = Operation(id, name, priority)
	267
	268	self.opObjList.append(opObj)
	269
	270	return opObj
	271
	272	def makeXml(self, procBranchElement):
	273
	274	upElement = SubElement(procBranchElement, 'UP')
	275	upElement.set('id', str(self.id))
	276	upElement.set('name', self.name)
	277	upElement.set('type', self.type)
	278
	279	for opObj in self.opObjList:
	280	opObj.makeXml(upElement)
	281
	282	class Operation():
	283
	284	id = 0
	285	name = None
	286	priority = None
	287	parmObjList = []
	288
	289	def __init__(self, id, name, priority):
	290
	291	self.id = id
	292	self.name = name
	293	self.priority = priority
	294
	295	self.parmObjList = []
	296
	297	def addParameter(self, name, value):
	298
	299	id = len(self.parmObjList) + 1
	300
	301	parmObj = Parameter(id, name, value)
	302
	303	self.parmObjList.append(parmObj)
	304
	305	return parmObj
	306
	307	def makeXml(self, upElement):
	308
	309	opElement = SubElement(upElement, 'Operation')
	310	opElement.set('id', str(self.id))
	311	opElement.set('name', self.name)
	312	opElement.set('priority', str(self.priority))
	313
	314	for parmObj in self.parmObjList:
	315	parmObj.makeXml(opElement)
	316
	317	class Parameter():
	318
	319	id = None
	320	name = None
	321	value = None
	322
	323	def __init__(self, id, name, value):
	324
	325	self.id = id
	326	self.name = name
	327	self.value = value
	328
	329	def makeXml(self, opElement):
	330
	331	parmElement = SubElement(opElement, 'Parameter')
	332	parmElement.set('name', self.name)
	333	parmElement.set('value', self.value)
	334
	335	# se = SubElement(parmElement, 'value')#ESTO ES LO ULTIMO QUE SE TRABAJO
	336	# se.text = self.value
	337
	338	if __name__ == '__main__':
	339
	340	desc = "Este es un test"
	341	filename = "test.xml"
	342
	343	workspace=str("C:\\Users\\alex\\workspace\\GUIV2.0\\test.xml")
	344
	345	projectObj = Project()
	346
	347	projectObj.setParms(id = '11', name='test01', description=desc)
	348
	349	readBranchObj = projectObj.addReadBranch(dpath='mydata', dataformat='rawdata', readMode=0, startDate='1', endDate='3', startTime='4', endTime='5')
	350
	351	procBranchObj = projectObj.addProcBranch(name='Branch1')
	352
	353	procBranchObj1 = projectObj.addProcBranch(name='Branch2')
	354	upObj1 = procBranchObj.addUP(name='UP1', type='Voltage')
	355	upObj2 = procBranchObj.addUP(name='UP2', type='Voltage')
	356
	357	opObj11 = upObj1.addOperation(name='removeDC', priority=1)
	358	opObj11.addParameter(name='type', value='1')
	359
	360
	361	opObj12 = upObj1.addOperation(name='decodification', priority=2)
	362	opObj12.addParameter(name='ncode', value='2')
	363	opObj12.addParameter(name='nbauds', value='8')
	364	opObj12.addParameter(name='code1', value='001110011')
	365	opObj12.addParameter(name='code2', value='001110011')
	366
	367	projectObj.writeXml(filename)
	368
	369	projectObj.readXml(workspace)
	370	No newline at end of file

schainpy/Controller/controller1.py created 644 +358 0

@@ -0,0 +1,358
	1	'''
	2	Created on September , 2012
	3	@author:
	4	'''
	5	from xml.etree.ElementTree import Element, SubElement, ElementTree
	6	from element import prettify
	7	from xml.etree import ElementTree as ET
	8	import sys
	9
	10	class Project():
	11
	12	id = None
	13	name = None
	14	description = None
	15	readBranchObjList = None
	16	procBranchObjList = None
	17
	18	def __init__(self):
	19
	20	# self.id = id
	21	# self.name = name
	22	# self.description = description
	23
	24	self.readBranchObjList = []
	25	self.procBranchObjList = []
	26
	27	def setParms(self, id, name, description):
	28
	29	self.id = id
	30	self.name = name
	31	self.description = description
	32
	33	def addReadBranch(self,id, dpath, dataformat, opMode,readMode, startDate='', endDate='', startTime='', endTime=''):
	34
	35	#id = len(self.readBranchObjList) + 1
	36
	37	readBranchObj = ReadBranch(id, dpath, dataformat, opMode , readMode, startDate, endDate, startTime, endTime)
	38
	39	self.readBranchObjList.append(readBranchObj)
	40
	41	return readBranchObj
	42
	43	def addProcBranch(self, id,name):
	44
	45	# id = len(self.procBranchObjList) + 1
	46
	47	procBranchObj = ProcBranch(id, name)
	48
	49	self.procBranchObjList.append(procBranchObj)
	50
	51	return procBranchObj
	52
	53	def makeXml(self):
	54
	55	projectElement = Element('Project')
	56	projectElement.set('id', str(self.id))
	57	projectElement.set('name', self.name)
	58	#projectElement.set('description', self.description)
	59
	60	se = SubElement(projectElement, 'description',description=self.description)#ESTO ES LO ULTIMO QUE SE TRABAJO
	61	#se.text = self.description #ULTIMA MODIFICACION PARA SACAR UN SUB ELEMENT
	62
	63	for readBranchObj in self.readBranchObjList:
	64	readBranchObj.makeXml(projectElement)
	65
	66	for branchObj in self.procBranchObjList:
	67	branchObj.makeXml(projectElement)
	68
	69	self.projectElement = projectElement
	70
	71	def writeXml(self, filename):
	72
	73	self.makeXml()
	74	ElementTree(self.projectElement).write(filename, method='xml')
	75	#print prettify(self.projectElement)
	76
	77	class ReadBranch():
	78
	79	id = None
	80	dpath = None
	81	dataformat = None
	82	opMode =None
	83	readMode = None
	84	startDate = None
	85	endDate = None
	86	startTime = None
	87	endTime = None
	88
	89	def __init__(self, id, dpath, dataformat,opMode, readMode, startDate, endDate, startTime, endTime):
	90
	91	self.id = id
	92	self.dpath = dpath
	93	self.dataformat = dataformat
	94	self.opMode = opMode
	95	self.readMode = readMode
	96	self.startDate = startDate
	97	self.endDate = endDate
	98	self.startTime = startTime
	99	self.endTime = endTime
	100
	101	def makeXml(self, projectElement):
	102
	103	readBranchElement = SubElement(projectElement, 'readBranch')
	104	readBranchElement.set('id', str(self.id))
	105
	106	##########################################################################
	107	se = SubElement(readBranchElement, 'parameter', name='dpath' , value=self.dpath)
	108	se = SubElement(readBranchElement, 'parameter', name='dataformat', value=self.dataformat)
	109	se = SubElement(readBranchElement, 'parameter', name='opMode' , value=self.opMode)
	110	se = SubElement(readBranchElement, 'parameter', name='startDate' , value=self.startDate)
	111	se = SubElement(readBranchElement, 'parameter', name='endDate' , value=self.endDate)
	112	se = SubElement(readBranchElement, 'parameter', name='startTime' , value=self.startTime)
	113	se = SubElement(readBranchElement, 'parameter', name='endTime' , value=self.endTime)
	114	se = SubElement(readBranchElement, 'parameter', name='readMode' , value=str(self.readMode))
	115
	116	class ProcBranch():
	117
	118	id = None
	119	name = None
	120
	121	upObjList = None
	122	upsubObjList=None
	123
	124	def __init__(self, id, name):
	125
	126	self.id = id
	127	self.name = name
	128
	129	self.upObjList = []
	130	self.upsubObjList = []
	131
	132	def addUP(self,id, name, type):
	133
	134	#id = len(self.upObjList) + 1
	135
	136	upObj = UP(id, name, type)
	137
	138	self.upObjList.append(upObj)
	139
	140	return upObj
	141
	142	def addUPSUB(self,id, name, type):
	143
	144	# id = len(self.upsubObjList) + 1
	145
	146	upsubObj = UPSUB(id, name, type)
	147
	148	self.upsubObjList.append(upsubObj)
	149
	150	return upsubObj
	151
	152	def makeXml(self, projectElement):
	153
	154	procBranchElement = SubElement(projectElement, 'procBranch')
	155	procBranchElement.set('id', str(self.id))
	156	procBranchElement.set('name', self.name)
	157
	158	for upObj in self.upObjList:
	159	upObj.makeXml(procBranchElement)
	160
	161	for upsubObj in self.upsubObjList:
	162	upsubObj.makeXml(procBranchElement)
	163
	164	class UP():
	165
	166	id = None
	167	name = None
	168	type = None
	169	upsubObjList=None
	170	opObjList = None
	171
	172	def __init__(self, id, name, type):
	173
	174	self.id = id
	175	self.name = name
	176	self.type = type
	177	self.upsubObjList=[]
	178	self.up2subObjList=[]
	179	self.opObjList = []
	180
	181	def addOperation(self,id, name, priority):
	182
	183	#id = len(self.opObjList) + 1
	184
	185	opObj = Operation(id, name, priority)
	186
	187	self.opObjList.append(opObj)
	188
	189	return opObj
	190
	191	def addUPSUB(self,id, name, type):
	192
	193	# id = len(self.upsubObjList) + 1
	194
	195	upsubObj = UPSUB(id, name, type)
	196
	197	self.upsubObjList.append(upsubObj)
	198
	199	return upsubObj
	200
	201	def addUP2SUB(self,id, name, type):
	202
	203	# id = len(self.upsubObjList) + 1
	204
	205	up2subObj = UP2SUB(id, name, type)
	206
	207	self.up2subObjList.append(up2subObj)
	208
	209	return up2subObj
	210
	211	def makeXml(self, procBranchElement):
	212
	213	upElement = SubElement(procBranchElement, 'UP')
	214	upElement.set('id', str(self.id))
	215	upElement.set('name', self.name)
	216	upElement.set('type', self.type)
	217
	218	for opObj in self.opObjList:
	219	opObj.makeXml(upElement)
	220
	221	for upsubObj in self.upsubObjList:
	222	upsubObj.makeXml(upElement)
	223
	224	class UPSUB():
	225
	226	id = None
	227	name = None
	228	type = None
	229	opObjList = None
	230	up2subObjList=None
	231
	232
	233	def __init__(self, id, name, type):
	234
	235	self.id = id
	236	self.name = name
	237	self.type = type
	238	self.up2subObjList = []
	239	self.opObjList = []
	240
	241	def addOperation(self, name, priority):
	242
	243	id = len(self.opObjList) + 1
	244
	245	opObj = Operation(id, name, priority)
	246
	247	self.opObjList.append(opObj)
	248
	249	return opObj
	250
	251
	252	def addUP2SUB(self,id, name, type):
	253	#
	254	# id = len(self.opObjList) + 1
	255	up2subObj = UP2SUB(id, name, type)
	256
	257	self.up2subObjList.append(up2subObj)
	258
	259	return up2subObj
	260
	261	def makeXml(self, upElement):
	262
	263	upsubElement = SubElement(upElement, 'UPSUB')
	264	upsubElement.set('id', str(self.id))
	265	upsubElement.set('name', self.name)
	266	upsubElement.set('type', self.type)
	267
	268	for opObj in self.opObjList:
	269	opObj.makeXml(upsubElement)
	270
	271	for up2subObj in self.up2subObjList:
	272	up2subObj.makeXml(upsubElement)
	273
	274	class UP2SUB():
	275
	276	id = None
	277	name = None
	278	type = None
	279	opObjList = None
	280
	281	def __init__(self, id, name, type):
	282
	283	self.id = id
	284	self.name = name
	285	self.type = type
	286	self.opObjList = []
	287
	288	def addOperation(self, name, priority):
	289
	290	id = len(self.opObjList) + 1
	291
	292	opObj = Operation(id, name, priority)
	293
	294	self.opObjList.append(opObj)
	295
	296	return opObj
	297
	298	def makeXml(self,upsubElement):
	299	up2subElement = SubElement(upsubElement, 'UPD2SUB')
	300	up2subElement.set('id', str(self.id))
	301	up2subElement.set('name', self.name)
	302	up2subElement.set('type', self.type)
	303
	304	for opObj in self.opObjList:
	305	opObj.makeXml(up2subElement)
	306
	307	class Operation():
	308
	309	id = 0
	310	name = None
	311	priority = None
	312	parmObjList = []
	313
	314	def __init__(self, id, name, priority):
	315
	316	self.id = id
	317	self.name = name
	318	self.priority = priority
	319
	320	self.parmObjList = []
	321
	322	def addParameter(self, name, value):
	323
	324	id = len(self.parmObjList) + 1
	325
	326	parmObj = Parameter(id, name, value)
	327
	328	self.parmObjList.append(parmObj)
	329
	330	return parmObj
	331
	332	def makeXml(self, upElement):
	333
	334	opElement = SubElement(upElement, 'Operation')
	335	opElement.set('id', str(self.id))
	336	opElement.set('name', self.name)
	337	opElement.set('priority', str(self.priority))
	338
	339	for parmObj in self.parmObjList:
	340	parmObj.makeXml(opElement)
	341
	342	class Parameter():
	343
	344	id = None
	345	name = None
	346	value = None
	347
	348	def __init__(self, id, name, value):
	349
	350	self.id = id
	351	self.name = name
	352	self.value = value
	353
	354	def makeXml(self, opElement):
	355
	356	parmElement = SubElement(opElement, 'Parameter')
	357	parmElement.set('name', self.name)
	358	parmElement.set('value', self.value) No newline at end of file

schainpy/Model/JROData.py created 644 +241 0

@@ -0,0 +1,241
	1	'''
	2
	3	$Author: murco $
	4	$Id: JROData.py 173 2012-11-20 15:06:21Z murco $
	5	'''
	6
	7	import os, sys
	8	import copy
	9	import numpy
	10
	11	from JROHeaderIO import SystemHeader, RadarControllerHeader
	12
	13	class JROData:
	14
	15	# m_BasicHeader = BasicHeader()
	16	# m_ProcessingHeader = ProcessingHeader()
	17
	18	systemHeaderObj = SystemHeader()
	19
	20	radarControllerHeaderObj = RadarControllerHeader()
	21
	22	# data = None
	23
	24	type = None
	25
	26	dtype = None
	27
	28	nChannels = None
	29
	30	nHeights = None
	31
	32	nProfiles = None
	33
	34	heightList = None
	35
	36	channelList = None
	37
	38	channelIndexList = None
	39
	40	flagNoData = True
	41
	42	flagTimeBlock = False
	43
	44	utctime = None
	45
	46	blocksize = None
	47
	48	nCode = None
	49
	50	nBaud = None
	51
	52	code = None
	53
	54	flagDecodeData = True #asumo q la data esta decodificada
	55
	56	flagDeflipData = True #asumo q la data esta sin flip
	57
	58	flagShiftFFT = False
	59
	60	ippSeconds = None
	61
	62	timeInterval = None
	63
	64	def __init__(self):
	65
	66	raise ValueError, "This class has not been implemented"
	67
	68	def copy(self, inputObj=None):
	69
	70	if inputObj == None:
	71	return copy.deepcopy(self)
	72
	73	for key in inputObj.__dict__.keys():
	74	self.__dict__[key] = inputObj.__dict__[key]
	75
	76	def deepcopy(self):
	77
	78	return copy.deepcopy(self)
	79
	80	class Voltage(JROData):
	81
	82	nCohInt = None
	83
	84	#data es un numpy array de 2 dmensiones (canales, alturas)
	85	data = None
	86
	87	def __init__(self):
	88	'''
	89	Constructor
	90	'''
	91
	92	self.radarControllerHeaderObj = RadarControllerHeader()
	93
	94	self.systemHeaderObj = SystemHeader()
	95
	96	self.type = "Voltage"
	97
	98	self.data = None
	99
	100	self.dtype = None
	101
	102	self.nChannels = 0
	103
	104	self.nHeights = 0
	105
	106	self.nProfiles = None
	107
	108	self.heightList = None
	109
	110	self.channelList = None
	111
	112	self.channelIndexList = None
	113
	114	self.flagNoData = True
	115
	116	self.flagTimeBlock = False
	117
	118	self.utctime = None
	119
	120	self.nCohInt = None
	121
	122	self.blocksize = None
	123
	124	class Spectra(JROData):
	125
	126	#data es un numpy array de 2 dmensiones (canales, perfiles, alturas)
	127	data_spc = None
	128
	129	#data es un numpy array de 2 dmensiones (canales, pares, alturas)
	130	data_cspc = None
	131
	132	#data es un numpy array de 2 dmensiones (canales, alturas)
	133	data_dc = None
	134
	135	nFFTPoints = None
	136
	137	nPairs = None
	138
	139	pairsList = None
	140
	141	nIncohInt = None
	142
	143	wavelength = None #Necesario para cacular el rango de velocidad desde la frecuencia
	144
	145	nCohInt = None #se requiere para determinar el valor de timeInterval
	146
	147	def __init__(self):
	148	'''
	149	Constructor
	150	'''
	151
	152	self.radarControllerHeaderObj = RadarControllerHeader()
	153
	154	self.systemHeaderObj = SystemHeader()
	155
	156	self.type = "Spectra"
	157
	158	# self.data = None
	159
	160	self.dtype = None
	161
	162	self.nChannels = 0
	163
	164	self.nHeights = 0
	165
	166	self.nProfiles = None
	167
	168	self.heightList = None
	169
	170	self.channelList = None
	171
	172	self.channelIndexList = None
	173
	174	self.flagNoData = True
	175
	176	self.flagTimeBlock = False
	177
	178	self.utctime = None
	179
	180	self.nIncohInt = None
	181
	182	self.blocksize = None
	183
	184	self.nFFTPoints = None
	185
	186	self.wavelength = None
	187
	188	def getFrequencies(self):
	189
	190	xrange = numpy.arange(self.nFFTPoints)
	191	xrange = xrange
	192	return None
	193
	194
	195	class SpectraHeis(JROData):
	196
	197	data_spc = None
	198
	199	data_cspc = None
	200
	201	data_dc = None
	202
	203	nFFTPoints = None
	204
	205	nPairs = None
	206
	207	pairsList = None
	208
	209	nIncohInt = None
	210
	211	def __init__(self):
	212
	213	self.radarControllerHeaderObj = RadarControllerHeader()
	214
	215	self.systemHeaderObj = SystemHeader()
	216
	217	self.type = "SpectraHeis"
	218
	219	self.dtype = None
	220
	221	self.nChannels = 0
	222
	223	self.nHeights = 0
	224
	225	self.nProfiles = None
	226
	227	self.heightList = None
	228
	229	self.channelList = None
	230
	231	self.channelIndexList = None
	232
	233	self.flagNoData = True
	234
	235	self.flagTimeBlock = False
	236
	237	self.nPairs = 0
	238
	239	self.utctime = None
	240
	241	self.blocksize = None

schainpy/Model/JRODataIO.py created 644 +2461 0

This diff has been collapsed as it changes many lines, (2461 lines changed) Show them Hide them
	@@ -0,0 +1,2461
		1	'''
		2
		3	$Author: murco $
		4	$Id: JRODataIO.py 169 2012-11-19 21:57:03Z murco $
		5	'''
		6
		7	import os, sys
		8	import glob
		9	import time
		10	import numpy
		11	import fnmatch
		12	import time, datetime
		13
		14	from Data.JROData import *
		15	from JROHeaderIO import *
		16
		17	def isNumber(str):
		18	"""
		19	Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
		20
		21	Excepciones:
		22	Si un determinado string no puede ser convertido a numero
		23	Input:
		24	str, string al cual se le analiza para determinar si convertible a un numero o no
		25
		26	Return:
		27	True : si el string es uno numerico
		28	False : no es un string numerico
		29	"""
		30	try:
		31	float( str )
		32	return True
		33	except:
		34	return False
		35
		36	def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
		37	"""
		38	Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
		39
		40	Inputs:
		41	filename : nombre completo del archivo de datos en formato Jicamarca (.r)
		42
		43	startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
		44	segundos contados desde 01/01/1970.
		45	endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
		46	segundos contados desde 01/01/1970.
		47
		48	Return:
		49	Boolean : Retorna True si el archivo de datos contiene datos en el rango de
		50	fecha especificado, de lo contrario retorna False.
		51
		52	Excepciones:
		53	Si el archivo no existe o no puede ser abierto
		54	Si la cabecera no puede ser leida.
		55
		56	"""
		57	basicHeaderObj = BasicHeader()
		58
		59	try:
		60	fp = open(filename,'rb')
		61	except:
		62	raise IOError, "The file %s can't be opened" %(filename)
		63
		64	sts = basicHeaderObj.read(fp)
		65	fp.close()
		66
		67	if not(sts):
		68	print "Skipping the file %s because it has not a valid header" %(filename)
		69	return 0
		70
		71	if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
		72	return 0
		73
		74	return 1
		75
		76	def getlastFileFromPath(path, ext):
		77	"""
		78	Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
		79	al final de la depuracion devuelve el ultimo file de la lista que quedo.
		80
		81	Input:
		82	fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta
		83	ext : extension de los files contenidos en una carpeta
		84
		85	Return:
		86	El ultimo file de una determinada carpeta, no se considera el path.
		87	"""
		88	validFilelist = []
		89	fileList = os.listdir(path)
		90
		91	# 0 1234 567 89A BCDE
		92	# H YYYY DDD SSS .ext
		93
		94	for file in fileList:
		95	try:
		96	year = int(file[1:5])
		97	doy = int(file[5:8])
		98
		99	if (os.path.splitext(file)[-1].upper() != ext.upper()) : continue
		100	except:
		101	continue
		102
		103	validFilelist.append(file)
		104
		105	if validFilelist:
		106	validFilelist = sorted( validFilelist, key=str.lower )
		107	return validFilelist[-1]
		108
		109	return None
		110
		111	def checkForRealPath(path, year, doy, set, ext):
		112	"""
		113	Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
		114	Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
		115	el path exacto de un determinado file.
		116
		117	Example :
		118	nombre correcto del file es .../.../D2009307/P2009307367.ext
		119
		120	Entonces la funcion prueba con las siguientes combinaciones
		121	.../.../x2009307/y2009307367.ext
		122	.../.../x2009307/Y2009307367.ext
		123	.../.../X2009307/y2009307367.ext
		124	.../.../X2009307/Y2009307367.ext
		125	siendo para este caso, la ultima combinacion de letras, identica al file buscado
		126
		127	Return:
		128	Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
		129	caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
		130	para el filename
		131	"""
		132	filepath = None
		133	find_flag = False
		134	filename = None
		135
		136	if ext.lower() == ".r": #voltage
		137	header1 = "dD"
		138	header2 = "dD"
		139	elif ext.lower() == ".pdata": #spectra
		140	header1 = "dD"
		141	header2 = "pP"
		142	else:
		143	return None, filename
		144
		145	for dir in header1: #barrido por las dos combinaciones posibles de "D"
		146	for fil in header2: #barrido por las dos combinaciones posibles de "D"
		147	doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
		148	filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
		149	filepath = os.path.join( path, doypath, filename ) #formo el path completo
		150	if os.path.exists( filepath ): #verifico que exista
		151	find_flag = True
		152	break
		153	if find_flag:
		154	break
		155
		156	if not(find_flag):
		157	return None, filename
		158
		159	return filepath, filename
		160
		161	class JRODataIO:
		162
		163	c = 3E8
		164
		165	basicHeaderObj = BasicHeader()
		166
		167	systemHeaderObj = SystemHeader()
		168
		169	radarControllerHeaderObj = RadarControllerHeader()
		170
		171	processingHeaderObj = ProcessingHeader()
		172
		173	online = 0
		174
		175	dtype = None
		176
		177	pathList = []
		178
		179	filenameList = []
		180
		181	filename = None
		182
		183	ext = None
		184
		185	flagNoMoreFiles = 0
		186
		187	flagIsNewFile = 1
		188
		189	flagTimeBlock = 0
		190
		191	flagIsNewBlock = 0
		192
		193	fp = None
		194
		195	firstHeaderSize = 0
		196
		197	basicHeaderSize = 24
		198
		199	versionFile = 1103
		200
		201	fileSize = None
		202
		203	ippSeconds = None
		204
		205	fileSizeByHeader = None
		206
		207	fileIndex = None
		208
		209	profileIndex = None
		210
		211	blockIndex = None
		212
		213	nTotalBlocks = None
		214
		215	maxTimeStep = 30
		216
		217	lastUTTime = None
		218
		219	datablock = None
		220
		221	dataOutObj = None
		222
		223	blocksize = None
		224
		225	def __init__(self):
		226	pass
		227
		228	class JRODataReader(JRODataIO):
		229
		230	nReadBlocks = 0
		231
		232	delay = 60 #number of seconds waiting a new file
		233
		234	nTries = 3 #quantity tries
		235
		236	nFiles = 3 #number of files for searching
		237
		238
		239	def __init__(self):
		240
		241	"""
		242
		243	"""
		244
		245	raise ValueError, "This method has not been implemented"
		246
		247
		248	def createObjByDefault(self):
		249	"""
		250
		251	"""
		252	raise ValueError, "This method has not been implemented"
		253
		254	def getBlockDimension(self):
		255
		256	raise ValueError, "No implemented"
		257
		258	def __searchFilesOffLine(self,
		259	path,
		260	startDate,
		261	endDate,
		262	startTime=datetime.time(0,0,0),
		263	endTime=datetime.time(23,59,59),
		264	set=None,
		265	expLabel="",
		266	ext=".r"):
		267	dirList = []
		268	for thisPath in os.listdir(path):
		269	if os.path.isdir(os.path.join(path,thisPath)):
		270	dirList.append(thisPath)
		271
		272	if not(dirList):
		273	return None, None
		274
		275	pathList = []
		276	dateList = []
		277
		278	thisDate = startDate
		279
		280	while(thisDate <= endDate):
		281	year = thisDate.timetuple().tm_year
		282	doy = thisDate.timetuple().tm_yday
		283
		284	match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
		285	if len(match) == 0:
		286	thisDate += datetime.timedelta(1)
		287	continue
		288
		289	pathList.append(os.path.join(path,match[0],expLabel))
		290	dateList.append(thisDate)
		291	thisDate += datetime.timedelta(1)
		292
		293	filenameList = []
		294	for index in range(len(pathList)):
		295
		296	thisPath = pathList[index]
		297	fileList = glob.glob1(thisPath, "*%s" %ext)
		298	fileList.sort()
		299
		300	#Busqueda de datos en el rango de horas indicados
		301	thisDate = dateList[index]
		302	startDT = datetime.datetime.combine(thisDate, startTime)
		303	endDT = datetime.datetime.combine(thisDate, endTime)
		304
		305	startUtSeconds = time.mktime(startDT.timetuple())
		306	endUtSeconds = time.mktime(endDT.timetuple())
		307
		308	for file in fileList:
		309
		310	filename = os.path.join(thisPath,file)
		311
		312	if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
		313	filenameList.append(filename)
		314
		315	if not(filenameList):
		316	return None, None
		317
		318	self.filenameList = filenameList
		319
		320	return pathList, filenameList
		321
		322	def __searchFilesOnLine(self, path, startDate=None, endDate=None, startTime=None, endTime=None, expLabel = "", ext = None):
		323
		324	"""
		325	Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
		326	devuelve el archivo encontrado ademas de otros datos.
		327
		328	Input:
		329	path : carpeta donde estan contenidos los files que contiene data
		330
		331	startDate : Fecha inicial. Rechaza todos los directorios donde
		332	file end time < startDate (obejto datetime.date)
		333
		334	endDate : Fecha final. Rechaza todos los directorios donde
		335	file start time > endDate (obejto datetime.date)
		336
		337	startTime : Tiempo inicial. Rechaza todos los archivos donde
		338	file end time < startTime (obejto datetime.time)
		339
		340	endTime : Tiempo final. Rechaza todos los archivos donde
		341	file start time > endTime (obejto datetime.time)
		342
		343	expLabel : Nombre del subexperimento (subfolder)
		344
		345	ext : extension de los files
		346
		347	Return:
		348	directory : eL directorio donde esta el file encontrado
		349	filename : el ultimo file de una determinada carpeta
		350	year : el anho
		351	doy : el numero de dia del anho
		352	set : el set del archivo
		353
		354
		355	"""
		356	dirList = []
		357	pathList = []
		358	directory = None
		359
		360	#Filtra solo los directorios
		361	for thisPath in os.listdir(path):
		362	if os.path.isdir(os.path.join(path, thisPath)):
		363	dirList.append(thisPath)
		364
		365	if not(dirList):
		366	return None, None, None, None, None
		367
		368	dirList = sorted( dirList, key=str.lower )
		369
		370	if startDate:
		371	startDateTime = datetime.datetime.combine(startDate, startTime)
		372	thisDateTime = startDateTime
		373	if endDate == None: endDateTime = startDateTime
		374	else: endDateTime = datetime.datetime.combine(endDate, endTime)
		375
		376	while(thisDateTime <= endDateTime):
		377	year = thisDateTime.timetuple().tm_year
		378	doy = thisDateTime.timetuple().tm_yday
		379
		380	match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
		381	if len(match) == 0:
		382	thisDateTime += datetime.timedelta(1)
		383	continue
		384
		385	pathList.append(os.path.join(path,match[0], expLabel))
		386	thisDateTime += datetime.timedelta(1)
		387
		388	if not(pathList):
		389	print "\tNo files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
		390	return None, None, None, None, None
		391
		392	directory = pathList[0]
		393
		394	else:
		395	directory = dirList[-1]
		396	directory = os.path.join(path,directory)
		397
		398	filename = getlastFileFromPath(directory, ext)
		399
		400	if not(filename):
		401	return None, None, None, None, None
		402
		403	if not(self.__verifyFile(os.path.join(directory, filename))):
		404	return None, None, None, None, None
		405
		406	year = int( filename[1:5] )
		407	doy = int( filename[5:8] )
		408	set = int( filename[8:11] )
		409
		410	return directory, filename, year, doy, set
		411
		412	def setup(self,dataOutObj=None,
		413	path=None,
		414	startDate=None,
		415	endDate=None,
		416	startTime=datetime.time(0,0,0),
		417	endTime=datetime.time(23,59,59),
		418	set=0,
		419	expLabel = "",
		420	ext = None,
		421	online = False,
		422	delay = 60):
		423
		424	if path == None:
		425	raise ValueError, "The path is not valid"
		426
		427	if ext == None:
		428	ext = self.ext
		429
		430	if dataOutObj == None:
		431	dataOutObj = self.createObjByDefault()
		432
		433	self.dataOutObj = dataOutObj
		434
		435	if online:
		436	print "Searching files in online mode..."
		437	doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext)
		438
		439	if not(doypath):
		440	for nTries in range( self.nTries ):
		441	print '\tWaiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
		442	time.sleep( self.delay )
		443	doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=exp)
		444	if doypath:
		445	break
		446
		447	if not(doypath):
		448	print "There 'isn't valied files in %s" % path
		449	return None
		450
		451	self.year = year
		452	self.doy = doy
		453	self.set = set - 1
		454	self.path = path
		455
		456	else:
		457	print "Searching files in offline mode ..."
		458	pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)
		459
		460	if not(pathList):
		461	print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
		462	datetime.datetime.combine(startDate,startTime).ctime(),
		463	datetime.datetime.combine(endDate,endTime).ctime())
		464
		465	sys.exit(-1)
		466
		467
		468	self.fileIndex = -1
		469	self.pathList = pathList
		470	self.filenameList = filenameList
		471
		472	self.online = online
		473	self.delay = delay
		474	ext = ext.lower()
		475	self.ext = ext
		476
		477	if not(self.setNextFile()):
		478	if (startDate!=None) and (endDate!=None):
		479	print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
		480	elif startDate != None:
		481	print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
		482	else:
		483	print "No files"
		484
		485	sys.exit(-1)
		486
		487	# self.updateDataHeader()
		488
		489	return self.dataOutObj
		490
		491	def __setNextFileOffline(self):
		492
		493	idFile = self.fileIndex
		494
		495	while (True):
		496	idFile += 1
		497	if not(idFile < len(self.filenameList)):
		498	self.flagNoMoreFiles = 1
		499	print "No more Files"
		500	return 0
		501
		502	filename = self.filenameList[idFile]
		503
		504	if not(self.__verifyFile(filename)):
		505	continue
		506
		507	fileSize = os.path.getsize(filename)
		508	fp = open(filename,'rb')
		509	break
		510
		511	self.flagIsNewFile = 1
		512	self.fileIndex = idFile
		513	self.filename = filename
		514	self.fileSize = fileSize
		515	self.fp = fp
		516
		517	print "Setting the file: %s"%self.filename
		518
		519	return 1
		520
		521	def __setNextFileOnline(self):
		522	"""
		523	Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
		524	no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
		525	siguientes.
		526
		527	Affected:
		528	self.flagIsNewFile
		529	self.filename
		530	self.fileSize
		531	self.fp
		532	self.set
		533	self.flagNoMoreFiles
		534
		535	Return:
		536	0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
		537	1 : si el file fue abierto con exito y esta listo a ser leido
		538
		539	Excepciones:
		540	Si un determinado file no puede ser abierto
		541	"""
		542	nFiles = 0
		543	fileOk_flag = False
		544	firstTime_flag = True
		545
		546	self.set += 1
		547
		548	#busca el 1er file disponible
		549	file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
		550	if file:
		551	if self.__verifyFile(file, False):
		552	fileOk_flag = True
		553
		554	#si no encuentra un file entonces espera y vuelve a buscar
		555	if not(fileOk_flag):
		556	for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
		557
		558	if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
		559	tries = self.nTries
		560	else:
		561	tries = 1 #si no es la 1era vez entonces solo lo hace una vez
		562
		563	for nTries in range( tries ):
		564	if firstTime_flag:
		565	print "\tWaiting %0.2f sec for the file \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 )
		566	time.sleep( self.delay )
		567	else:
		568	print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
		569
		570	file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
		571	if file:
		572	if self.__verifyFile(file):
		573	fileOk_flag = True
		574	break
		575
		576	if fileOk_flag:
		577	break
		578
		579	firstTime_flag = False
		580
		581	print "\tSkipping the file \"%s\" due to this file doesn't exist" % filename
		582	self.set += 1
		583
		584	if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
		585	self.set = 0
		586	self.doy += 1
		587
		588	if fileOk_flag:
		589	self.fileSize = os.path.getsize( file )
		590	self.filename = file
		591	self.flagIsNewFile = 1
		592	if self.fp != None: self.fp.close()
		593	self.fp = open(file)
		594	self.flagNoMoreFiles = 0
		595	print 'Setting the file: %s' % file
		596	else:
		597	self.fileSize = 0
		598	self.filename = None
		599	self.flagIsNewFile = 0
		600	self.fp = None
		601	self.flagNoMoreFiles = 1
		602	print 'No more Files'
		603
		604	return fileOk_flag
		605
		606
		607	def setNextFile(self):
		608	if self.fp != None:
		609	self.fp.close()
		610
		611	if self.online:
		612	newFile = self.__setNextFileOnline()
		613	else:
		614	newFile = self.__setNextFileOffline()
		615
		616	if not(newFile):
		617	return 0
		618
		619	self.__readFirstHeader()
		620	self.nReadBlocks = 0
		621	return 1
		622
		623	def __setNewBlock(self):
		624	if self.fp == None:
		625	return 0
		626
		627	if self.flagIsNewFile:
		628	return 1
		629
		630	self.lastUTTime = self.basicHeaderObj.utc
		631	currentSize = self.fileSize - self.fp.tell()
		632	neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
		633
		634	if (currentSize >= neededSize):
		635	self.__rdBasicHeader()
		636	return 1
		637
		638	if not(self.setNextFile()):
		639	return 0
		640
		641	deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
		642
		643	self.flagTimeBlock = 0
		644
		645	if deltaTime > self.maxTimeStep:
		646	self.flagTimeBlock = 1
		647
		648	return 1
		649
		650
		651	def readNextBlock(self):
		652	if not(self.__setNewBlock()):
		653	return 0
		654
		655	if not(self.readBlock()):
		656	return 0
		657
		658	return 1
		659
		660	def __rdProcessingHeader(self, fp=None):
		661	if fp == None:
		662	fp = self.fp
		663
		664	self.processingHeaderObj.read(fp)
		665
		666	def __rdRadarControllerHeader(self, fp=None):
		667	if fp == None:
		668	fp = self.fp
		669
		670	self.radarControllerHeaderObj.read(fp)
		671
		672	def __rdSystemHeader(self, fp=None):
		673	if fp == None:
		674	fp = self.fp
		675
		676	self.systemHeaderObj.read(fp)
		677
		678	def __rdBasicHeader(self, fp=None):
		679	if fp == None:
		680	fp = self.fp
		681
		682	self.basicHeaderObj.read(fp)
		683
		684
		685	def __readFirstHeader(self):
		686	self.__rdBasicHeader()
		687	self.__rdSystemHeader()
		688	self.__rdRadarControllerHeader()
		689	self.__rdProcessingHeader()
		690
		691	self.firstHeaderSize = self.basicHeaderObj.size
		692
		693	datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
		694	if datatype == 0:
		695	datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
		696	elif datatype == 1:
		697	datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
		698	elif datatype == 2:
		699	datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
		700	elif datatype == 3:
		701	datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
		702	elif datatype == 4:
		703	datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
		704	elif datatype == 5:
		705	datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
		706	else:
		707	raise ValueError, 'Data type was not defined'
		708
		709	self.dtype = datatype_str
		710	self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
		711	self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
		712	# self.dataOutObj.channelList = numpy.arange(self.systemHeaderObj.numChannels)
		713	# self.dataOutObj.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
		714	self.getBlockDimension()
		715
		716
		717	def __verifyFile(self, filename, msgFlag=True):
		718	msg = None
		719	try:
		720	fp = open(filename, 'rb')
		721	currentPosition = fp.tell()
		722	except:
		723	if msgFlag:
		724	print "The file %s can't be opened" % (filename)
		725	return False
		726
		727	neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
		728
		729	if neededSize == 0:
		730	basicHeaderObj = BasicHeader()
		731	systemHeaderObj = SystemHeader()
		732	radarControllerHeaderObj = RadarControllerHeader()
		733	processingHeaderObj = ProcessingHeader()
		734
		735	try:
		736	if not( basicHeaderObj.read(fp) ): raise ValueError
		737	if not( systemHeaderObj.read(fp) ): raise ValueError
		738	if not( radarControllerHeaderObj.read(fp) ): raise ValueError
		739	if not( processingHeaderObj.read(fp) ): raise ValueError
		740	data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
		741
		742	neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
		743
		744	except:
		745	if msgFlag:
		746	print "\tThe file %s is empty or it hasn't enough data" % filename
		747
		748	fp.close()
		749	return False
		750	else:
		751	msg = "\tSkipping the file %s due to it hasn't enough data" %filename
		752
		753	fp.close()
		754	fileSize = os.path.getsize(filename)
		755	currentSize = fileSize - currentPosition
		756	if currentSize < neededSize:
		757	if msgFlag and (msg != None):
		758	print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
		759	return False
		760
		761	return True
		762
		763	def getData():
		764	pass
		765
		766	def hasNotDataInBuffer():
		767	pass
		768
		769	def readBlock():
		770	pass
		771
		772	class JRODataWriter(JRODataIO):
		773
		774	"""
		775	Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
		776	de los datos siempre se realiza por bloques.
		777	"""
		778
		779	blockIndex = 0
		780
		781	path = None
		782
		783	setFile = None
		784
		785	profilesPerBlock = None
		786
		787	blocksPerFile = None
		788
		789	nWriteBlocks = 0
		790
		791	isConfig = False
		792
		793	def __init__(self, dataOutObj=None):
		794	raise ValueError, "Not implemented"
		795
		796
		797	def hasAllDataInBuffer(self):
		798	raise ValueError, "Not implemented"
		799
		800
		801	def setBlockDimension(self):
		802	raise ValueError, "Not implemented"
		803
		804
		805	def writeBlock(self):
		806	raise ValueError, "No implemented"
		807
		808
		809	def putData(self):
		810	raise ValueError, "No implemented"
		811
		812	def getDataHeader(self):
		813	"""
		814	Obtiene una copia del First Header
		815
		816	Affected:
		817
		818	self.basicHeaderObj
		819	self.systemHeaderObj
		820	self.radarControllerHeaderObj
		821	self.processingHeaderObj self.
		822
		823	Return:
		824	None
		825	"""
		826
		827	raise ValueError, "No implemented"
		828
		829	def getBasicHeader(self):
		830
		831	self.basicHeaderObj.size = self.basicHeaderSize #bytes
		832	self.basicHeaderObj.version = self.versionFile
		833	self.basicHeaderObj.dataBlock = self.nTotalBlocks
		834
		835	utc = numpy.floor(self.dataOutObj.utctime)
		836	milisecond = (self.dataOutObj.utctime - utc)* 1000.0
		837
		838	self.basicHeaderObj.utc = utc
		839	self.basicHeaderObj.miliSecond = milisecond
		840	self.basicHeaderObj.timeZone = 0
		841	self.basicHeaderObj.dstFlag = 0
		842	self.basicHeaderObj.errorCount = 0
		843
		844	def __writeFirstHeader(self):
		845	"""
		846	Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
		847
		848	Affected:
		849	__dataType
		850
		851	Return:
		852	None
		853	"""
		854
		855	# CALCULAR PARAMETROS
		856
		857	sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
		858	self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
		859
		860	self.basicHeaderObj.write(self.fp)
		861	self.systemHeaderObj.write(self.fp)
		862	self.radarControllerHeaderObj.write(self.fp)
		863	self.processingHeaderObj.write(self.fp)
		864
		865	self.dtype = self.dataOutObj.dtype
		866
		867	def __setNewBlock(self):
		868	"""
		869	Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
		870
		871	Return:
		872	0 : si no pudo escribir nada
		873	1 : Si escribio el Basic el First Header
		874	"""
		875	if self.fp == None:
		876	self.setNextFile()
		877
		878	if self.flagIsNewFile:
		879	return 1
		880
		881	if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
		882	self.basicHeaderObj.write(self.fp)
		883	return 1
		884
		885	if not( self.setNextFile() ):
		886	return 0
		887
		888	return 1
		889
		890
		891	def writeNextBlock(self):
		892	"""
		893	Selecciona el bloque siguiente de datos y los escribe en un file
		894
		895	Return:
		896	0 : Si no hizo pudo escribir el bloque de datos
		897	1 : Si no pudo escribir el bloque de datos
		898	"""
		899	if not( self.__setNewBlock() ):
		900	return 0
		901
		902	self.writeBlock()
		903
		904	return 1
		905
		906	def setNextFile(self):
		907	"""
		908	Determina el siguiente file que sera escrito
		909
		910	Affected:
		911	self.filename
		912	self.subfolder
		913	self.fp
		914	self.setFile
		915	self.flagIsNewFile
		916
		917	Return:
		918	0 : Si el archivo no puede ser escrito
		919	1 : Si el archivo esta listo para ser escrito
		920	"""
		921	ext = self.ext
		922	path = self.path
		923
		924	if self.fp != None:
		925	self.fp.close()
		926
		927	timeTuple = time.localtime( self.dataOutObj.dataUtcTime)
		928	subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
		929
		930	doypath = os.path.join( path, subfolder )
		931	if not( os.path.exists(doypath) ):
		932	os.mkdir(doypath)
		933	self.setFile = -1 #inicializo mi contador de seteo
		934	else:
		935	filesList = os.listdir( doypath )
		936	if len( filesList ) > 0:
		937	filesList = sorted( filesList, key=str.lower )
		938	filen = filesList[-1]
		939	# el filename debera tener el siguiente formato
		940	# 0 1234 567 89A BCDE (hex)
		941	# x YYYY DDD SSS .ext
		942	if isNumber( filen[8:11] ):
		943	self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
		944	else:
		945	self.setFile = -1
		946	else:
		947	self.setFile = -1 #inicializo mi contador de seteo
		948
		949	setFile = self.setFile
		950	setFile += 1
		951
		952	file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
		953	timeTuple.tm_year,
		954	timeTuple.tm_yday,
		955	setFile,
		956	ext )
		957
		958	filename = os.path.join( path, subfolder, file )
		959
		960	fp = open( filename,'wb' )
		961
		962	self.blockIndex = 0
		963
		964	#guardando atributos
		965	self.filename = filename
		966	self.subfolder = subfolder
		967	self.fp = fp
		968	self.setFile = setFile
		969	self.flagIsNewFile = 1
		970
		971	self.getDataHeader()
		972
		973	print 'Writing the file: %s'%self.filename
		974
		975	self.__writeFirstHeader()
		976
		977	return 1
		978
		979	def setup(self, path, blocksPerFile, profilesPerBlock=None, set=0, ext=None):
		980	"""
		981	Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
		982
		983	Inputs:
		984	path : el path destino en el cual se escribiran los files a crear
		985	format : formato en el cual sera salvado un file
		986	set : el setebo del file
		987
		988	Return:
		989	0 : Si no realizo un buen seteo
		990	1 : Si realizo un buen seteo
		991	"""
		992
		993	if ext == None:
		994	ext = self.ext
		995
		996	ext = ext.lower()
		997
		998	self.ext = ext
		999
		1000	self.path = path
		1001
		1002	self.setFile = set - 1
		1003
		1004	self.blocksPerFile = blocksPerFile
		1005
		1006	self.profilesPerBlock = profilesPerBlock
		1007
		1008	if not(self.setNextFile()):
		1009	print "There isn't a next file"
		1010	return 0
		1011
		1012	self.setBlockDimension()
		1013
		1014	return 1
		1015
		1016	def run(self, dataOut, **kwargs):
		1017
		1018	if not(self.isConfig):
		1019
		1020	self.dataOutObj = dataOut
		1021	self.setup(**kwargs)
		1022
		1023	self.putData()
		1024
		1025	class VoltageReader(JRODataReader):
		1026	"""
		1027	Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
		1028	de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
		1029	perfilesalturascanales) son almacenados en la variable "buffer".
		1030
		1031	perfiles * alturas * canales
		1032
		1033	Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
		1034	RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
		1035	cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
		1036	datos desde el "buffer" cada vez que se ejecute el metodo "getData".
		1037
		1038	Example:
		1039
		1040	dpath = "/home/myuser/data"
		1041
		1042	startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
		1043
		1044	endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
		1045
		1046	readerObj = VoltageReader()
		1047
		1048	readerObj.setup(dpath, startTime, endTime)
		1049
		1050	while(True):
		1051
		1052	#to get one profile
		1053	profile = readerObj.getData()
		1054
		1055	#print the profile
		1056	print profile
		1057
		1058	#If you want to see all datablock
		1059	print readerObj.datablock
		1060
		1061	if readerObj.flagNoMoreFiles:
		1062	break
		1063
		1064	"""
		1065
		1066	ext = ".r"
		1067
		1068	optchar = "D"
		1069	dataOutObj = None
		1070
		1071
		1072	def __init__(self, dataOutObj=None):
		1073	"""
		1074	Inicializador de la clase VoltageReader para la lectura de datos de voltage.
		1075
		1076	Input:
		1077	dataOutObj : Objeto de la clase Voltage. Este objeto sera utilizado para
		1078	almacenar un perfil de datos cada vez que se haga un requerimiento
		1079	(getData). El perfil sera obtenido a partir del buffer de datos,
		1080	si el buffer esta vacio se hara un nuevo proceso de lectura de un
		1081	bloque de datos.
		1082	Si este parametro no es pasado se creara uno internamente.
		1083
		1084	Variables afectadas:
		1085	self.dataOutObj
		1086
		1087	Return:
		1088	None
		1089	"""
		1090
		1091	self.datablock = None
		1092
		1093	self.utc = 0
		1094
		1095	self.ext = ".r"
		1096
		1097	self.optchar = "D"
		1098
		1099	self.basicHeaderObj = BasicHeader()
		1100
		1101	self.systemHeaderObj = SystemHeader()
		1102
		1103	self.radarControllerHeaderObj = RadarControllerHeader()
		1104
		1105	self.processingHeaderObj = ProcessingHeader()
		1106
		1107	self.online = 0
		1108
		1109	self.fp = None
		1110
		1111	self.idFile = None
		1112
		1113	self.dtype = None
		1114
		1115	self.fileSizeByHeader = None
		1116
		1117	self.filenameList = []
		1118
		1119	self.filename = None
		1120
		1121	self.fileSize = None
		1122
		1123	self.firstHeaderSize = 0
		1124
		1125	self.basicHeaderSize = 24
		1126
		1127	self.pathList = []
		1128
		1129	self.filenameList = []
		1130
		1131	self.lastUTTime = 0
		1132
		1133	self.maxTimeStep = 30
		1134
		1135	self.flagNoMoreFiles = 0
		1136
		1137	self.set = 0
		1138
		1139	self.path = None
		1140
		1141	self.profileIndex = 9999
		1142
		1143	self.delay = 3 #seconds
		1144
		1145	self.nTries = 3 #quantity tries
		1146
		1147	self.nFiles = 3 #number of files for searching
		1148
		1149	self.nReadBlocks = 0
		1150
		1151	self.flagIsNewFile = 1
		1152
		1153	self.ippSeconds = 0
		1154
		1155	self.flagTimeBlock = 0
		1156
		1157	self.flagIsNewBlock = 0
		1158
		1159	self.nTotalBlocks = 0
		1160
		1161	self.blocksize = 0
		1162
		1163	def createObjByDefault(self):
		1164
		1165	dataObj = Voltage()
		1166
		1167	return dataObj
		1168
		1169	def __hasNotDataInBuffer(self):
		1170	if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
		1171	return 1
		1172	return 0
		1173
		1174
		1175	def getBlockDimension(self):
		1176	"""
		1177	Obtiene la cantidad de puntos a leer por cada bloque de datos
		1178
		1179	Affected:
		1180	self.blocksize
		1181
		1182	Return:
		1183	None
		1184	"""
		1185	pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
		1186	self.blocksize = pts2read
		1187
		1188
		1189	def readBlock(self):
		1190	"""
		1191	readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
		1192	(self.fp) y actualiza todos los parametros relacionados al bloque de datos
		1193	(metadata + data). La data leida es almacenada en el buffer y el contador del buffer
		1194	es seteado a 0
		1195
		1196	Inputs:
		1197	None
		1198
		1199	Return:
		1200	None
		1201
		1202	Affected:
		1203	self.profileIndex
		1204	self.datablock
		1205	self.flagIsNewFile
		1206	self.flagIsNewBlock
		1207	self.nTotalBlocks
		1208
		1209	Exceptions:
		1210	Si un bloque leido no es un bloque valido
		1211	"""
		1212
		1213	junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
		1214
		1215	try:
		1216	junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
		1217	except:
		1218	print "The read block (%3d) has not enough data" %self.nReadBlocks
		1219	return 0
		1220
		1221	junk = numpy.transpose(junk, (2,0,1))
		1222	self.datablock = junk['real'] + junk['imag']*1j
		1223
		1224	self.profileIndex = 0
		1225
		1226	self.flagIsNewFile = 0
		1227	self.flagIsNewBlock = 1
		1228
		1229	self.nTotalBlocks += 1
		1230	self.nReadBlocks += 1
		1231
		1232	return 1
		1233
		1234
		1235	def getData(self):
		1236	"""
		1237	getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
		1238	con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
		1239	lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
		1240
		1241	Ademas incrementa el contador del buffer en 1.
		1242
		1243	Return:
		1244	data : retorna un perfil de voltages (alturas * canales) copiados desde el
		1245	buffer. Si no hay mas archivos a leer retorna None.
		1246
		1247	Variables afectadas:
		1248	self.dataOutObj
		1249	self.profileIndex
		1250
		1251	Affected:
		1252	self.dataOutObj
		1253	self.profileIndex
		1254	self.flagTimeBlock
		1255	self.flagIsNewBlock
		1256	"""
		1257	if self.flagNoMoreFiles: return 0
		1258
		1259	self.flagTimeBlock = 0
		1260	self.flagIsNewBlock = 0
		1261
		1262	if self.__hasNotDataInBuffer():
		1263
		1264	if not( self.readNextBlock() ):
		1265	return 0
		1266
		1267	# self.updateDataHeader()
		1268
		1269	if self.flagNoMoreFiles == 1:
		1270	print 'Process finished'
		1271	return 0
		1272
		1273	#data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
		1274
		1275	if self.datablock == None:
		1276	self.dataOutObj.flagNoData = True
		1277	return 0
		1278
		1279	self.dataOutObj.data = self.datablock[:,self.profileIndex,:]
		1280
		1281	self.dataOutObj.dtype = self.dtype
		1282
		1283	self.dataOutObj.nChannels = self.systemHeaderObj.nChannels
		1284
		1285	self.dataOutObj.nHeights = self.processingHeaderObj.nHeights
		1286
		1287	self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
		1288
		1289	xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
		1290
		1291	self.dataOutObj.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
		1292
		1293	self.dataOutObj.channelList = range(self.systemHeaderObj.nChannels)
		1294
		1295	self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
		1296
		1297	self.dataOutObj.flagTimeBlock = self.flagTimeBlock
		1298
		1299	self.dataOutObj.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
		1300
		1301	self.dataOutObj.ippSeconds = self.ippSeconds
		1302
		1303	self.dataOutObj.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt
		1304
		1305	self.dataOutObj.nCohInt = self.processingHeaderObj.nCohInt
		1306
		1307	self.dataOutObj.flagShiftFFT = False
		1308
		1309	if self.processingHeaderObj.code != None:
		1310	self.dataOutObj.nCode = self.processingHeaderObj.nCode
		1311
		1312	self.dataOutObj.nBaud = self.processingHeaderObj.nBaud
		1313
		1314	self.dataOutObj.code = self.processingHeaderObj.code
		1315
		1316	self.profileIndex += 1
		1317
		1318	self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
		1319
		1320	self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
		1321
		1322	self.dataOutObj.flagNoData = False
		1323
		1324	# print self.profileIndex, self.dataOutObj.utctime
		1325	# if self.profileIndex == 800:
		1326	# a=1
		1327
		1328	return self.dataOutObj.data
		1329
		1330
		1331	class VoltageWriter(JRODataWriter):
		1332	"""
		1333	Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
		1334	de los datos siempre se realiza por bloques.
		1335	"""
		1336
		1337	ext = ".r"
		1338
		1339	optchar = "D"
		1340
		1341	shapeBuffer = None
		1342
		1343
		1344	def __init__(self, dataOutObj=None):
		1345	"""
		1346	Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
		1347
		1348	Affected:
		1349	self.dataOutObj
		1350
		1351	Return: None
		1352	"""
		1353	if dataOutObj == None:
		1354	dataOutObj = Voltage()
		1355
		1356	if not( isinstance(dataOutObj, Voltage) ):
		1357	raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object"
		1358
		1359	self.dataOutObj = dataOutObj
		1360
		1361	self.nTotalBlocks = 0
		1362
		1363	self.profileIndex = 0
		1364
		1365	self.isConfig = False
		1366
		1367	self.fp = None
		1368
		1369	self.flagIsNewFile = 1
		1370
		1371	self.nTotalBlocks = 0
		1372
		1373	self.flagIsNewBlock = 0
		1374
		1375	self.flagNoMoreFiles = 0
		1376
		1377	self.setFile = None
		1378
		1379	self.dtype = None
		1380
		1381	self.path = None
		1382
		1383	self.noMoreFiles = 0
		1384
		1385	self.filename = None
		1386
		1387	self.basicHeaderObj = BasicHeader()
		1388
		1389	self.systemHeaderObj = SystemHeader()
		1390
		1391	self.radarControllerHeaderObj = RadarControllerHeader()
		1392
		1393	self.processingHeaderObj = ProcessingHeader()
		1394
		1395	def hasAllDataInBuffer(self):
		1396	if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
		1397	return 1
		1398	return 0
		1399
		1400
		1401	def setBlockDimension(self):
		1402	"""
		1403	Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
		1404
		1405	Affected:
		1406	self.shape_spc_Buffer
		1407	self.shape_cspc_Buffer
		1408	self.shape_dc_Buffer
		1409
		1410	Return: None
		1411	"""
		1412	self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
		1413	self.processingHeaderObj.nHeights,
		1414	self.systemHeaderObj.nChannels)
		1415
		1416	self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
		1417	self.processingHeaderObj.profilesPerBlock,
		1418	self.processingHeaderObj.nHeights),
		1419	dtype=numpy.dtype('complex'))
		1420
		1421
		1422	def writeBlock(self):
		1423	"""
		1424	Escribe el buffer en el file designado
		1425
		1426	Affected:
		1427	self.profileIndex
		1428	self.flagIsNewFile
		1429	self.flagIsNewBlock
		1430	self.nTotalBlocks
		1431	self.blockIndex
		1432
		1433	Return: None
		1434	"""
		1435	data = numpy.zeros( self.shapeBuffer, self.dtype )
		1436
		1437	junk = numpy.transpose(self.datablock, (1,2,0))
		1438
		1439	data['real'] = junk.real
		1440	data['imag'] = junk.imag
		1441
		1442	data = data.reshape( (-1) )
		1443
		1444	data.tofile( self.fp )
		1445
		1446	self.datablock.fill(0)
		1447
		1448	self.profileIndex = 0
		1449	self.flagIsNewFile = 0
		1450	self.flagIsNewBlock = 1
		1451
		1452	self.blockIndex += 1
		1453	self.nTotalBlocks += 1
		1454
		1455	def putData(self):
		1456	"""
		1457	Setea un bloque de datos y luego los escribe en un file
		1458
		1459	Affected:
		1460	self.flagIsNewBlock
		1461	self.profileIndex
		1462
		1463	Return:
		1464	0 : Si no hay data o no hay mas files que puedan escribirse
		1465	1 : Si se escribio la data de un bloque en un file
		1466	"""
		1467	if self.dataOutObj.flagNoData:
		1468	return 0
		1469
		1470	self.flagIsNewBlock = 0
		1471
		1472	if self.dataOutObj.flagTimeBlock:
		1473
		1474	self.datablock.fill(0)
		1475	self.profileIndex = 0
		1476	self.setNextFile()
		1477
		1478	if self.profileIndex == 0:
		1479	self.getBasicHeader()
		1480
		1481	self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
		1482
		1483	self.profileIndex += 1
		1484
		1485	if self.hasAllDataInBuffer():
		1486	#if self.flagIsNewFile:
		1487	self.writeNextBlock()
		1488	# self.getDataHeader()
		1489
		1490	if self.flagNoMoreFiles:
		1491	#print 'Process finished'
		1492	return 0
		1493
		1494	return 1
		1495
		1496	def __getProcessFlags(self):
		1497
		1498	processFlags = 0
		1499
		1500	dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
		1501	dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
		1502	dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
		1503	dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
		1504	dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
		1505	dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
		1506
		1507	dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
		1508
		1509
		1510
		1511	datatypeValueList = [PROCFLAG.DATATYPE_CHAR,
		1512	PROCFLAG.DATATYPE_SHORT,
		1513	PROCFLAG.DATATYPE_LONG,
		1514	PROCFLAG.DATATYPE_INT64,
		1515	PROCFLAG.DATATYPE_FLOAT,
		1516	PROCFLAG.DATATYPE_DOUBLE]
		1517
		1518
		1519	for index in range(len(dtypeList)):
		1520	if self.dataOutObj.dtype == dtypeList[index]:
		1521	dtypeValue = datatypeValueList[index]
		1522	break
		1523
		1524	processFlags += dtypeValue
		1525
		1526	if self.dataOutObj.flagDecodeData:
		1527	processFlags += PROCFLAG.DECODE_DATA
		1528
		1529	if self.dataOutObj.flagDeflipData:
		1530	processFlags += PROCFLAG.DEFLIP_DATA
		1531
		1532	if self.dataOutObj.code != None:
		1533	processFlags += PROCFLAG.DEFINE_PROCESS_CODE
		1534
		1535	if self.dataOutObj.nCohInt > 1:
		1536	processFlags += PROCFLAG.COHERENT_INTEGRATION
		1537
		1538	return processFlags
		1539
		1540
		1541	def __getBlockSize(self):
		1542	'''
		1543	Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
		1544	'''
		1545
		1546	dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
		1547	dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
		1548	dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
		1549	dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
		1550	dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
		1551	dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
		1552
		1553	dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
		1554	datatypeValueList = [1,2,4,8,4,8]
		1555	for index in range(len(dtypeList)):
		1556	if self.dataOutObj.dtype == dtypeList[index]:
		1557	datatypeValue = datatypeValueList[index]
		1558	break
		1559
		1560	blocksize = int(self.dataOutObj.nHeights * self.dataOutObj.nChannels * self.dataOutObj.nProfiles * datatypeValue * 2)
		1561
		1562	return blocksize
		1563
		1564	def getDataHeader(self):
		1565
		1566	"""
		1567	Obtiene una copia del First Header
		1568
		1569	Affected:
		1570	self.systemHeaderObj
		1571	self.radarControllerHeaderObj
		1572	self.dtype
		1573
		1574	Return:
		1575	None
		1576	"""
		1577
		1578	self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
		1579	self.systemHeaderObj.nChannels = self.dataOutObj.nChannels
		1580	self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
		1581
		1582	self.getBasicHeader()
		1583
		1584	processingHeaderSize = 40 # bytes
		1585	self.processingHeaderObj.dtype = 0 # Voltage
		1586	self.processingHeaderObj.blockSize = self.__getBlockSize()
		1587	self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
		1588	self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
		1589	self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOutObj.processingHeaderObj.nWindows
		1590	self.processingHeaderObj.processFlags = self.__getProcessFlags()
		1591	self.processingHeaderObj.nCohInt = self.dataOutObj.nCohInt
		1592	self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
		1593	self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
		1594
		1595	if self.dataOutObj.code != None:
		1596	self.processingHeaderObj.code = self.dataOutObj.code
		1597	self.processingHeaderObj.nCode = self.dataOutObj.nCode
		1598	self.processingHeaderObj.nBaud = self.dataOutObj.nBaud
		1599	codesize = int(8 + 4 * self.dataOutObj.nCode * self.dataOutObj.nBaud)
		1600	processingHeaderSize += codesize
		1601
		1602	if self.processingHeaderObj.nWindows != 0:
		1603	self.processingHeaderObj.firstHeight = self.dataOutObj.heightList[0]
		1604	self.processingHeaderObj.deltaHeight = self.dataOutObj.heightList[1] - self.dataOutObj.heightList[0]
		1605	self.processingHeaderObj.nHeights = self.dataOutObj.nHeights
		1606	self.processingHeaderObj.samplesWin = self.dataOutObj.nHeights
		1607	processingHeaderSize += 12
		1608
		1609	self.processingHeaderObj.size = processingHeaderSize
		1610
		1611	class SpectraReader(JRODataReader):
		1612	"""
		1613	Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
		1614	de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
		1615	son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
		1616
		1617	paresCanalesIguales * alturas * perfiles (Self Spectra)
		1618	paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
		1619	canales * alturas (DC Channels)
		1620
		1621	Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
		1622	RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
		1623	cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
		1624	datos desde el "buffer" cada vez que se ejecute el metodo "getData".
		1625
		1626	Example:
		1627	dpath = "/home/myuser/data"
		1628
		1629	startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
		1630
		1631	endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
		1632
		1633	readerObj = SpectraReader()
		1634
		1635	readerObj.setup(dpath, startTime, endTime)
		1636
		1637	while(True):
		1638
		1639	readerObj.getData()
		1640
		1641	print readerObj.data_spc
		1642
		1643	print readerObj.data_cspc
		1644
		1645	print readerObj.data_dc
		1646
		1647	if readerObj.flagNoMoreFiles:
		1648	break
		1649
		1650	"""
		1651
		1652	pts2read_SelfSpectra = 0
		1653
		1654	pts2read_CrossSpectra = 0
		1655
		1656	pts2read_DCchannels = 0
		1657
		1658	ext = ".pdata"
		1659
		1660	optchar = "P"
		1661
		1662	dataOutObj = None
		1663
		1664	nRdChannels = None
		1665
		1666	nRdPairs = None
		1667
		1668	rdPairList = []
		1669
		1670
		1671	def __init__(self, dataOutObj=None):
		1672	"""
		1673	Inicializador de la clase SpectraReader para la lectura de datos de espectros.
		1674
		1675	Inputs:
		1676	dataOutObj : Objeto de la clase Spectra. Este objeto sera utilizado para
		1677	almacenar un perfil de datos cada vez que se haga un requerimiento
		1678	(getData). El perfil sera obtenido a partir del buffer de datos,
		1679	si el buffer esta vacio se hara un nuevo proceso de lectura de un
		1680	bloque de datos.
		1681	Si este parametro no es pasado se creara uno internamente.
		1682
		1683	Affected:
		1684	self.dataOutObj
		1685
		1686	Return : None
		1687	"""
		1688
		1689	self.pts2read_SelfSpectra = 0
		1690
		1691	self.pts2read_CrossSpectra = 0
		1692
		1693	self.pts2read_DCchannels = 0
		1694
		1695	self.datablock = None
		1696
		1697	self.utc = None
		1698
		1699	self.ext = ".pdata"
		1700
		1701	self.optchar = "P"
		1702
		1703	self.basicHeaderObj = BasicHeader()
		1704
		1705	self.systemHeaderObj = SystemHeader()
		1706
		1707	self.radarControllerHeaderObj = RadarControllerHeader()
		1708
		1709	self.processingHeaderObj = ProcessingHeader()
		1710
		1711	self.online = 0
		1712
		1713	self.fp = None
		1714
		1715	self.idFile = None
		1716
		1717	self.dtype = None
		1718
		1719	self.fileSizeByHeader = None
		1720
		1721	self.filenameList = []
		1722
		1723	self.filename = None
		1724
		1725	self.fileSize = None
		1726
		1727	self.firstHeaderSize = 0
		1728
		1729	self.basicHeaderSize = 24
		1730
		1731	self.pathList = []
		1732
		1733	self.lastUTTime = 0
		1734
		1735	self.maxTimeStep = 30
		1736
		1737	self.flagNoMoreFiles = 0
		1738
		1739	self.set = 0
		1740
		1741	self.path = None
		1742
		1743	self.delay = 3 #seconds
		1744
		1745	self.nTries = 3 #quantity tries
		1746
		1747	self.nFiles = 3 #number of files for searching
		1748
		1749	self.nReadBlocks = 0
		1750
		1751	self.flagIsNewFile = 1
		1752
		1753	self.ippSeconds = 0
		1754
		1755	self.flagTimeBlock = 0
		1756
		1757	self.flagIsNewBlock = 0
		1758
		1759	self.nTotalBlocks = 0
		1760
		1761	self.blocksize = 0
		1762
		1763
		1764	def createObjByDefault(self):
		1765
		1766	dataObj = Spectra()
		1767
		1768	return dataObj
		1769
		1770	def __hasNotDataInBuffer(self):
		1771	return 1
		1772
		1773
		1774	def getBlockDimension(self):
		1775	"""
		1776	Obtiene la cantidad de puntos a leer por cada bloque de datos
		1777
		1778	Affected:
		1779	self.nRdChannels
		1780	self.nRdPairs
		1781	self.pts2read_SelfSpectra
		1782	self.pts2read_CrossSpectra
		1783	self.pts2read_DCchannels
		1784	self.blocksize
		1785	self.dataOutObj.nChannels
		1786	self.dataOutObj.nPairs
		1787
		1788	Return:
		1789	None
		1790	"""
		1791	self.nRdChannels = 0
		1792	self.nRdPairs = 0
		1793	self.rdPairList = []
		1794
		1795	for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
		1796	if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
		1797	self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
		1798	else:
		1799	self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
		1800	self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
		1801
		1802	pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
		1803
		1804	self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
		1805	self.blocksize = self.pts2read_SelfSpectra
		1806
		1807	if self.processingHeaderObj.flag_cspc:
		1808	self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
		1809	self.blocksize += self.pts2read_CrossSpectra
		1810
		1811	if self.processingHeaderObj.flag_dc:
		1812	self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)
		1813	self.blocksize += self.pts2read_DCchannels
		1814
		1815	# self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
		1816
		1817
		1818	def readBlock(self):
		1819	"""
		1820	Lee el bloque de datos desde la posicion actual del puntero del archivo
		1821	(self.fp) y actualiza todos los parametros relacionados al bloque de datos
		1822	(metadata + data). La data leida es almacenada en el buffer y el contador del buffer
		1823	es seteado a 0
		1824
		1825	Return: None
		1826
		1827	Variables afectadas:
		1828
		1829	self.flagIsNewFile
		1830	self.flagIsNewBlock
		1831	self.nTotalBlocks
		1832	self.data_spc
		1833	self.data_cspc
		1834	self.data_dc
		1835
		1836	Exceptions:
		1837	Si un bloque leido no es un bloque valido
		1838	"""
		1839	blockOk_flag = False
		1840	fpointer = self.fp.tell()
		1841
		1842	spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )
		1843	spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
		1844
		1845	if self.processingHeaderObj.flag_cspc:
		1846	cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )
		1847	cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
		1848
		1849	if self.processingHeaderObj.flag_dc:
		1850	dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
		1851	dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D
		1852
		1853
		1854	if not(self.processingHeaderObj.shif_fft):
		1855	spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
		1856
		1857	if self.processingHeaderObj.flag_cspc:
		1858	cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
		1859
		1860
		1861	spc = numpy.transpose( spc, (0,2,1) )
		1862	self.data_spc = spc
		1863
		1864	if self.processingHeaderObj.flag_cspc:
		1865	cspc = numpy.transpose( cspc, (0,2,1) )
		1866	self.data_cspc = cspc['real'] + cspc['imag']*1j
		1867	else:
		1868	self.data_cspc = None
		1869
		1870	if self.processingHeaderObj.flag_dc:
		1871	self.data_dc = dc['real'] + dc['imag']*1j
		1872	else:
		1873	self.data_dc = None
		1874
		1875	self.flagIsNewFile = 0
		1876	self.flagIsNewBlock = 1
		1877
		1878	self.nTotalBlocks += 1
		1879	self.nReadBlocks += 1
		1880
		1881	return 1
		1882
		1883
		1884	def getData(self):
		1885	"""
		1886	Copia el buffer de lectura a la clase "Spectra",
		1887	con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
		1888	lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
		1889
		1890	Return:
		1891	0 : Si no hay mas archivos disponibles
		1892	1 : Si hizo una buena copia del buffer
		1893
		1894	Affected:
		1895	self.dataOutObj
		1896
		1897	self.flagTimeBlock
		1898	self.flagIsNewBlock
		1899	"""
		1900
		1901	if self.flagNoMoreFiles: return 0
		1902
		1903	self.flagTimeBlock = 0
		1904	self.flagIsNewBlock = 0
		1905
		1906	if self.__hasNotDataInBuffer():
		1907
		1908	if not( self.readNextBlock() ):
		1909	return 0
		1910
		1911	# self.updateDataHeader()
		1912
		1913	if self.flagNoMoreFiles == 1:
		1914	print 'Process finished'
		1915	return 0
		1916
		1917	#data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
		1918
		1919	if self.data_dc == None:
		1920	self.dataOutObj.flagNoData = True
		1921	return 0
		1922
		1923
		1924	self.dataOutObj.data_spc = self.data_spc
		1925
		1926	self.dataOutObj.data_cspc = self.data_cspc
		1927
		1928	self.dataOutObj.data_dc = self.data_dc
		1929
		1930	self.dataOutObj.flagTimeBlock = self.flagTimeBlock
		1931
		1932	self.dataOutObj.flagNoData = False
		1933
		1934	self.dataOutObj.dtype = self.dtype
		1935
		1936	self.dataOutObj.nChannels = self.nRdChannels
		1937
		1938	self.dataOutObj.nPairs = self.nRdPairs
		1939
		1940	self.dataOutObj.pairsList = self.rdPairList
		1941
		1942	self.dataOutObj.nHeights = self.processingHeaderObj.nHeights
		1943
		1944	self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
		1945
		1946	self.dataOutObj.nFFTPoints = self.processingHeaderObj.profilesPerBlock
		1947
		1948	self.dataOutObj.nIncohInt = self.processingHeaderObj.nIncohInt
		1949
		1950
		1951	xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
		1952
		1953	self.dataOutObj.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
		1954
		1955	self.dataOutObj.channelList = range(self.systemHeaderObj.nChannels)
		1956
		1957	self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
		1958
		1959	self.dataOutObj.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds
		1960
		1961	self.dataOutObj.ippSeconds = self.ippSeconds
		1962
		1963	self.dataOutObj.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOutObj.nFFTPoints
		1964
		1965	self.dataOutObj.flagShiftFFT = self.processingHeaderObj.shif_fft
		1966
		1967	# self.profileIndex += 1
		1968
		1969	self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
		1970
		1971	self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
		1972
		1973	return self.dataOutObj.data_spc
		1974
		1975
		1976	class SpectraWriter(JRODataWriter):
		1977
		1978	"""
		1979	Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
		1980	de los datos siempre se realiza por bloques.
		1981	"""
		1982
		1983	ext = ".pdata"
		1984
		1985	optchar = "P"
		1986
		1987	shape_spc_Buffer = None
		1988
		1989	shape_cspc_Buffer = None
		1990
		1991	shape_dc_Buffer = None
		1992
		1993	data_spc = None
		1994
		1995	data_cspc = None
		1996
		1997	data_dc = None
		1998
		1999	# dataOutObj = None
		2000
		2001	def __init__(self, dataOutObj=None):
		2002	"""
		2003	Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
		2004
		2005	Affected:
		2006	self.dataOutObj
		2007	self.basicHeaderObj
		2008	self.systemHeaderObj
		2009	self.radarControllerHeaderObj
		2010	self.processingHeaderObj
		2011
		2012	Return: None
		2013	"""
		2014	if dataOutObj == None:
		2015	dataOutObj = Spectra()
		2016
		2017	if not( isinstance(dataOutObj, Spectra) ):
		2018	raise ValueError, "in SpectraReader, dataOutObj must be an Spectra class object"
		2019
		2020	self.dataOutObj = dataOutObj
		2021
		2022	self.nTotalBlocks = 0
		2023
		2024	self.data_spc = None
		2025
		2026	self.data_cspc = None
		2027
		2028	self.data_dc = None
		2029
		2030	self.fp = None
		2031
		2032	self.flagIsNewFile = 1
		2033
		2034	self.nTotalBlocks = 0
		2035
		2036	self.flagIsNewBlock = 0
		2037
		2038	self.flagNoMoreFiles = 0
		2039
		2040	self.setFile = None
		2041
		2042	self.dtype = None
		2043
		2044	self.path = None
		2045
		2046	self.noMoreFiles = 0
		2047
		2048	self.filename = None
		2049
		2050	self.basicHeaderObj = BasicHeader()
		2051
		2052	self.systemHeaderObj = SystemHeader()
		2053
		2054	self.radarControllerHeaderObj = RadarControllerHeader()
		2055
		2056	self.processingHeaderObj = ProcessingHeader()
		2057
		2058
		2059	def hasAllDataInBuffer(self):
		2060	return 1
		2061
		2062
		2063	def setBlockDimension(self):
		2064	"""
		2065	Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
		2066
		2067	Affected:
		2068	self.shape_spc_Buffer
		2069	self.shape_cspc_Buffer
		2070	self.shape_dc_Buffer
		2071
		2072	Return: None
		2073	"""
		2074	self.shape_spc_Buffer = (self.dataOutObj.nChannels,
		2075	self.processingHeaderObj.nHeights,
		2076	self.processingHeaderObj.profilesPerBlock)
		2077
		2078	self.shape_cspc_Buffer = (self.dataOutObj.nPairs,
		2079	self.processingHeaderObj.nHeights,
		2080	self.processingHeaderObj.profilesPerBlock)
		2081
		2082	self.shape_dc_Buffer = (self.dataOutObj.nChannels,
		2083	self.processingHeaderObj.nHeights)
		2084
		2085
		2086	def writeBlock(self):
		2087	"""
		2088	Escribe el buffer en el file designado
		2089
		2090	Affected:
		2091	self.data_spc
		2092	self.data_cspc
		2093	self.data_dc
		2094	self.flagIsNewFile
		2095	self.flagIsNewBlock
		2096	self.nTotalBlocks
		2097	self.nWriteBlocks
		2098
		2099	Return: None
		2100	"""
		2101
		2102	spc = numpy.transpose( self.data_spc, (0,2,1) )
		2103	if not( self.processingHeaderObj.shif_fft ):
		2104	spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
		2105	data = spc.reshape((-1))
		2106	data.tofile(self.fp)
		2107
		2108	if self.data_cspc != None:
		2109	data = numpy.zeros( self.shape_cspc_Buffer, self.dtype )
		2110	cspc = numpy.transpose( self.data_cspc, (0,2,1) )
		2111	if not( self.processingHeaderObj.shif_fft ):
		2112	cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
		2113	data['real'] = cspc.real
		2114	data['imag'] = cspc.imag
		2115	data = data.reshape((-1))
		2116	data.tofile(self.fp)
		2117
		2118	if self.data_dc != None:
		2119	data = numpy.zeros( self.shape_dc_Buffer, self.dtype )
		2120	dc = self.data_dc
		2121	data['real'] = dc.real
		2122	data['imag'] = dc.imag
		2123	data = data.reshape((-1))
		2124	data.tofile(self.fp)
		2125
		2126	self.data_spc.fill(0)
		2127	self.data_dc.fill(0)
		2128	if self.data_cspc != None:
		2129	self.data_cspc.fill(0)
		2130
		2131	self.flagIsNewFile = 0
		2132	self.flagIsNewBlock = 1
		2133	self.nTotalBlocks += 1
		2134	self.nWriteBlocks += 1
		2135	self.blockIndex += 1
		2136
		2137
		2138	def putData(self):
		2139	"""
		2140	Setea un bloque de datos y luego los escribe en un file
		2141
		2142	Affected:
		2143	self.data_spc
		2144	self.data_cspc
		2145	self.data_dc
		2146
		2147	Return:
		2148	0 : Si no hay data o no hay mas files que puedan escribirse
		2149	1 : Si se escribio la data de un bloque en un file
		2150	"""
		2151
		2152	if self.dataOutObj.flagNoData:
		2153	return 0
		2154
		2155	self.flagIsNewBlock = 0
		2156
		2157	if self.dataOutObj.flagTimeBlock:
		2158	self.data_spc.fill(0)
		2159	self.data_cspc.fill(0)
		2160	self.data_dc.fill(0)
		2161	self.setNextFile()
		2162
		2163	if self.flagIsNewFile == 0:
		2164	self.getBasicHeader()
		2165
		2166	self.data_spc = self.dataOutObj.data_spc
		2167	self.data_cspc = self.dataOutObj.data_cspc
		2168	self.data_dc = self.dataOutObj.data_dc
		2169
		2170	# #self.processingHeaderObj.dataBlocksPerFile)
		2171	if self.hasAllDataInBuffer():
		2172	# self.getDataHeader()
		2173	self.writeNextBlock()
		2174
		2175	if self.flagNoMoreFiles:
		2176	#print 'Process finished'
		2177	return 0
		2178
		2179	return 1
		2180
		2181
		2182	def __getProcessFlags(self):
		2183
		2184	processFlags = 0
		2185
		2186	dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
		2187	dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
		2188	dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
		2189	dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
		2190	dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
		2191	dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
		2192
		2193	dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
		2194
		2195
		2196
		2197	datatypeValueList = [PROCFLAG.DATATYPE_CHAR,
		2198	PROCFLAG.DATATYPE_SHORT,
		2199	PROCFLAG.DATATYPE_LONG,
		2200	PROCFLAG.DATATYPE_INT64,
		2201	PROCFLAG.DATATYPE_FLOAT,
		2202	PROCFLAG.DATATYPE_DOUBLE]
		2203
		2204
		2205	for index in range(len(dtypeList)):
		2206	if self.dataOutObj.dtype == dtypeList[index]:
		2207	dtypeValue = datatypeValueList[index]
		2208	break
		2209
		2210	processFlags += dtypeValue
		2211
		2212	if self.dataOutObj.flagDecodeData:
		2213	processFlags += PROCFLAG.DECODE_DATA
		2214
		2215	if self.dataOutObj.flagDeflipData:
		2216	processFlags += PROCFLAG.DEFLIP_DATA
		2217
		2218	if self.dataOutObj.code != None:
		2219	processFlags += PROCFLAG.DEFINE_PROCESS_CODE
		2220
		2221	if self.dataOutObj.nIncohInt > 1:
		2222	processFlags += PROCFLAG.INCOHERENT_INTEGRATION
		2223
		2224	if self.dataOutObj.data_dc != None:
		2225	processFlags += PROCFLAG.SAVE_CHANNELS_DC
		2226
		2227	return processFlags
		2228
		2229
		2230	def __getBlockSize(self):
		2231	'''
		2232	Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
		2233	'''
		2234
		2235	dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
		2236	dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
		2237	dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
		2238	dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
		2239	dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
		2240	dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
		2241
		2242	dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
		2243	datatypeValueList = [1,2,4,8,4,8]
		2244	for index in range(len(dtypeList)):
		2245	if self.dataOutObj.dtype == dtypeList[index]:
		2246	datatypeValue = datatypeValueList[index]
		2247	break
		2248
		2249
		2250	pts2write = self.dataOutObj.nHeights * self.dataOutObj.nFFTPoints
		2251
		2252	pts2write_SelfSpectra = int(self.dataOutObj.nChannels * pts2write)
		2253	blocksize = (pts2write_SelfSpectra*datatypeValue)
		2254
		2255	if self.dataOutObj.data_cspc != None:
		2256	pts2write_CrossSpectra = int(self.dataOutObj.nPairs * pts2write)
		2257	blocksize += (pts2write_CrossSpectradatatypeValue2)
		2258
		2259	if self.dataOutObj.data_dc != None:
		2260	pts2write_DCchannels = int(self.dataOutObj.nChannels * self.dataOutObj.nHeights)
		2261	blocksize += (pts2write_DCchannelsdatatypeValue2)
		2262
		2263	blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
		2264
		2265	return blocksize
		2266
		2267	def getDataHeader(self):
		2268
		2269	"""
		2270	Obtiene una copia del First Header
		2271
		2272	Affected:
		2273	self.systemHeaderObj
		2274	self.radarControllerHeaderObj
		2275	self.dtype
		2276
		2277	Return:
		2278	None
		2279	"""
		2280
		2281	self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
		2282	self.systemHeaderObj.nChannels = self.dataOutObj.nChannels
		2283	self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
		2284
		2285	self.getBasicHeader()
		2286
		2287	processingHeaderSize = 40 # bytes
		2288	self.processingHeaderObj.dtype = 0 # Voltage
		2289	self.processingHeaderObj.blockSize = self.__getBlockSize()
		2290	self.processingHeaderObj.profilesPerBlock = self.dataOutObj.nFFTPoints
		2291	self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
		2292	self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOutObj.processingHeaderObj.nWindows
		2293	self.processingHeaderObj.processFlags = self.__getProcessFlags()
		2294	self.processingHeaderObj.nCohInt = self.dataOutObj.nCohInt# Se requiere para determinar el valor de timeInterval
		2295	self.processingHeaderObj.nIncohInt = self.dataOutObj.nIncohInt
		2296	self.processingHeaderObj.totalSpectra = self.dataOutObj.nPairs + self.dataOutObj.nChannels
		2297
		2298	if self.processingHeaderObj.totalSpectra > 0:
		2299	channelList = []
		2300	for channel in range(self.dataOutObj.nChannels):
		2301	channelList.append(channel)
		2302	channelList.append(channel)
		2303
		2304	pairsList = []
		2305	for pair in self.dataOutObj.pairsList:
		2306	pairsList.append(pair[0])
		2307	pairsList.append(pair[1])
		2308	spectraComb = channelList + pairsList
		2309	spectraComb = numpy.array(spectraComb,dtype="u1")
		2310	self.processingHeaderObj.spectraComb = spectraComb
		2311	sizeOfSpcComb = len(spectraComb)
		2312	processingHeaderSize += sizeOfSpcComb
		2313
		2314	if self.dataOutObj.code != None:
		2315	self.processingHeaderObj.code = self.dataOutObj.code
		2316	self.processingHeaderObj.nCode = self.dataOutObj.nCode
		2317	self.processingHeaderObj.nBaud = self.dataOutObj.nBaud
		2318	nCodeSize = 4 # bytes
		2319	nBaudSize = 4 # bytes
		2320	codeSize = 4 # bytes
		2321	sizeOfCode = int(nCodeSize + nBaudSize + codeSize * self.dataOutObj.nCode * self.dataOutObj.nBaud)
		2322	processingHeaderSize += sizeOfCode
		2323
		2324	if self.processingHeaderObj.nWindows != 0:
		2325	self.processingHeaderObj.firstHeight = self.dataOutObj.heightList[0]
		2326	self.processingHeaderObj.deltaHeight = self.dataOutObj.heightList[1] - self.dataOutObj.heightList[0]
		2327	self.processingHeaderObj.nHeights = self.dataOutObj.nHeights
		2328	self.processingHeaderObj.samplesWin = self.dataOutObj.nHeights
		2329	sizeOfFirstHeight = 4
		2330	sizeOfdeltaHeight = 4
		2331	sizeOfnHeights = 4
		2332	sizeOfWindows = (sizeOfFirstHeight + sizeOfdeltaHeight + sizeOfnHeights)*self.processingHeaderObj.nWindows
		2333	processingHeaderSize += sizeOfWindows
		2334
		2335	self.processingHeaderObj.size = processingHeaderSize
		2336
		2337	class SpectraHeisWriter():
		2338
		2339	i=0
		2340
		2341	def __init__(self, dataOutObj):
		2342
		2343	self.wrObj = FITS()
		2344	self.dataOutObj = dataOutObj
		2345
		2346	def isNumber(str):
		2347	"""
		2348	Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
		2349
		2350	Excepciones:
		2351	Si un determinado string no puede ser convertido a numero
		2352	Input:
		2353	str, string al cual se le analiza para determinar si convertible a un numero o no
		2354
		2355	Return:
		2356	True : si el string es uno numerico
		2357	False : no es un string numerico
		2358	"""
		2359	try:
		2360	float( str )
		2361	return True
		2362	except:
		2363	return False
		2364
		2365	def setup(self, wrpath,):
		2366
		2367	if not(os.path.exists(wrpath)):
		2368	os.mkdir(wrpath)
		2369
		2370	self.wrpath = wrpath
		2371	self.setFile = 0
		2372
		2373	def putData(self):
		2374	# self.wrObj.writeHeader(nChannels=self.dataOutObj.nChannels, nFFTPoints=self.dataOutObj.nFFTPoints)
		2375	#name = self.dataOutObj.utctime
		2376	name= time.localtime( self.dataOutObj.utctime)
		2377	ext=".fits"
		2378	#folder='D%4.4d%3.3d'%(name.tm_year,name.tm_yday)
		2379	subfolder = 'D%4.4d%3.3d' % (name.tm_year,name.tm_yday)
		2380
		2381	doypath = os.path.join( self.wrpath, subfolder )
		2382	if not( os.path.exists(doypath) ):
		2383	os.mkdir(doypath)
		2384	self.setFile += 1
		2385	file = 'D%4.4d%3.3d%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)
		2386
		2387	filename = os.path.join(self.wrpath,subfolder, file)
		2388
		2389	# print self.dataOutObj.ippSeconds
		2390	freq=numpy.arange(-1self.dataOutObj.nHeights/2.,self.dataOutObj.nHeights/2.)/(2self.dataOutObj.ippSeconds)
		2391
		2392	col1=self.wrObj.setColF(name="freq", format=str(self.dataOutObj.nFFTPoints)+'E', array=freq)
		2393	col2=self.wrObj.writeData(name="P_Ch1",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[0,:]))
		2394	col3=self.wrObj.writeData(name="P_Ch2",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[1,:]))
		2395	col4=self.wrObj.writeData(name="P_Ch3",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[2,:]))
		2396	col5=self.wrObj.writeData(name="P_Ch4",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[3,:]))
		2397	col6=self.wrObj.writeData(name="P_Ch5",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[4,:]))
		2398	col7=self.wrObj.writeData(name="P_Ch6",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[5,:]))
		2399	col8=self.wrObj.writeData(name="P_Ch7",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[6,:]))
		2400	col9=self.wrObj.writeData(name="P_Ch8",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[7,:]))
		2401	#n=numpy.arange((100))
		2402	n=self.dataOutObj.data_spc[6,:]
		2403	a=self.wrObj.cFImage(n)
		2404	b=self.wrObj.Ctable(col1,col2,col3,col4,col5,col6,col7,col8,col9)
		2405	self.wrObj.CFile(a,b)
		2406	self.wrObj.wFile(filename)
		2407	return 1
		2408
		2409	class FITS:
		2410
		2411	name=None
		2412	format=None
		2413	array =None
		2414	data =None
		2415	thdulist=None
		2416
		2417	def __init__(self):
		2418
		2419	pass
		2420
		2421	def setColF(self,name,format,array):
		2422	self.name=name
		2423	self.format=format
		2424	self.array=array
		2425	a1=numpy.array([self.array],dtype=numpy.float32)
		2426	self.col1 = pyfits.Column(name=self.name, format=self.format, array=a1)
		2427	return self.col1
		2428
		2429	# def setColP(self,name,format,data):
		2430	# self.name=name
		2431	# self.format=format
		2432	# self.data=data
		2433	# a2=numpy.array([self.data],dtype=numpy.float32)
		2434	# self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
		2435	# return self.col2
		2436
		2437	def writeHeader(self,):
		2438	pass
		2439
		2440	def writeData(self,name,format,data):
		2441	self.name=name
		2442	self.format=format
		2443	self.data=data
		2444	a2=numpy.array([self.data],dtype=numpy.float32)
		2445	self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
		2446	return self.col2
		2447
		2448	def cFImage(self,n):
		2449	self.hdu= pyfits.PrimaryHDU(n)
		2450	return self.hdu
		2451
		2452	def Ctable(self,col1,col2,col3,col4,col5,col6,col7,col8,col9):
		2453	self.cols=pyfits.ColDefs( [col1,col2,col3,col4,col5,col6,col7,col8,col9])
		2454	self.tbhdu = pyfits.new_table(self.cols)
		2455	return self.tbhdu
		2456
		2457	def CFile(self,hdu,tbhdu):
		2458	self.thdulist=pyfits.HDUList([hdu,tbhdu])
		2459
		2460	def wFile(self,filename):
		2461	self.thdulist.writeto(filename) No newline at end of file

schainpy/Model/JROHeaderIO.py created 644 +505 0

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

schainpy/Model/JROPlot.py created 644 0 0

NO CONTENT: new file 100644

schainpy/Model/JROProcessing.py created 644 +423 0

@@ -0,0 +1,423
	1	'''
	2
	3	$Author: dsuarez $
	4	$Id: Processor.py 1 2012-11-12 18:56:07Z dsuarez $
	5	'''
	6	import os
	7	import numpy
	8	import datetime
	9	import time
	10
	11	from JROData import *
	12	from JRODataIO import *
	13	from JROPlot import *
	14
	15	class ProcessingUnit:
	16
	17	"""
	18	Esta es la clase base para el procesamiento de datos.
	19
	20	Contiene el metodo "call" para llamar operaciones. Las operaciones pueden ser:
	21	- Metodos internos (callMethod)
	22	- Objetos del tipo Operation (callObject). Antes de ser llamados, estos objetos
	23	tienen que ser agreagados con el metodo "add".
	24
	25	"""
	26	# objeto de datos de entrada (Voltage, Spectra o Correlation)
	27	dataIn = None
	28
	29	# objeto de datos de entrada (Voltage, Spectra o Correlation)
	30	dataOut = None
	31
	32
	33	objectDict = None
	34
	35	def __init__(self):
	36
	37	self.objectDict = {}
	38
	39	def addOperation(self, object, objId):
	40
	41	"""
	42	Agrega el objeto "object" a la lista de objetos "self.objectList" y retorna el
	43	identificador asociado a este objeto.
	44
	45	Input:
	46
	47	object : objeto de la clase "Operation"
	48
	49	Return:
	50
	51	objId : identificador del objeto, necesario para ejecutar la operacion
	52	"""
	53
	54	self.object[objId] = object
	55
	56	return objId
	57
	58	def operation(self, **kwargs):
	59
	60	"""
	61	Operacion directa sobre la data (dataout.data). Es necesario actualizar los valores de los
	62	atributos del objeto dataOut
	63
	64	Input:
	65
	66	**kwargs : Diccionario de argumentos de la funcion a ejecutar
	67	"""
	68
	69	if self.dataIn.isEmpty():
	70	return None
	71
	72	raise ValueError, "ImplementedError"
	73
	74	def callMethod(self, name, **kwargs):
	75
	76	"""
	77	Ejecuta el metodo con el nombre "name" y con argumentos **kwargs de la propia clase.
	78
	79	Input:
	80	name : nombre del metodo a ejecutar
	81
	82	**kwargs : diccionario con los nombres y valores de la funcion a ejecutar.
	83
	84	"""
	85
	86	if self.dataIn.isEmpty():
	87	return None
	88
	89	methodToCall = getattr(self, name)
	90
	91	methodToCall(**kwargs)
	92
	93	def callObject(self, objId, **kwargs):
	94
	95	"""
	96	Ejecuta la operacion asociada al identificador del objeto "objId"
	97
	98	Input:
	99
	100	objId : identificador del objeto a ejecutar
	101
	102	**kwargs : diccionario con los nombres y valores de la funcion a ejecutar.
	103
	104	Return:
	105
	106	None
	107	"""
	108
	109	if self.dataIn.isEmpty():
	110	return None
	111
	112	object = self.objectList[objId]
	113
	114	object.run(self.dataOut, **kwargs)
	115
	116	def call(self, operation, **kwargs):
	117
	118	"""
	119	Ejecuta la operacion "operation" con los argumentos "**kwargs". La operacion puede
	120	ser de dos tipos:
	121
	122	1. Un metodo propio de esta clase:
	123
	124	operation.type = "self"
	125
	126	2. El metodo "run" de un objeto del tipo Operation o de un derivado de ella:
	127	operation.type = "other".
	128
	129	Este objeto de tipo Operation debe de haber sido agregado antes con el metodo:
	130	"addOperation" e identificado con el operation.id
	131
	132
	133	con el id de la operacion.
	134	"""
	135	if self.dataIn.isEmpty():
	136	return None
	137
	138	if operation.type == 'self':
	139	self.callMethod(operation.name, **kwargs)
	140	return
	141
	142	if operation.type == 'other':
	143	self.callObject(operation.id, **kwargs)
	144	return
	145
	146	class Operation():
	147
	148	"""
	149	Clase base para definir las operaciones adicionales que se pueden agregar a la clase ProcessingUnit
	150	y necesiten acumular información previa de los datos a procesar. De preferencia usar un buffer de
	151	acumulacion dentro de esta clase
	152
	153	Ejemplo: Integraciones coherentes, necesita la información previa de los n perfiles anteriores (bufffer)
	154
	155	"""
	156
	157	__buffer = None
	158
	159	def __init__(self):
	160
	161	pass
	162
	163	def run(self, dataIn, **kwargs):
	164
	165	"""
	166	Realiza las operaciones necesarias sobre la dataIn.data y actualiza los atributos del objeto dataIn.
	167
	168	Input:
	169
	170	dataIn : objeto del tipo JROData
	171
	172	Return:
	173
	174	None
	175
	176	Affected:
	177	__buffer : buffer de recepcion de datos.
	178
	179	"""
	180
	181	raise ValueError, "ImplementedError"
	182
	183	class VoltageProc(ProcessingUnit):
	184
	185
	186	def __init__(self):
	187
	188	pass
	189
	190	def setup(self, dataInObj=None, dataOutObj=None):
	191
	192	self.dataInObj = dataInObj
	193
	194	if self.dataOutObj == None:
	195	dataOutObj = Voltage()
	196
	197	self.dataOutObj = dataOutObj
	198
	199	return self.dataOutObj
	200
	201	def init(self):
	202
	203	if self.dataInObj.isEmpty():
	204	return 0
	205
	206	self.dataOutObj.copy(self.dataInObj)
	207	# No necesita copiar en cada init() los atributos de dataInObj
	208	# la copia deberia hacerse por cada nuevo bloque de datos
	209
	210	def selectChannels(self, channelList):
	211
	212	if self.dataInObj.isEmpty():
	213	return 0
	214
	215	self.selectChannelsByIndex(channelList)
	216
	217	def selectChannelsByIndex(self, channelIndexList):
	218	"""
	219	Selecciona un bloque de datos en base a canales segun el channelIndexList
	220
	221	Input:
	222	channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
	223
	224	Affected:
	225	self.dataOutObj.data
	226	self.dataOutObj.channelIndexList
	227	self.dataOutObj.nChannels
	228	self.dataOutObj.m_ProcessingHeader.totalSpectra
	229	self.dataOutObj.systemHeaderObj.numChannels
	230	self.dataOutObj.m_ProcessingHeader.blockSize
	231
	232	Return:
	233	None
	234	"""
	235
	236	for channel in channelIndexList:
	237	if channel not in self.dataOutObj.channelIndexList:
	238	raise ValueError, "The value %d in channelIndexList is not valid" %channel
	239
	240	nChannels = len(channelIndexList)
	241
	242	data = self.dataOutObj.data[channelIndexList,:]
	243
	244	self.dataOutObj.data = data
	245	self.dataOutObj.channelIndexList = channelIndexList
	246	self.dataOutObj.channelList = [self.dataOutObj.channelList[i] for i in channelIndexList]
	247	self.dataOutObj.nChannels = nChannels
	248
	249	return 1
	250
	251	class CohInt(Operation):
	252
	253	__profIndex = 0
	254	__withOverapping = False
	255
	256	__byTime = False
	257	__initime = None
	258	__integrationtime = None
	259
	260	__buffer = None
	261
	262	__dataReady = False
	263
	264	nCohInt = None
	265
	266
	267	def __init__(self):
	268
	269	pass
	270
	271	def setup(self, nCohInt=None, timeInterval=None, overlapping=False):
	272	"""
	273	Set the parameters of the integration class.
	274
	275	Inputs:
	276
	277	nCohInt : Number of coherent integrations
	278	timeInterval : Time of integration. If the parameter "nCohInt" is selected this one does not work
	279	overlapping :
	280
	281	"""
	282
	283	self.__initime = None
	284	self.__buffer = None
	285	self.__dataReady = False
	286
	287
	288	if nCohInt == None and timeInterval == None:
	289	raise ValueError, "nCohInt or timeInterval should be specified ..."
	290
	291	if nCohInt != None:
	292	self.nCohInt = nCohInt
	293	self.__byTime = False
	294	else:
	295	self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
	296	self.nCohInt = 9999
	297	self.__byTime = True
	298
	299	if overlapping:
	300	self.__withOverapping = True
	301	self.__buffer = None
	302	else:
	303	self.__withOverapping = False
	304	self.__buffer = 0
	305
	306	self.__profIndex = 0
	307
	308	def putData(self, data):
	309
	310	"""
	311	Add a profile to the __buffer and increase in one the __profileIndex
	312
	313	"""
	314	if self.__initime == None:
	315	self.__initime = datatime
	316
	317	if not self.__withOverapping:
	318	self.__buffer += data
	319	self.__profIndex += 1
	320	return
	321
	322	#Overlapping data
	323	nChannels, nHeis = data.shape
	324	data = numpy.reshape(data, (1, nChannels, nHeis))
	325
	326	#If the buffer is empty then it takes the data value
	327	if self.__buffer == None:
	328	self.__buffer = data
	329	self.__profIndex += 1
	330	return
	331
	332	#If the buffer length is lower than nCohInt then stakcing the data value
	333	if self.__profIndex < self.nCohInt:
	334	self.__buffer = numpy.vstack((self.__buffer, data))
	335	self.__profIndex += 1
	336	return
	337
	338	#If the buffer length is equal to nCohInt then replacing the last buffer value with the data value
	339	self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
	340	self.__buffer[self.nCohInt-1] = data
	341	self.__profIndex = self.nCohInt
	342	return
	343
	344
	345	def pushData(self):
	346	"""
	347	Return the sum of the last profiles and the profiles used in the sum.
	348
	349	Affected:
	350
	351	self.__profileIndex
	352
	353	"""
	354
	355	self.__initime = None
	356
	357	if not self.__withOverapping:
	358	data = self.__buffer
	359	nCohInt = self.__profIndex
	360
	361	self.__buffer = 0
	362	self.__profIndex = 0
	363
	364	return data, nCohInt
	365
	366	#Integration with Overlapping
	367	data = numpy.sum(self.__buffer, axis=0)
	368	nCohInt = self.__profIndex
	369
	370	return data, nCohInt
	371
	372	def byProfiles(self, data):
	373
	374	self.__dataReady = False
	375	avg_data = None
	376
	377	self.putData(data)
	378
	379	if self.__profIndex == self.nCohInt:
	380
	381	avgdata, nCohInt = self.pushData()
	382	self.__dataReady = True
	383
	384	return avgdata, nCohInt
	385
	386	def byTime(self, data, datatime):
	387
	388	self.__dataReady = False
	389	avg_data = None
	390
	391	self.putData(data)
	392
	393	if (datatime - self.__initime) >= self.__integrationtime:
	394	avgdata, nCohInt = self.pushData()
	395	self.nCohInt = nCohInt
	396	self.__dataReady = True
	397
	398	return avgdata, nCohInt
	399
	400	def integrate(self, data, datatime=None):
	401
	402	if not self.__byTime:
	403	avg_data = self.byProfiles(data)
	404	else:
	405	avg_data = self.byTime(data, datatime)
	406
	407	self.data = avg_data
	408
	409
	410	def run(self, dataOut, nCohInt=None, timeInterval=None, overlapping=False):
	411
	412
	413	# self.dataOutObj.timeInterval *= nCohInt
	414	self.dataOutObj.flagNoData = True
	415
	416	if myCohIntObj.__dataReady:
	417	self.dataOutObj.data = myCohIntObj.data
	418	self.dataOutObj.timeInterval *= myCohIntObj.nCohInt
	419	self.dataOutObj.nCohInt = myCohIntObj.nCohInt * self.dataInObj.nCohInt
	420	self.dataOutObj.utctime = myCohIntObj.firstdatatime
	421	self.dataOutObj.flagNoData = False
	422
	423	return avg_data No newline at end of file

schainpy/TestSpectraHeis.py created 644 +104 0

@@ -0,0 +1,104
	1	'''
	2	Created on Jul 31, 2012
	3
	4	@author $Author$
	5	@version $Id$
	6	'''
	7
	8	import os, sys
	9	import time, datetime
	10	#import pylab as pl
	11
	12	from Data.JROData import Voltage
	13	from IO.VoltageIO import *
	14
	15	from Data.JROData import SpectraHeis
	16	from IO.SpectraIO import *
	17
	18	from Processing.VoltageProcessor import *
	19	from Processing.SpectraProcessor import *
	20
	21	#from Graphics.BaseGraph_mpl import LinearPlot
	22
	23	class TestHeis():
	24	i=None
	25	def __init__(self):
	26	self.setValues()
	27	self.createObjects()
	28	self.testSChain()
	29	self.i=0
	30
	31	def setValues( self ):
	32
	33	self.path="/home/roj-idl71/data"
	34	self.path = "/Data/Data/RAWDATA/ASTRONOMIA"
	35
	36	#self.path = ""
	37	self.startDate = datetime.date(2012,4,1)
	38	self.endDate = datetime.date(2012,12,30)
	39
	40	self.startTime = datetime.time(0,0,0)
	41	self.endTime = datetime.time(23,0,0)
	42
	43
	44	def createObjects( self ):
	45
	46	self.readerObj = VoltageReader()
	47	self.specProcObj = SpectraHeisProcessor()
	48
	49	self.voltObj1 = self.readerObj.setup(
	50	path = self.path,
	51	startDate = self.startDate,
	52	endDate = self.endDate,
	53	startTime = self.startTime,
	54	endTime = self.endTime,
	55	expLabel = '',
	56	online = 1)
	57
	58	if not(self.voltObj1):
	59	sys.exit(0)
	60
	61	self.specObj1 = self.specProcObj.setup(dataInObj = self.voltObj1,nFFTPoints=self.voltObj1.nHeights)
	62
	63
	64	#
	65
	66	#
	67
	68	def testSChain( self ):
	69
	70	ini = time.time()
	71	counter = 0
	72	while(True):
	73	self.readerObj.getData()
	74	self.specProcObj.init()
	75
	76	self.specProcObj.integrator(N=32) ## return self.dataOutObj
	77
	78
	79
	80
	81	self.specProcObj.plotScope(idfigure=1,
	82	wintitle='test plot library',
	83	driver='plplot',
	84	minvalue = 30000.0,
	85	maxvalue = 5000000.0,
	86	save=False,
	87	gpath="/home/roj-idl71/PlotImage")
	88
	89
	90	if self.readerObj.flagNoMoreFiles:
	91	break
	92
	93
	94
	95	if self.readerObj.flagIsNewBlock:
	96	print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
	97	datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
	98
	99
	100
	101	if __name__ == '__main__':
	102	TestHeis()
	103
	104	No newline at end of file

schainpy/testSchainExp.py created 644 +120 0

@@ -0,0 +1,120
	1	'''
	2
	3	$Author: murco $
	4	$Id: testSchainExp.py 158 2012-11-08 21:31:03Z murco $
	5	'''
	6	import os, sys
	7	import time, datetime
	8
	9	path = os.path.split(os.getcwd())[0]
	10	sys.path.append(path)
	11
	12	from Data.JROData import Voltage
	13	from IO.VoltageIO import *
	14
	15	from Processing.VoltageProcessor import *
	16	from Processing.SpectraProcessor import *
	17
	18	class TestSChain():
	19
	20	def __init__(self):
	21	self.setValues()
	22	self.createObjects()
	23	self.testSChain()
	24
	25	def setValues(self):
	26	self.path = "/home/roj-idl71/Data/RAWDATA/Meteors"
	27	self.path = "/remote/puma/2012_06/Meteors"
	28
	29	self.startDate = datetime.date(2012,06,19)
	30	self.endDate = datetime.date(2012,12,30)
	31
	32	self.startTime = datetime.time(11,0,0)
	33	self.endTime = datetime.time(23,59,59)
	34
	35	self.nFFTPoints = 32
	36
	37	self.wrpath = "/home/roj-idl71/tmp/results"
	38	self.profilesPerBlock = 40
	39	self.blocksPerFile = 50
	40
	41	def createObjects(self):
	42
	43	self.readerObj = VoltageReader()
	44	self.voltProcObj = VoltageProcessor()
	45	self.specProcObj = SpectraProcessor()
	46
	47	self.voltObj1 = self.readerObj.setup(
	48	path = self.path,
	49	startDate = self.startDate,
	50	endDate = self.endDate,
	51	startTime = self.startTime,
	52	endTime = self.endTime,
	53	expLabel = '',
	54	online = True)
	55
	56	self.voltObj2 = self.voltProcObj.setup(dataInObj = self.voltObj1)
	57	self.specObj1 = self.specProcObj.setup(dataInObj = self.voltObj2, nFFTPoints = self.nFFTPoints)
	58
	59	def testSChain(self):
	60
	61	ini = time.time()
	62
	63	while(True):
	64	self.readerObj.getData()
	65
	66	self.voltProcObj.init()
	67
	68	self.voltProcObj.integrator(25, overlapping=False)
	69	#
	70	# self.voltProcObj.writeData(self.wrpath,self.profilesPerBlock,self.blocksPerFile)
	71	self.voltProcObj.selectChannels([0,1,2])
	72
	73	# self.voltProcObj.plotScope(idfigure=0,
	74	# wintitle='test plot library',
	75	# driver='plplot',
	76	# save=False,
	77	# gpath=None,
	78	# type="power")
	79
	80	# self.voltProcObj.plotRti(idfigure=1,
	81	# starttime=self.startTime,
	82	# endtime=self.endTime,
	83	# minvalue=0,
	84	# maxvalue=50,
	85	# wintitle='',
	86	# driver='plplot',
	87	# colormap='jet',
	88	# colorbar=True,
	89	# showprofile=False,
	90	# xrangestep=2,
	91	# save=False,
	92	# gpath=None)
	93	#
	94	# if self.voltProcObj.dataOutObj.flagNoData ==False:
	95	# print self.readerObj.dataOutObj.nProfiles
	96
	97	self.specProcObj.init()
	98
	99	self.specProcObj.plotSpc(idfigure=2,
	100	minvalue=30,
	101	maxvalue=70,
	102	wintitle='Spectra',
	103	driver='plplot',
	104	colormap='jet',
	105	colorbar=True,
	106	showprofile=True,
	107	save=False,
	108	gpath=None)
	109
	110	if self.readerObj.flagNoMoreFiles:
	111	break
	112
	113	if self.readerObj.flagIsNewBlock:
	114	# print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks, datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
	115	print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
	116	datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc + self.readerObj.basicHeaderObj.miliSecond/1000.0),)
	117
	118
	119	if __name__ == '__main__':
	120	TestSChain() No newline at end of file

schainpy/testSchainSpecExp.py created 644 +85 0

@@ -0,0 +1,85
	1	'''
	2
	3	$Author: murco $
	4	$Id: testSchainSpecExp.py 147 2012-10-30 22:50:56Z murco $
	5	'''
	6
	7	import os, sys
	8	import time, datetime
	9
	10	path = os.path.split(os.getcwd())[0]
	11	sys.path.append(path)
	12
	13
	14	from Data.JROData import Spectra
	15	from IO.SpectraIO import *
	16	from Processing.SpectraProcessor import *
	17
	18
	19
	20	class TestSChain:
	21
	22	def __init__(self):
	23	self.setValues()
	24	self.createObjects()
	25	self.testSChain()
	26
	27	def setValues(self):
	28	# self.path = "/Users/jro/Documents/RadarData/MST_ISR/MST"
	29	## self.path = "/home/roj-idl71/Data/RAWDATA/IMAGING"
	30	# self.path = "/Users/danielangelsuarezmunoz/Data/EW_Drifts"
	31	# self.path = "/Users/danielangelsuarezmunoz/Data/IMAGING"
	32	self.path = "/home/daniel/RadarData/IMAGING"
	33
	34	self.startDate = datetime.date(2012,3,1)
	35	self.endDate = datetime.date(2012,3,30)
	36
	37	self.startTime = datetime.time(0,0,0)
	38	self.endTime = datetime.time(14,1,1)
	39
	40	# paramatros para Escritura de Pdata
	41	self.wrpath = "/home/daniel/RadarData/test_wr2"
	42	self.blocksPerFile = 5
	43
	44
	45
	46	def createObjects(self):
	47
	48	self.readerObj = SpectraReader()
	49
	50	self.specObj1 = self.readerObj.setup(
	51	path = self.path,
	52	startDate = self.startDate,
	53	endDate = self.endDate,
	54	startTime = self.startTime,
	55	endTime = self.endTime,
	56	expLabel = '',
	57	online = 0)
	58
	59	self.specObjProc = SpectraProcessor()
	60
	61	self.specObj2 = self.specObjProc.setup(dataInObj = self.specObj1)
	62
	63
	64
	65	def testSChain(self):
	66
	67	ini = time.time()
	68
	69	while(True):
	70	self.readerObj.getData()
	71
	72	self.specObjProc.init()
	73
	74	self.specObjProc.writeData(self.wrpath,self.blocksPerFile)
	75	#
	76	if self.readerObj.flagNoMoreFiles:
	77	break
	78
	79	if self.readerObj.flagIsNewBlock:
	80	print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
	81	datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc))
	82
	83
	84	if __name__ == '__main__':
	85	TestSChain() No newline at end of file

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