schain-jc Commit - r197:77188df611db

Controlador de Signal Chain finalizado....

Miguel Valdez -

r197:77188df611db

parent child

Context file:

r197:77188df611db

Collapse all files

schainpy/schain.py created 644 +609 0

This diff has been collapsed as it changes many lines, (609 lines changed) Show them Hide them
	@@ -0,0 +1,609
		1	'''
		2	Created on September , 2012
		3	@author:
		4	'''
		5	from xml.etree.ElementTree import Element, SubElement, ElementTree
		6	from xml.etree import ElementTree as ET
		7	from xml.dom import minidom
		8
		9	import sys
		10	import datetime
		11	from model.jrodataIO import *
		12	from model.jroprocessing import *
		13
		14	def prettify(elem):
		15	"""Return a pretty-printed XML string for the Element.
		16	"""
		17	rough_string = ET.tostring(elem, 'utf-8')
		18	reparsed = minidom.parseString(rough_string)
		19	return reparsed.toprettyxml(indent=" ")
		20
		21	class ParameterConf():
		22
		23	id = None
		24	name = None
		25	value = None
		26	type = None
		27
		28	ELEMENTNAME = 'Parameter'
		29
		30	def __init__(self):
		31
		32	self.type = 'str'
		33
		34	def getElementName(self):
		35
		36	return self.ELEMENTNAME
		37
		38	def getValue(self):
		39
		40	if self.type == 'list':
		41	strList = self.value.split(',')
		42	return strList
		43
		44	if self.type == 'intlist':
		45	strList = self.value.split(',')
		46	intList = [int(x) for x in strList]
		47	return intList
		48
		49	if self.type == 'floatlist':
		50	strList = self.value.split(',')
		51	floatList = [float(x) for x in strList]
		52	return floatList
		53
		54	if self.type == 'date':
		55	strList = self.value.split('/')
		56	intList = [int(x) for x in strList]
		57	date = datetime.date(intList[0], intList[1], intList[2])
		58	return date
		59
		60	if self.type == 'time':
		61	strList = self.value.split(':')
		62	intList = [int(x) for x in strList]
		63	time = datetime.time(intList[0], intList[1], intList[2])
		64	return time
		65
		66	func = eval(self.type)
		67
		68	return func(self.value)
		69
		70	def setup(self, id, name, value, type='str'):
		71
		72	self.id = id
		73	self.name = name
		74	self.value = str(value)
		75	self.type = type
		76
		77	def makeXml(self, opElement):
		78
		79	parmElement = SubElement(opElement, self.ELEMENTNAME)
		80	parmElement.set('id', str(self.id))
		81	parmElement.set('name', self.name)
		82	parmElement.set('value', self.value)
		83	parmElement.set('type', self.type)
		84
		85	def readXml(self, parmElement):
		86
		87	self.id = parmElement.get('id')
		88	self.name = parmElement.get('name')
		89	self.value = parmElement.get('value')
		90	self.type = parmElement.get('type')
		91
		92	def printattr(self):
		93
		94	print "Parameter[%s]: name = %s, value = %s, type = %s" %(self.id, self.name, self.value, self.type)
		95
		96	class OperationConf():
		97
		98	id = None
		99	name = None
		100	priority = None
		101	type = None
		102
		103	parmConfObjList = []
		104
		105	ELEMENTNAME = 'Operation'
		106
		107	def __init__(self):
		108
		109	id = 0
		110	name = None
		111	priority = None
		112	type = 'self'
		113
		114
		115	def __getNewId(self):
		116
		117	return int(self.id)*10 + len(self.parmConfObjList) + 1
		118
		119	def getElementName(self):
		120
		121	return self.ELEMENTNAME
		122
		123	def getParameterObjList(self):
		124
		125	return self.parmConfObjList
		126
		127	def setup(self, id, name, priority, type):
		128
		129	self.id = id
		130	self.name = name
		131	self.type = type
		132	self.priority = priority
		133
		134	self.parmConfObjList = []
		135
		136	def addParameter(self, name, value, type='str'):
		137
		138	id = self.__getNewId()
		139
		140	parmConfObj = ParameterConf()
		141	parmConfObj.setup(id, name, value, type)
		142
		143	self.parmConfObjList.append(parmConfObj)
		144
		145	return parmConfObj
		146
		147	def makeXml(self, upElement):
		148
		149	opElement = SubElement(upElement, self.ELEMENTNAME)
		150	opElement.set('id', str(self.id))
		151	opElement.set('name', self.name)
		152	opElement.set('type', self.type)
		153	opElement.set('priority', str(self.priority))
		154
		155	for parmConfObj in self.parmConfObjList:
		156	parmConfObj.makeXml(opElement)
		157
		158	def readXml(self, opElement):
		159
		160	self.id = opElement.get('id')
		161	self.name = opElement.get('name')
		162	self.type = opElement.get('type')
		163	self.priority = opElement.get('priority')
		164
		165	self.parmConfObjList = []
		166
		167	parmElementList = opElement.getiterator(ParameterConf().getElementName())
		168
		169	for parmElement in parmElementList:
		170	parmConfObj = ParameterConf()
		171	parmConfObj.readXml(parmElement)
		172	self.parmConfObjList.append(parmConfObj)
		173
		174	def printattr(self):
		175
		176	print "%s[%s]: name = %s, type = %s, priority = %s" %(self.ELEMENTNAME,
		177	self.id,
		178	self.name,
		179	self.type,
		180	self.priority)
		181
		182	for parmConfObj in self.parmConfObjList:
		183	parmConfObj.printattr()
		184
		185	def createObject(self):
		186
		187	if self.type == 'self':
		188	raise ValueError, "This operation type cannot be created"
		189
		190	if self.type == 'other':
		191	className = eval(self.name)
		192	opObj = className()
		193
		194	return opObj
		195
		196	class ProcUnitConf():
		197
		198	id = None
		199	name = None
		200	type = None
		201	inputId = None
		202
		203	opConfObjList = []
		204
		205	procUnitObj = None
		206	opObjList = []
		207
		208	ELEMENTNAME = 'ProcUnit'
		209
		210	def __init__(self):
		211
		212	self.id = None
		213	self.type = None
		214	self.name = None
		215	self.inputId = None
		216
		217	self.opConfObjList = []
		218
		219	self.procUnitObj = None
		220	self.opObjDict = {}
		221
		222	def __getPriority(self):
		223
		224	return len(self.opConfObjList)+1
		225
		226	def __getNewId(self):
		227
		228	return int(self.id)*10 + len(self.opConfObjList) + 1
		229
		230	def getElementName(self):
		231
		232	return self.ELEMENTNAME
		233
		234	def getId(self):
		235
		236	return str(self.id)
		237
		238	def getInputId(self):
		239
		240	return str(self.inputId)
		241
		242	def getOperationObjList(self):
		243
		244	return self.opConfObjList
		245
		246	def getProcUnitObj(self):
		247
		248	return self.procUnitObj
		249
		250	def setup(self, id, name, type, inputId):
		251
		252	self.id = id
		253	self.name = name
		254	self.type = type
		255	self.inputId = inputId
		256
		257	self.opConfObjList = []
		258
		259	self.addOperation(name='init', optype='self')
		260
		261	def addOperation(self, name, optype='self'):
		262
		263	id = self.__getNewId()
		264	priority = self.__getPriority()
		265
		266	opConfObj = OperationConf()
		267	opConfObj.setup(id, name=name, priority=priority, type=optype)
		268
		269	self.opConfObjList.append(opConfObj)
		270
		271	return opConfObj
		272
		273	def makeXml(self, procUnitElement):
		274
		275	upElement = SubElement(procUnitElement, self.ELEMENTNAME)
		276	upElement.set('id', str(self.id))
		277	upElement.set('name', self.name)
		278	upElement.set('type', self.type)
		279	upElement.set('inputId', str(self.inputId))
		280
		281	for opConfObj in self.opConfObjList:
		282	opConfObj.makeXml(upElement)
		283
		284	def readXml(self, upElement):
		285
		286	self.id = upElement.get('id')
		287	self.name = upElement.get('name')
		288	self.type = upElement.get('type')
		289	self.inputId = upElement.get('inputId')
		290
		291	self.opConfObjList = []
		292
		293	opElementList = upElement.getiterator(OperationConf().getElementName())
		294
		295	for opElement in opElementList:
		296	opConfObj = OperationConf()
		297	opConfObj.readXml(opElement)
		298	self.opConfObjList.append(opConfObj)
		299
		300	def printattr(self):
		301
		302	print "%s[%s]: name = %s, type = %s, inputId = %s" %(self.ELEMENTNAME,
		303	self.id,
		304	self.name,
		305	self.type,
		306	self.inputId)
		307
		308	for opConfObj in self.opConfObjList:
		309	opConfObj.printattr()
		310
		311	def createObjects(self):
		312
		313	className = eval(self.name)
		314	procUnitObj = className()
		315
		316	for opConfObj in self.opConfObjList:
		317
		318	if opConfObj.type == 'self':
		319	continue
		320
		321	opObj = opConfObj.createObject()
		322
		323	self.opObjDict[opConfObj.id] = opObj
		324	procUnitObj.addOperation(opObj, opConfObj.id)
		325
		326	self.procUnitObj = procUnitObj
		327
		328	return procUnitObj
		329
		330	def run(self):
		331
		332	for opConfObj in self.opConfObjList:
		333	kwargs = {}
		334	for parmConfObj in opConfObj.getParameterObjList():
		335	kwargs[parmConfObj.name] = parmConfObj.getValue()
		336
		337	self.procUnitObj.call(opConfObj, **kwargs)
		338
		339
		340
		341	class ReadUnitConf(ProcUnitConf):
		342
		343
		344	path = None
		345	startDate = None
		346	endDate = None
		347	startTime = None
		348	endTime = None
		349	online = None
		350	expLabel = None
		351	delay = None
		352
		353	ELEMENTNAME = 'ReadUnit'
		354
		355	def __init__(self):
		356
		357	self.id = None
		358	self.type = None
		359	self.name = None
		360	self.inputId = 0
		361
		362	self.opConfObjList = []
		363	self.opObjList = []
		364
		365	def getElementName(self):
		366
		367	return self.ELEMENTNAME
		368
		369	def setup(self, id, name, type, path, startDate, endDate, startTime, endTime, online=0, expLabel='', delay=60):
		370
		371	self.id = id
		372	self.name = name
		373	self.type = type
		374
		375	self.path = path
		376	self.startDate = startDate
		377	self.endDate = endDate
		378	self.startTime = startTime
		379	self.endTime = endTime
		380	self.online = online
		381	self.expLabel = expLabel
		382	self.delay = delay
		383
		384	self.addRunOperation()
		385
		386	def addRunOperation(self):
		387
		388	opObj = self.addOperation(name = 'run', optype = 'self')
		389
		390	opObj.addParameter(name='path' , value=self.path, type='str')
		391	opObj.addParameter(name='startDate' , value=self.startDate, type='date')
		392	opObj.addParameter(name='endDate' , value=self.endDate, type='date')
		393	opObj.addParameter(name='startTime' , value=self.startTime, type='time')
		394	opObj.addParameter(name='endTime' , value=self.endTime, type='time')
		395	opObj.addParameter(name='expLabel' , value=self.expLabel, type='str')
		396	opObj.addParameter(name='online' , value=self.online, type='bool')
		397	opObj.addParameter(name='delay' , value=self.delay, type='float')
		398
		399	return opObj
		400
		401
		402	class Controller():
		403
		404	id = None
		405	name = None
		406	description = None
		407	# readUnitConfObjList = None
		408	procUnitConfObjDict = None
		409
		410	ELEMENTNAME = 'Controller'
		411
		412	def __init__(self):
		413
		414	self.id = None
		415	self.name = None
		416	self.description = None
		417
		418	# self.readUnitConfObjList = []
		419	self.procUnitConfObjDict = {}
		420
		421	def __getNewId(self):
		422
		423	id = int(self.id)*10 + len(self.procUnitConfObjDict) + 1
		424
		425	return str(id)
		426
		427	def getElementName(self):
		428
		429	return self.ELEMENTNAME
		430
		431	def setup(self, id, name, description):
		432
		433	self.id = id
		434	self.name = name
		435	self.description = description
		436
		437	def addReadUnit(self, type, path, startDate='', endDate='', startTime='', endTime='', online=0, expLabel='', delay=60):
		438
		439	id = self.__getNewId()
		440	name = '%sReader' %(type)
		441
		442	readUnitConfObj = ReadUnitConf()
		443	readUnitConfObj.setup(id, name, type, path, startDate, endDate, startTime, endTime, online, expLabel, delay)
		444
		445	self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
		446
		447	return readUnitConfObj
		448
		449	def addProcUnit(self, type, inputId):
		450
		451	id = self.__getNewId()
		452	name = '%sProc' %(type)
		453
		454	procUnitConfObj = ProcUnitConf()
		455	procUnitConfObj.setup(id, name, type, inputId)
		456
		457	self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
		458
		459	return procUnitConfObj
		460
		461	def makeXml(self):
		462
		463	projectElement = Element('Controller')
		464	projectElement.set('id', str(self.id))
		465	projectElement.set('name', self.name)
		466	projectElement.set('description', self.description)
		467
		468	# for readUnitConfObj in self.readUnitConfObjList:
		469	# readUnitConfObj.makeXml(projectElement)
		470
		471	for procUnitConfObj in self.procUnitConfObjDict.values():
		472	procUnitConfObj.makeXml(projectElement)
		473
		474	self.projectElement = projectElement
		475
		476	def writeXml(self, filename):
		477
		478	self.makeXml()
		479
		480	print prettify(self.projectElement)
		481
		482	ElementTree(self.projectElement).write(filename, method='xml')
		483
		484	def readXml(self, filename):
		485
		486	#tree = ET.parse(filename)
		487	self.projectElement = None
		488	# self.readUnitConfObjList = []
		489	self.procUnitConfObjDict = {}
		490
		491	self.projectElement = ElementTree().parse(filename)
		492
		493	self.project = self.projectElement.tag
		494
		495	self.id = self.projectElement.get('id')
		496	self.name = self.projectElement.get('name')
		497	self.description = self.projectElement.get('description')
		498
		499	readUnitElementList = self.projectElement.getiterator(ReadUnitConf().getElementName())
		500
		501	for readUnitElement in readUnitElementList:
		502	readUnitConfObj = ReadUnitConf()
		503	readUnitConfObj.readXml(readUnitElement)
		504
		505	self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
		506
		507	procUnitElementList = self.projectElement.getiterator(ProcUnitConf().getElementName())
		508
		509	for procUnitElement in procUnitElementList:
		510	procUnitConfObj = ProcUnitConf()
		511	procUnitConfObj.readXml(procUnitElement)
		512
		513	self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
		514
		515	def printattr(self):
		516
		517	print "Controller[%s]: name = %s, description = %s" %(self.id,
		518	self.name,
		519	self.description)
		520
		521	# for readUnitConfObj in self.readUnitConfObjList:
		522	# readUnitConfObj.printattr()
		523
		524	for procUnitConfObj in self.procUnitConfObjDict.values():
		525	procUnitConfObj.printattr()
		526
		527	def createObjects(self):
		528
		529	# for readUnitConfObj in self.readUnitConfObjList:
		530	# readUnitConfObj.createObjects()
		531
		532	for procUnitConfObj in self.procUnitConfObjDict.values():
		533	procUnitConfObj.createObjects()
		534
		535	def __connect(self, objIN, obj):
		536
		537	obj.setInput(objIN.getOutput())
		538
		539	def connectObjects(self):
		540
		541	for puConfObj in self.procUnitConfObjDict.values():
		542
		543	inputId = puConfObj.getInputId()
		544
		545	if int(inputId) == 0:
		546	continue
		547
		548	puConfINObj = self.procUnitConfObjDict[inputId]
		549
		550	puObj = puConfObj.getProcUnitObj()
		551	puINObj = puConfINObj.getProcUnitObj()
		552
		553	self.__connect(puINObj, puObj)
		554
		555	def run(self):
		556
		557	# for readUnitConfObj in self.readUnitConfObjList:
		558	# readUnitConfObj.run()
		559	while(True):
		560	for procUnitConfObj in self.procUnitConfObjDict.values():
		561	procUnitConfObj.run()
		562
		563	if __name__ == '__main__':
		564
		565	desc = "Segundo Test"
		566	filename = "schain.xml"
		567
		568	controllerObj = Controller()
		569
		570	controllerObj.setup(id = '191', name='test01', description=desc)
		571
		572	readUnitConfObj = controllerObj.addReadUnit(type='Voltage',
		573	path='/home/roj-idl71/Data/RAWDATA/Meteors',
		574	startDate='2012/01/01',
		575	endDate='2012/12/31',
		576	startTime='00:00:00',
		577	endTime='23:59:59',
		578	online=0)
		579
		580	procUnitConfObj1 = controllerObj.addProcUnit(type='Voltage', inputId=readUnitConfObj.getId())
		581
		582	procUnitConfObj2 = controllerObj.addProcUnit(type='Voltage', inputId=procUnitConfObj1.getId())
		583
		584	opObj11 = procUnitConfObj1.addOperation(name='selectChannels')
		585	opObj11.addParameter(name='channelList', value='1,2', type='intlist')
		586
		587	# opObj12 = procUnitConfObj1.addOperation(name='decoder')
		588	# opObj12.addParameter(name='ncode', value='2', type='int')
		589	# opObj12.addParameter(name='nbauds', value='8', type='int')
		590	# opObj12.addParameter(name='code0', value='001110011', type='int')
		591	# opObj12.addParameter(name='code1', value='001110011', type='int')
		592
		593	opObj21 = procUnitConfObj2.addOperation(name='CohInt', optype='other')
		594	opObj21.addParameter(name='nCohInt', value='10', type='int')
		595
		596
		597	print "Escribiendo el archivo XML"
		598
		599	controllerObj.writeXml(filename)
		600
		601	print "Leyendo el archivo XML"
		602	controllerObj.readXml(filename)
		603	#controllerObj.printattr()
		604
		605	controllerObj.createObjects()
		606	controllerObj.connectObjects()
		607	controllerObj.run()
		608
		609	No newline at end of file

schainpy/schain.xml created 644 +1 0

	@@ -0,0 +1,1
				1	<Controller description="Segundo Test" id="191" name="test01"><ReadUnit id="1911" inputId="0" name="VoltageReader" type="Voltage"><Operation id="19111" name="run" priority="1" type="self"><Parameter id="191111" name="path" type="str" value="/home/roj-idl71/Data/RAWDATA/Meteors" /><Parameter id="191112" name="startDate" type="date" value="2012/01/01" /><Parameter id="191113" name="endDate" type="date" value="2012/12/31" /><Parameter id="191114" name="startTime" type="time" value="00:00:00" /><Parameter id="191115" name="endTime" type="time" value="23:59:59" /><Parameter id="191116" name="expLabel" type="str" value="" /><Parameter id="191117" name="online" type="bool" value="0" /><Parameter id="191118" name="delay" type="float" value="60" /></Operation></ReadUnit><ProcUnit id="1913" inputId="1912" name="VoltageProc" type="Voltage"><Operation id="19131" name="init" priority="1" type="self" /><Operation id="19132" name="CohInt" priority="2" type="other"><Parameter id="191321" name="nCohInt" type="int" value="10" /></Operation></ProcUnit><ProcUnit id="1912" inputId="1911" name="VoltageProc" type="Voltage"><Operation id="19121" name="init" priority="1" type="self" /><Operation id="19122" name="selectChannels" priority="2" type="self"><Parameter id="191221" name="channelList" type="intlist" value="1,2" /></Operation></ProcUnit></Controller> No newline at end of file

schainpy/model/graphics/__init__.py ~~schainpy/graphics/__init__.py~~ renamed 0 0

NO CONTENT: file renamed from schainpy/graphics/__init__.py to schainpy/model/graphics/__init__.py

schainpy/model/graphics/figure.py ~~schainpy/graphics/figure.py~~ renamed 0 0

NO CONTENT: file renamed from schainpy/graphics/figure.py to schainpy/model/graphics/figure.py

schainpy/model/graphics/mpldriver.py ~~schainpy/graphics/mpldriver.py~~ renamed +2 -2

             import matplotlib
-            matplotlib.use("TKAgg")
+            matplotlib.use("Agg")
             import matplotlib.pyplot
-            import scitools.numpyutils
+            #import scitools.numpyutils
             from mpl_toolkits.axes_grid1 import make_axes_locatable
             def init(idfigure, wintitle, width, height):
                 matplotlib.pyplot.ioff()
                 fig = matplotlib.pyplot.matplotlib.pyplot.figure(num=idfigure, facecolor="w")
                 fig.canvas.manager.set_window_title(wintitle)
                 fig.canvas.manager.resize(width,height)
                 matplotlib.pyplot.ion()
                 return fig
             def setWinTitle(fig, title):
                 fig.canvas.manager.set_window_title(title)
             def setTextFromAxes(idfigure, ax, title):
                 fig = matplotlib.pyplot.figure(idfigure)
                 ax.annotate(title, xy=(.1, .99),
                             xycoords='figure fraction',
                             horizontalalignment='left', verticalalignment='top',
                             fontsize=10)
             def setTitle(idfigure, title):
                 fig = matplotlib.pyplot.figure(idfigure)
                 fig.suptitle(title)
             def makeAxes(idfigure, nrow, ncol, xpos, ypos, colspan, rowspan):
                 fig = matplotlib.pyplot.figure(idfigure)
                 ax = matplotlib.pyplot.subplot2grid((nrow, ncol), (xpos, ypos), colspan=colspan, rowspan=rowspan)
                 return ax
             def pline(ax, x, y, xmin, xmax, ymin, ymax, xlabel, ylabel, title, firsttime):
                 if firsttime:
                     ax.plot(x, y)
                     ax.set_xlim([xmin,xmax])
                     ax.set_ylim([ymin,ymax])
                     ax.set_xlabel(xlabel, size=8)
                     ax.set_ylabel(ylabel, size=8)
                     ax.set_title(title, size=10)
                     matplotlib.pyplot.tight_layout()
                 else:
                     ax.lines[0].set_data(x,y)
             def draw(idfigure):
                 fig = matplotlib.pyplot.figure(idfigure)
                 fig.canvas.draw()
             def pcolor(ax, x, y, z, xmin, xmax, ymin, ymax, zmin, zmax, xlabel, ylabel, title, firsttime, mesh):
                 if firsttime:
                     divider = make_axes_locatable(ax)
                     ax_cb = divider.new_horizontal(size="5%", pad=0.05)
                     fig1 = ax.get_figure()
                     fig1.add_axes(ax_cb)
                     ax.set_xlim([xmin,xmax])
                     ax.set_ylim([ymin,ymax])
                     ax.set_xlabel(xlabel)
                     ax.set_ylabel(ylabel)
                     ax.set_title(title)
                     imesh=ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax)
                     matplotlib.pyplot.colorbar(imesh, cax=ax_cb)
                     ax_cb.yaxis.tick_right()
                     for tl in ax_cb.get_yticklabels():
                         tl.set_visible(True)
                     ax_cb.yaxis.tick_right()
                     matplotlib.pyplot.tight_layout()
                     return imesh
                 else:
                     z = z.T
                     z = z[0:-1,0:-1]
                     mesh.set_array(z.ravel())
                     return mesh
   No newline at end of file

schainpy/model/jrodataIO.py +77 -74

             '''
             $Author: murco $
             $Id: JRODataIO.py 169 2012-11-19 21:57:03Z murco $
             '''
             import os, sys
             import glob
             import time
             import numpy
             import fnmatch
             import time, datetime
             from jrodata import *
             from jroheaderIO import *
+            from jroprocessing import *
             def isNumber(str):
                 """
                 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
                 Excepciones:
                     Si un determinado string no puede ser convertido a numero
                 Input:
                     str, string al cual se le analiza para determinar si convertible a un numero o no
                 Return:
                     True    :    si el string es uno numerico
                     False   :    no es un string numerico
                 """
                 try:
                     float( str )
                     return True
                 except:
                     return False
             def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
                 """
                 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startUTSeconds      :    fecha inicial del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                     endUTSeconds        :    fecha final del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 basicHeaderObj = BasicHeader()
                 try:
                     fp = open(filename,'rb')
                 except:
                     raise IOError, "The file %s can't be opened" %(filename)
                 sts = basicHeaderObj.read(fp)
                 fp.close()
                 if not(sts):
                     print "Skipping the file %s because it has not a valid header" %(filename)
                     return 0
                 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
                     return 0
                 return 1
             def getlastFileFromPath(path, ext):
                 """
                 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
                 al final de la depuracion devuelve el ultimo file de la lista que quedo.
                 Input:
                     fileList    :    lista conteniendo todos los files (sin path) que componen una determinada carpeta
                     ext         :    extension de los files contenidos en una carpeta
                 Return:
                     El ultimo file de una determinada carpeta, no se considera el path.
                 """
                 validFilelist = []
                 fileList = os.listdir(path)
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for file in fileList:
                     try:
                         year = int(file[1:5])
                         doy  = int(file[5:8])
                         if (os.path.splitext(file)[-1].upper() != ext.upper()) : continue
                     except:
                         continue
                     validFilelist.append(file)
                 if validFilelist:
                     validFilelist = sorted( validFilelist, key=str.lower )
                     return validFilelist[-1]
                 return None
             def checkForRealPath(path, year, doy, set, ext):
                 """
                 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
                 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
                 el path exacto de un determinado file.
                 Example    :
                     nombre correcto del file es  .../.../D2009307/P2009307367.ext
                     Entonces la funcion prueba con las siguientes combinaciones
                         .../.../x2009307/y2009307367.ext
                         .../.../x2009307/Y2009307367.ext
                         .../.../X2009307/y2009307367.ext
                         .../.../X2009307/Y2009307367.ext
                     siendo para este caso, la ultima combinacion de letras, identica al file buscado
                 Return:
                     Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
                     caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
                     para el filename
                 """
                 filepath = None
                 find_flag = False
                 filename = None
                 if ext.lower() == ".r": #voltage
                     header1 = "dD"
                     header2 = "dD"
                 elif ext.lower() == ".pdata": #spectra
                     header1 = "dD"
                     header2 = "pP"
                 else:
                     return None, filename
                 for dir in header1: #barrido por las dos combinaciones posibles de "D"
                     for fil in header2: #barrido por las dos combinaciones posibles de "D"
                         doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
                         filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
                         filepath = os.path.join( path, doypath, filename ) #formo el path completo
                         if os.path.exists( filepath ): #verifico que exista
                             find_flag = True
                             break
                     if find_flag:
                         break
                 if not(find_flag):
                     return None, filename
                 return filepath, filename
             class JRODataIO:
                 c = 3E8
                 isConfig = False
                 basicHeaderObj = BasicHeader()
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
                 processingHeaderObj = ProcessingHeader()
                 online = 0
                 dtype = None
                 pathList = []
                 filenameList = []
                 filename = None
                 ext = None
                 flagNoMoreFiles = 0
                 flagIsNewFile = 1
                 flagTimeBlock = 0
                 flagIsNewBlock = 0
                 fp = None
                 firstHeaderSize = 0
                 basicHeaderSize = 24
                 versionFile = 1103
                 fileSize = None
                 ippSeconds = None
                 fileSizeByHeader = None
                 fileIndex = None
                 profileIndex = None
                 blockIndex = None
                 nTotalBlocks = None
                 maxTimeStep = 30
                 lastUTTime = None
                 datablock = None
                 dataOut = None
                 blocksize = None
                 def __init__(self):
                     raise ValueError, "Not implemented"
                 def run(self):
                     raise ValueError, "Not implemented"
                 def getOutput(self):
                     return self.dataOut
-            class JRODataReader(JRODataIO):
+            class JRODataReader(JRODataIO, ProcessingUnit):
                 nReadBlocks = 0
                 delay  = 60   #number of seconds waiting a new file
                 nTries  = 3  #quantity tries
                 nFiles = 3   #number of files for searching
                 def __init__(self):
                     """
                     """
                     raise ValueError, "This method has not been implemented"
                 def createObjByDefault(self):
                     """
                     """
                     raise ValueError, "This method has not been implemented"
                 def getBlockDimension(self):
                     raise ValueError, "No implemented"
                 def __searchFilesOffLine(self,
                                         path,
                                         startDate,
                                         endDate,
                                         startTime=datetime.time(0,0,0),
                                         endTime=datetime.time(23,59,59),
                                         set=None,
                                         expLabel="",
                                         ext=".r"):
                     dirList = []
                     for thisPath in os.listdir(path):
                         if os.path.isdir(os.path.join(path,thisPath)):
                             dirList.append(thisPath)
                     if not(dirList):
                         return None, None
                     pathList = []
                     dateList = []
                     thisDate = startDate
                     while(thisDate <= endDate):
                         year = thisDate.timetuple().tm_year
                         doy = thisDate.timetuple().tm_yday
                         match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
                         if len(match) == 0:
                             thisDate += datetime.timedelta(1)
                             continue
                         pathList.append(os.path.join(path,match[0],expLabel))
                         dateList.append(thisDate)
                         thisDate += datetime.timedelta(1)
                     filenameList = []
                     for index in range(len(pathList)):
                         thisPath = pathList[index]
                         fileList = glob.glob1(thisPath, "*%s" %ext)
                         fileList.sort()
                         #Busqueda de datos en el rango de horas indicados
                         thisDate = dateList[index]
                         startDT = datetime.datetime.combine(thisDate, startTime)
                         endDT = datetime.datetime.combine(thisDate, endTime)
                         startUtSeconds = time.mktime(startDT.timetuple())
                         endUtSeconds = time.mktime(endDT.timetuple())
                         for file in fileList:
                             filename = os.path.join(thisPath,file)
                             if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
                                 filenameList.append(filename)
                     if not(filenameList):
                         return None, None
                     self.filenameList = filenameList
                     return pathList, filenameList
                 def __searchFilesOnLine(self, path, startDate=None, endDate=None, startTime=None, endTime=None, expLabel = "", ext = None):
                     """
                     Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
                     devuelve el archivo encontrado ademas de otros datos.
                     Input:
                         path           :    carpeta donde estan contenidos los files que contiene data
                         startDate      :    Fecha inicial. Rechaza todos los directorios donde
                                             file end time < startDate (obejto datetime.date)
                         endDate        :    Fecha final. Rechaza todos los directorios donde
                                             file start time > endDate (obejto datetime.date)
                         startTime      :    Tiempo inicial. Rechaza todos los archivos donde
                                             file end time < startTime (obejto datetime.time)
                         endTime        :    Tiempo final. Rechaza todos los archivos donde
                                             file start time > endTime (obejto datetime.time)
                         expLabel        :     Nombre del subexperimento (subfolder)
                         ext              :    extension de los files
                     Return:
                         directory   :    eL directorio donde esta el file encontrado
                         filename    :    el ultimo file de una determinada carpeta
                         year        :    el anho
                         doy         :    el numero de dia del anho
                         set         :    el set del archivo
                     """
                     dirList = []
                     pathList = []
                     directory = None
                     #Filtra solo los directorios
                     for thisPath in os.listdir(path):
                         if os.path.isdir(os.path.join(path, thisPath)):
                             dirList.append(thisPath)
                     if not(dirList):
                         return None, None, None, None, None
                     dirList = sorted( dirList, key=str.lower )
                     if startDate:
                         startDateTime = datetime.datetime.combine(startDate, startTime)
                         thisDateTime = startDateTime
                         if endDate == None: endDateTime = startDateTime
                         else: endDateTime = datetime.datetime.combine(endDate, endTime)
                         while(thisDateTime <= endDateTime):
                             year = thisDateTime.timetuple().tm_year
                             doy = thisDateTime.timetuple().tm_yday
                             match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
                             if len(match) == 0:
                                 thisDateTime += datetime.timedelta(1)
                                 continue
                             pathList.append(os.path.join(path,match[0], expLabel))
                             thisDateTime += datetime.timedelta(1)
                         if not(pathList):
                             print "\tNo files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
                             return None, None, None, None, None
                         directory = pathList[0]
                     else:
                         directory = dirList[-1]
                         directory = os.path.join(path,directory)
                     filename = getlastFileFromPath(directory, ext)
                     if not(filename):
                         return None, None, None, None, None
                     if not(self.__verifyFile(os.path.join(directory, filename))):
                         return None, None, None, None, None
                     year = int( filename[1:5] )
                     doy  = int( filename[5:8] )
                     set  = int( filename[8:11] )
                     return directory, filename, year, doy, set
-                def setup(self,
-                            path=None,
-                            startDate=None,
-                            endDate=None,
-                            startTime=datetime.time(0,0,0),
-                            endTime=datetime.time(23,59,59),
-                            set=0,
-                            expLabel = "",
-                            ext = None,
-                            online = False,
-                            delay = 60):
-                    if path == None:
-                        raise ValueError, "The path is not valid"
-                    if ext == None:
-                        ext = self.ext
-                    if online:
-                        print "Searching files in online mode..."
-                        doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext)
-                        if not(doypath):
-                            for nTries in range( self.nTries ):
-                                print '\tWaiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
-                                time.sleep( self.delay )
-                                doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=exp)
-                                if doypath:
-                                    break
-                        if not(doypath):
-                            print "There 'isn't valied files in %s" % path
-                            return None
-                        self.year = year
-                        self.doy  = doy
-                        self.set  = set - 1
-                        self.path = path
-                    else:
-                        print "Searching files in offline mode ..."
-                        pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)
-                        if not(pathList):
-                            print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
-                                                                    datetime.datetime.combine(startDate,startTime).ctime(),
-                                                                    datetime.datetime.combine(endDate,endTime).ctime())
-                            sys.exit(-1)
-                        self.fileIndex = -1
-                        self.pathList = pathList
-                        self.filenameList = filenameList
-                    self.online = online
-                    self.delay = delay
-                    ext = ext.lower()
-                    self.ext = ext
-                    if not(self.setNextFile()):
-                        if (startDate!=None) and (endDate!=None):
-                            print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
-                        elif startDate != None:
-                            print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
-                        else:
-                            print "No files"
-                        sys.exit(-1)
-            #        self.updateDataHeader()
-                    return self.dataOut
                 def __setNextFileOffline(self):
                     idFile = self.fileIndex
                     while (True):
                         idFile += 1
                         if not(idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
                             print "No more Files"
                             return 0
                         filename = self.filenameList[idFile]
                         if not(self.__verifyFile(filename)):
                             continue
                         fileSize = os.path.getsize(filename)
                         fp = open(filename,'rb')
                         break
                     self.flagIsNewFile = 1
                     self.fileIndex = idFile
                     self.filename = filename
                     self.fileSize = fileSize
                     self.fp = fp
                     print "Setting the file: %s"%self.filename
                     return 1
                 def __setNextFileOnline(self):
                     """
                     Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
                     no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
                     siguientes.
                     Affected:
                         self.flagIsNewFile
                         self.filename
                         self.fileSize
                         self.fp
                         self.set
                         self.flagNoMoreFiles
                     Return:
 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
 : si el file fue abierto con exito y esta listo a ser leido
                     Excepciones:
                         Si un determinado file no puede ser abierto
                     """
                     nFiles = 0
                     fileOk_flag = False
                     firstTime_flag = True
                     self.set += 1
                     #busca el 1er file disponible
                     file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
                     if file:
                         if self.__verifyFile(file, False):
                             fileOk_flag = True
                     #si no encuentra un file entonces espera y vuelve a buscar
                     if not(fileOk_flag):
                         for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
                             if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
                                 tries = self.nTries
                             else:
                                 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
                             for nTries in range( tries ):
                                 if firstTime_flag:
                                     print "\tWaiting %0.2f sec for the file \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 )
                                     time.sleep( self.delay )
                                 else:
                                     print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
                                 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
                                 if file:
                                     if self.__verifyFile(file):
                                         fileOk_flag = True
                                         break
                             if fileOk_flag:
                                 break
                             firstTime_flag = False
                             print "\tSkipping the file \"%s\" due to this file doesn't exist" % filename
                             self.set += 1
                             if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
                                 self.set = 0
                                 self.doy += 1
                     if fileOk_flag:
                         self.fileSize = os.path.getsize( file )
                         self.filename = file
                         self.flagIsNewFile = 1
                         if self.fp != None: self.fp.close()
                         self.fp = open(file)
                         self.flagNoMoreFiles = 0
                         print 'Setting the file: %s' % file
                     else:
                         self.fileSize = 0
                         self.filename = None
                         self.flagIsNewFile = 0
                         self.fp = None
                         self.flagNoMoreFiles = 1
                         print 'No more Files'
                     return fileOk_flag
                 def setNextFile(self):
                     if self.fp != None:
                         self.fp.close()
                     if self.online:
                         newFile = self.__setNextFileOnline()
                     else:
                         newFile = self.__setNextFileOffline()
                     if not(newFile):
                         return 0
                     self.__readFirstHeader()
                     self.nReadBlocks = 0
                     return 1
                 def __setNewBlock(self):
                     if self.fp == None:
                         return 0
                     if self.flagIsNewFile:
                         return 1
                     self.lastUTTime = self.basicHeaderObj.utc
                     currentSize = self.fileSize - self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     if (currentSize >= neededSize):
                         self.__rdBasicHeader()
                         return 1
                     if not(self.setNextFile()):
                         return 0
                     deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
                     self.flagTimeBlock = 0
                     if deltaTime > self.maxTimeStep:
                         self.flagTimeBlock = 1
                     return 1
                 def readNextBlock(self):
                     if not(self.__setNewBlock()):
                         return 0
                     if not(self.readBlock()):
                         return 0
                     return 1
                 def __rdProcessingHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.processingHeaderObj.read(fp)
                 def __rdRadarControllerHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.radarControllerHeaderObj.read(fp)
                 def __rdSystemHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.systemHeaderObj.read(fp)
                 def __rdBasicHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.basicHeaderObj.read(fp)
                 def __readFirstHeader(self):
                     self.__rdBasicHeader()
                     self.__rdSystemHeader()
                     self.__rdRadarControllerHeader()
                     self.__rdProcessingHeader()
                     self.firstHeaderSize = self.basicHeaderObj.size
                     datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
                     if datatype == 0:
                         datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
                     elif datatype == 1:
                         datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
                     elif datatype == 2:
                         datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
                     elif datatype == 3:
                         datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
                     elif datatype == 4:
                         datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
                     elif datatype == 5:
                         datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
                     else:
                         raise ValueError, 'Data type was not defined'
                     self.dtype = datatype_str
                     self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
                     self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
             #        self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
             #        self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
                     self.getBlockDimension()
                 def __verifyFile(self, filename, msgFlag=True):
                     msg = None
                     try:
                         fp = open(filename, 'rb')
                         currentPosition = fp.tell()
                     except:
                         if msgFlag:
                             print "The file %s can't be opened" % (filename)
                         return False
                     neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
                     if neededSize == 0:
                         basicHeaderObj = BasicHeader()
                         systemHeaderObj = SystemHeader()
                         radarControllerHeaderObj = RadarControllerHeader()
                         processingHeaderObj = ProcessingHeader()
                         try:
                             if not( basicHeaderObj.read(fp) ): raise ValueError
                             if not( systemHeaderObj.read(fp) ): raise ValueError
                             if not( radarControllerHeaderObj.read(fp) ): raise ValueError
                             if not( processingHeaderObj.read(fp) ): raise ValueError
                             data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
                             neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
                         except:
                             if msgFlag:
                                 print "\tThe file %s is empty or it hasn't enough data" % filename
                             fp.close()
                             return False
                     else:
                         msg = "\tSkipping the file %s due to it hasn't enough data" %filename
                     fp.close()
                     fileSize = os.path.getsize(filename)
                     currentSize = fileSize - currentPosition
                     if currentSize < neededSize:
                         if msgFlag and (msg != None):
                             print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
                         return False
                     return True
+                def setup(self,
+                            path=None,
+                            startDate=None,
+                            endDate=None,
+                            startTime=datetime.time(0,0,0),
+                            endTime=datetime.time(23,59,59),
+                            set=0,
+                            expLabel = "",
+                            ext = None,
+                            online = False,
+                            delay = 60):
+                    if path == None:
+                        raise ValueError, "The path is not valid"
+                    if ext == None:
+                        ext = self.ext
+                    if online:
+                        print "Searching files in online mode..."
+                        doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext)
+                        if not(doypath):
+                            for nTries in range( self.nTries ):
+                                print '\tWaiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
+                                time.sleep( self.delay )
+                                doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=exp)
+                                if doypath:
+                                    break
+                        if not(doypath):
+                            print "There 'isn't valied files in %s" % path
+                            return None
+                        self.year = year
+                        self.doy  = doy
+                        self.set  = set - 1
+                        self.path = path
+                    else:
+                        print "Searching files in offline mode ..."
+                        pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)
+                        if not(pathList):
+                            print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
+                                                                    datetime.datetime.combine(startDate,startTime).ctime(),
+                                                                    datetime.datetime.combine(endDate,endTime).ctime())
+                            sys.exit(-1)
+                        self.fileIndex = -1
+                        self.pathList = pathList
+                        self.filenameList = filenameList
+                    self.online = online
+                    self.delay = delay
+                    ext = ext.lower()
+                    self.ext = ext
+                    if not(self.setNextFile()):
+                        if (startDate!=None) and (endDate!=None):
+                            print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
+                        elif startDate != None:
+                            print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
+                        else:
+                            print "No files"
+                        sys.exit(-1)
+            #        self.updateDataHeader()
+                    return self.dataOut
                 def getData():
                     pass
                 def hasNotDataInBuffer():
                     pass
                 def readBlock():
                     pass
                 def run(self, **kwargs):
                     if not(self.isConfig):
             #            self.dataOut = dataOut
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()
-            class JRODataWriter(JRODataIO):
+            class JRODataWriter(JRODataIO, Operation):
                 """
                 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 blockIndex = 0
                 path = None
                 setFile = None
                 profilesPerBlock = None
                 blocksPerFile = None
                 nWriteBlocks = 0
                 def __init__(self, dataOut=None):
                     raise ValueError, "Not implemented"
                 def hasAllDataInBuffer(self):
                     raise ValueError, "Not implemented"
                 def setBlockDimension(self):
                     raise ValueError, "Not implemented"
                 def writeBlock(self):
                     raise ValueError, "No implemented"
                 def putData(self):
                     raise ValueError, "No implemented"
                 def getDataHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj self.
                     Return:
                         None
                     """
                     raise ValueError, "No implemented"
                 def getBasicHeader(self):
                     self.basicHeaderObj.size = self.basicHeaderSize #bytes
                     self.basicHeaderObj.version = self.versionFile
                     self.basicHeaderObj.dataBlock = self.nTotalBlocks
                     utc = numpy.floor(self.dataOut.utctime)
                     milisecond  = (self.dataOut.utctime - utc)* 1000.0
                     self.basicHeaderObj.utc = utc
                     self.basicHeaderObj.miliSecond = milisecond
                     self.basicHeaderObj.timeZone = 0
                     self.basicHeaderObj.dstFlag = 0
                     self.basicHeaderObj.errorCount = 0
                 def __writeFirstHeader(self):
                     """
                     Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
                     Affected:
                         __dataType
                     Return:
                         None
                     """
             #        CALCULAR PARAMETROS
                     sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
                     self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
                     self.basicHeaderObj.write(self.fp)
                     self.systemHeaderObj.write(self.fp)
                     self.radarControllerHeaderObj.write(self.fp)
                     self.processingHeaderObj.write(self.fp)
                     self.dtype = self.dataOut.dtype
                 def __setNewBlock(self):
                     """
                     Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
                     Return:
 :    si no pudo escribir nada
 :    Si escribio el Basic el First Header
                     """
                     if self.fp == None:
                         self.setNextFile()
                     if self.flagIsNewFile:
                         return 1
                     if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
                         self.basicHeaderObj.write(self.fp)
                         return 1
                     if not( self.setNextFile() ):
                         return 0
                     return 1
                 def writeNextBlock(self):
                     """
                     Selecciona el bloque siguiente de datos y los escribe en un file
                     Return:
 :    Si no hizo pudo escribir el bloque de datos
 :    Si no pudo escribir el bloque de datos
                     """
                     if not( self.__setNewBlock() ):
                         return 0
                     self.writeBlock()
                     return 1
                 def setNextFile(self):
                     """
                     Determina el siguiente file que sera escrito
                     Affected:
                         self.filename
                         self.subfolder
                         self.fp
                         self.setFile
                         self.flagIsNewFile
                     Return:
 :    Si el archivo no puede ser escrito
 :    Si el archivo esta listo para ser escrito
                     """
                     ext = self.ext
                     path = self.path
                     if self.fp != None:
                         self.fp.close()
                     timeTuple = time.localtime( self.dataOut.dataUtcTime)
                     subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
                     doypath = os.path.join( path, subfolder )
                     if not( os.path.exists(doypath) ):
                         os.mkdir(doypath)
                         self.setFile = -1 #inicializo mi contador de seteo
                     else:
                         filesList = os.listdir( doypath )
                         if len( filesList ) > 0:
                             filesList = sorted( filesList, key=str.lower )
                             filen = filesList[-1]
                             # el filename debera tener el siguiente formato
                             # 0 1234 567 89A BCDE (hex)
                             # x YYYY DDD SSS .ext
                             if isNumber( filen[8:11] ):
                                 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
                             else:
                                 self.setFile = -1
                         else:
                             self.setFile = -1 #inicializo mi contador de seteo
                     setFile = self.setFile
                     setFile += 1
                     file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
                                                     timeTuple.tm_year,
                                                     timeTuple.tm_yday,
                                                     setFile,
                                                     ext )
                     filename = os.path.join( path, subfolder, file )
                     fp = open( filename,'wb' )
                     self.blockIndex = 0
                     #guardando atributos
                     self.filename = filename
                     self.subfolder = subfolder
                     self.fp = fp
                     self.setFile = setFile
                     self.flagIsNewFile = 1
                     self.getDataHeader()
                     print 'Writing the file: %s'%self.filename
                     self.__writeFirstHeader()
                     return 1
                 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=None, set=0, ext=None):
                     """
                     Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
                     Inputs:
                         path      :    el path destino en el cual se escribiran los files a crear
                         format    :    formato en el cual sera salvado un file
                         set       :    el setebo del file
                     Return:
 :    Si no realizo un buen seteo
 :    Si realizo un buen seteo
                     """
                     if ext == None:
                         ext = self.ext
                     ext = ext.lower()
                     self.ext = ext
                     self.path = path
                     self.setFile = set - 1
                     self.blocksPerFile = blocksPerFile
                     self.profilesPerBlock = profilesPerBlock
                     self.dataOut = dataOut
                     if not(self.setNextFile()):
                         print "There isn't a next file"
                         return 0
                     self.setBlockDimension()
                     return 1
                 def run(self, dataOut, **kwargs):
                     if not(self.isConfig):
                         self.setup(dataOut, **kwargs)
                         self.isConfig = True
                     self.putData()
             class VoltageReader(JRODataReader):
                 """
                 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
                 perfiles*alturas*canales) son almacenados en la variable "buffer".
                                          perfiles * alturas * canales
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
                 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
                 Example:
                     dpath = "/home/myuser/data"
                     startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
                     endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
                     readerObj = VoltageReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         #to get one profile
                         profile =  readerObj.getData()
                         #print the profile
                         print profile
                         #If you want to see all datablock
                         print readerObj.datablock
                         if readerObj.flagNoMoreFiles:
                             break
                 """
                 ext = ".r"
                 optchar = "D"
                 dataOut = None
                 def __init__(self):
                     """
                     Inicializador de la clase VoltageReader para la lectura de datos de voltage.
                     Input:
                         dataOut    :    Objeto de la clase Voltage. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           bloque de datos.
                                           Si este parametro no es pasado se creara uno internamente.
                     Variables afectadas:
                         self.dataOut
                     Return:
                         None
                     """
                     self.isConfig = False
                     self.datablock = None
                     self.utc = 0
                     self.ext = ".r"
                     self.optchar = "D"
                     self.basicHeaderObj = BasicHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.online = 0
                     self.fp = None
                     self.idFile = None
                     self.dtype = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.filename = None
                     self.fileSize = None
                     self.firstHeaderSize = 0
                     self.basicHeaderSize = 24
                     self.pathList = []
                     self.filenameList = []
                     self.lastUTTime = 0
                     self.maxTimeStep = 30
                     self.flagNoMoreFiles = 0
                     self.set = 0
                     self.path = None
                     self.profileIndex = 9999
                     self.delay  = 3   #seconds
                     self.nTries  = 3  #quantity tries
                     self.nFiles = 3   #number of files for searching
                     self.nReadBlocks = 0
                     self.flagIsNewFile = 1
                     self.ippSeconds = 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     self.nTotalBlocks = 0
                     self.blocksize = 0
                     self.dataOut = self.createObjByDefault()
                 def createObjByDefault(self):
                     dataObj = Voltage()
                     return dataObj
                 def __hasNotDataInBuffer(self):
                     if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
                         return 1
                     return 0
                 def getBlockDimension(self):
                     """
                     Obtiene la cantidad de puntos a leer por cada bloque de datos
                     Affected:
                         self.blocksize
                     Return:
                         None
                     """
                     pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
                     self.blocksize = pts2read
                 def readBlock(self):
                     """
                     readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
                     (self.fp) y actualiza todos los parametros relacionados al bloque de datos
                     (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
                     es seteado a 0
                     Inputs:
                         None
                     Return:
                         None
                     Affected:
                         self.profileIndex
                         self.datablock
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                     Exceptions:
                         Si un bloque leido no es un bloque valido
                     """
                     junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
                     try:
                         junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
                     except:
                         print "The read block (%3d) has not enough data" %self.nReadBlocks
                         return 0
                     junk = numpy.transpose(junk, (2,0,1))
                     self.datablock = junk['real'] + junk['imag']*1j
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def getData(self):
                     """
                     getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
                     con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
                     lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
                     Ademas incrementa el contador del buffer en 1.
                     Return:
                         data    :    retorna un perfil de voltages (alturas * canales) copiados desde el
                                      buffer. Si no hay mas archivos a leer retorna None.
                     Variables afectadas:
                         self.dataOut
                         self.profileIndex
                     Affected:
                         self.dataOut
                         self.profileIndex
                         self.flagTimeBlock
                         self.flagIsNewBlock
                     """
                     if self.flagNoMoreFiles: return 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not( self.readNextBlock() ):
                             return 0
             #            self.updateDataHeader()
                     if self.flagNoMoreFiles == 1:
                         print 'Process finished'
                         return 0
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.datablock == None:
                         self.dataOut.flagNoData = True
                         return 0
                     self.dataOut.data = self.datablock[:,self.profileIndex,:]
                     self.dataOut.dtype = self.dtype
                     self.dataOut.nChannels = self.systemHeaderObj.nChannels
                     self.dataOut.nHeights = self.processingHeaderObj.nHeights
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
                     self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
                     self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
                     self.dataOut.channelIndexList = range(self.systemHeaderObj.nChannels)
                     self.dataOut.flagTimeBlock = self.flagTimeBlock
                     self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
                     self.dataOut.ippSeconds = self.ippSeconds
                     self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt
                     self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
                     self.dataOut.flagShiftFFT = False
                     if self.processingHeaderObj.code != None:
                         self.dataOut.nCode = self.processingHeaderObj.nCode
                         self.dataOut.nBaud = self.processingHeaderObj.nBaud
                         self.dataOut.code = self.processingHeaderObj.code
                     self.profileIndex += 1
                     self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                     self.dataOut.flagNoData = False
             #        print self.profileIndex, self.dataOut.utctime
             #        if self.profileIndex == 800:
             #            a=1
                     return self.dataOut.data
             class VoltageWriter(JRODataWriter):
                 """
                 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 ext = ".r"
                 optchar = "D"
                 shapeBuffer = None
                 def __init__(self):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                     Affected:
                         self.dataOut
                     Return: None
                     """
                     self.nTotalBlocks = 0
                     self.profileIndex = 0
                     self.isConfig = False
                     self.fp = None
                     self.flagIsNewFile = 1
                     self.nTotalBlocks = 0
                     self.flagIsNewBlock = 0
                     self.flagNoMoreFiles = 0
                     self.setFile = None
                     self.dtype = None
                     self.path = None
                     self.noMoreFiles = 0
                     self.filename = None
                     self.basicHeaderObj = BasicHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                 def hasAllDataInBuffer(self):
                     if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
                         return 1
                     return 0
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     Affected:
                         self.shape_spc_Buffer
                         self.shape_cspc_Buffer
                         self.shape_dc_Buffer
                     Return: None
                     """
                     self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
                                         self.processingHeaderObj.nHeights,
                                         self.systemHeaderObj.nChannels)
                     self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
                                                  self.processingHeaderObj.profilesPerBlock,
                                                  self.processingHeaderObj.nHeights),
                                                  dtype=numpy.dtype('complex'))
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.profileIndex
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.blockIndex
                     Return: None
                     """
                     data = numpy.zeros( self.shapeBuffer, self.dtype )
                     junk = numpy.transpose(self.datablock, (1,2,0))
                     data['real'] = junk.real
                     data['imag'] = junk.imag
                     data = data.reshape( (-1) )
                     data.tofile( self.fp )
                     self.datablock.fill(0)
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.blockIndex += 1
                     self.nTotalBlocks += 1
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.flagIsNewBlock
                         self.profileIndex
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
                     if self.dataOut.flagNoData:
                         return 0
                     self.flagIsNewBlock = 0
                     if self.dataOut.flagTimeBlock:
                         self.datablock.fill(0)
                         self.profileIndex = 0
                         self.setNextFile()
                     if self.profileIndex == 0:
                         self.getBasicHeader()
                     self.datablock[:,self.profileIndex,:] = self.dataOut.data
                     self.profileIndex += 1
                     if self.hasAllDataInBuffer():
                         #if self.flagIsNewFile:
                         self.writeNextBlock()
             #            self.getDataHeader()
                     if self.flagNoMoreFiles:
                         #print 'Process finished'
                         return 0
                     return 1
                 def __getProcessFlags(self):
                     processFlags = 0
                     dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
                     dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
                     dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
                     dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
                     dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
                     dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList =  [PROCFLAG.DATATYPE_CHAR,
                                        PROCFLAG.DATATYPE_SHORT,
                                        PROCFLAG.DATATYPE_LONG,
                                        PROCFLAG.DATATYPE_INT64,
                                        PROCFLAG.DATATYPE_FLOAT,
                                        PROCFLAG.DATATYPE_DOUBLE]
                     for index in range(len(dtypeList)):
                         if self.dataOut.dtype == dtypeList[index]:
                             dtypeValue = datatypeValueList[index]
                             break
                     processFlags += dtypeValue
                     if self.dataOut.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
                     if self.dataOut.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
                     if self.dataOut.code != None:
                         processFlags += PROCFLAG.DEFINE_PROCESS_CODE
                     if self.dataOut.nCohInt > 1:
                         processFlags += PROCFLAG.COHERENT_INTEGRATION
                     return processFlags
                 def __getBlockSize(self):
                     '''
                     Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
                     '''
                     dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
                     dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
                     dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
                     dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
                     dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
                     dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList = [1,2,4,8,4,8]
                     for index in range(len(dtypeList)):
                         if self.dataOut.dtype == dtypeList[index]:
                             datatypeValue = datatypeValueList[index]
                             break
                     blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.dataOut.nProfiles * datatypeValue * 2)
                     return blocksize
                 def getDataHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.dtype
                     Return:
                         None
                     """
                     self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
                     self.systemHeaderObj.nChannels = self.dataOut.nChannels
                     self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
                     self.getBasicHeader()
                     processingHeaderSize = 40 # bytes
                     self.processingHeaderObj.dtype = 0 # Voltage
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
                     self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
                     self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.processFlags = self.__getProcessFlags()
                     self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
                     self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
                     self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
                     if self.dataOut.code != None:
                         self.processingHeaderObj.code = self.dataOut.code
                         self.processingHeaderObj.nCode = self.dataOut.nCode
                         self.processingHeaderObj.nBaud = self.dataOut.nBaud
                         codesize = int(8 + 4 * self.dataOut.nCode * self.dataOut.nBaud)
                         processingHeaderSize += codesize
                     if self.processingHeaderObj.nWindows != 0:
                         self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
                         self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                         self.processingHeaderObj.nHeights = self.dataOut.nHeights
                         self.processingHeaderObj.samplesWin = self.dataOut.nHeights
                         processingHeaderSize += 12
                     self.processingHeaderObj.size = processingHeaderSize
             class SpectraReader(JRODataReader):
                 """
                 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
                 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
                                     paresCanalesIguales    * alturas * perfiles  (Self Spectra)
                                     paresCanalesDiferentes * alturas * perfiles  (Cross Spectra)
                                     canales * alturas                            (DC Channels)
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
                 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
                 Example:
                     dpath = "/home/myuser/data"
                     startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
                     endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
                     readerObj = SpectraReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         readerObj.getData()
                         print readerObj.data_spc
                         print readerObj.data_cspc
                         print readerObj.data_dc
                         if readerObj.flagNoMoreFiles:
                             break
                 """
                 pts2read_SelfSpectra = 0
                 pts2read_CrossSpectra = 0
                 pts2read_DCchannels = 0
                 ext = ".pdata"
                 optchar = "P"
                 dataOut = None
                 nRdChannels = None
                 nRdPairs = None
                 rdPairList = []
                 def __init__(self):
                     """
                     Inicializador de la clase SpectraReader para la lectura de datos de espectros.
                     Inputs:
                         dataOut    :    Objeto de la clase Spectra. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           bloque de datos.
                                           Si este parametro no es pasado se creara uno internamente.
                     Affected:
                         self.dataOut
                     Return      : None
                     """
                     self.isConfig = False
                     self.pts2read_SelfSpectra = 0
                     self.pts2read_CrossSpectra = 0
                     self.pts2read_DCchannels = 0
                     self.datablock = None
                     self.utc = None
                     self.ext = ".pdata"
                     self.optchar = "P"
                     self.basicHeaderObj = BasicHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.online = 0
                     self.fp = None
                     self.idFile = None
                     self.dtype = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.filename = None
                     self.fileSize = None
                     self.firstHeaderSize = 0
                     self.basicHeaderSize = 24
                     self.pathList = []
                     self.lastUTTime = 0
                     self.maxTimeStep = 30
                     self.flagNoMoreFiles = 0
                     self.set = 0
                     self.path = None
                     self.delay  = 3   #seconds
                     self.nTries = 3  #quantity tries
                     self.nFiles = 3   #number of files for searching
                     self.nReadBlocks = 0
                     self.flagIsNewFile = 1
                     self.ippSeconds = 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     self.nTotalBlocks = 0
                     self.blocksize = 0
                     self.dataOut = self.createObjByDefault()
                 def createObjByDefault(self):
                     dataObj = Spectra()
                     return dataObj
                 def __hasNotDataInBuffer(self):
                     return 1
                 def getBlockDimension(self):
                     """
                     Obtiene la cantidad de puntos a leer por cada bloque de datos
                     Affected:
                         self.nRdChannels
                         self.nRdPairs
                         self.pts2read_SelfSpectra
                         self.pts2read_CrossSpectra
                         self.pts2read_DCchannels
                         self.blocksize
                         self.dataOut.nChannels
                         self.dataOut.nPairs
                     Return:
                         None
                     """
                     self.nRdChannels = 0
                     self.nRdPairs = 0
                     self.rdPairList = []
                     for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
                         if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
                             self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
                         else:
                             self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
                             self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
                     pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
                     self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
                     self.blocksize = self.pts2read_SelfSpectra
                     if self.processingHeaderObj.flag_cspc:
                         self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
                         self.blocksize += self.pts2read_CrossSpectra
                     if self.processingHeaderObj.flag_dc:
                         self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)
                         self.blocksize += self.pts2read_DCchannels
             #        self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
                 def readBlock(self):
                     """
                     Lee el bloque de datos desde la posicion actual del puntero del archivo
                     (self.fp) y actualiza todos los parametros relacionados al bloque de datos
                     (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
                     es seteado a 0
                     Return: None
                     Variables afectadas:
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Exceptions:
                         Si un bloque leido no es un bloque valido
                     """
                     blockOk_flag = False
                     fpointer = self.fp.tell()
                     spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )
                     spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
                     if self.processingHeaderObj.flag_cspc:
                         cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )
                         cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
                     if self.processingHeaderObj.flag_dc:
                         dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
                         dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D
                     if not(self.processingHeaderObj.shif_fft):
                         spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                         if self.processingHeaderObj.flag_cspc:
                             cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                     spc = numpy.transpose( spc, (0,2,1) )
                     self.data_spc = spc
                     if self.processingHeaderObj.flag_cspc:
                         cspc = numpy.transpose( cspc, (0,2,1) )
                         self.data_cspc = cspc['real'] + cspc['imag']*1j
                     else:
                         self.data_cspc = None
                     if self.processingHeaderObj.flag_dc:
                         self.data_dc = dc['real'] + dc['imag']*1j
                     else:
                         self.data_dc = None
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def getData(self):
                     """
                     Copia el buffer de lectura a la clase "Spectra",
                     con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
                     lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
                     Return:
 :    Si no hay mas archivos disponibles
 :    Si hizo una buena copia del buffer
                     Affected:
                         self.dataOut
                         self.flagTimeBlock
                         self.flagIsNewBlock
                     """
                     if self.flagNoMoreFiles: return 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not( self.readNextBlock() ):
                             return 0
             #            self.updateDataHeader()
                     if self.flagNoMoreFiles == 1:
                         print 'Process finished'
                         return 0
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.data_dc == None:
                         self.dataOut.flagNoData = True
                         return 0
                     self.dataOut.data_spc = self.data_spc
                     self.dataOut.data_cspc = self.data_cspc
                     self.dataOut.data_dc = self.data_dc
                     self.dataOut.flagTimeBlock = self.flagTimeBlock
                     self.dataOut.flagNoData = False
                     self.dataOut.dtype = self.dtype
                     self.dataOut.nChannels = self.nRdChannels
                     self.dataOut.nPairs = self.nRdPairs
                     self.dataOut.pairsList = self.rdPairList
                     self.dataOut.nHeights = self.processingHeaderObj.nHeights
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
                     self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock
                     self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt
                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
                     self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
                     self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
                     self.dataOut.channelIndexList = range(self.systemHeaderObj.nChannels)
                     self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds
                     self.dataOut.ippSeconds = self.ippSeconds
                     self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOut.nFFTPoints
                     self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
             #        self.profileIndex += 1
                     self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                     return self.dataOut.data_spc
             class SpectraWriter(JRODataWriter):
                 """
                 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 ext = ".pdata"
                 optchar = "P"
                 shape_spc_Buffer = None
                 shape_cspc_Buffer = None
                 shape_dc_Buffer = None
                 data_spc = None
                 data_cspc = None
                 data_dc = None
             #    dataOut = None
                 def __init__(self):
                     """
                     Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
                     Affected:
                         self.dataOut
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj
                     Return: None
                     """
                     self.isConfig = False
                     self.nTotalBlocks = 0
                     self.data_spc = None
                     self.data_cspc = None
                     self.data_dc = None
                     self.fp = None
                     self.flagIsNewFile = 1
                     self.nTotalBlocks = 0
                     self.flagIsNewBlock = 0
                     self.flagNoMoreFiles = 0
                     self.setFile = None
                     self.dtype = None
                     self.path = None
                     self.noMoreFiles = 0
                     self.filename = None
                     self.basicHeaderObj = BasicHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                 def hasAllDataInBuffer(self):
                     return 1
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     Affected:
                         self.shape_spc_Buffer
                         self.shape_cspc_Buffer
                         self.shape_dc_Buffer
                     Return: None
                     """
                     self.shape_spc_Buffer = (self.dataOut.nChannels,
                                              self.processingHeaderObj.nHeights,
                                              self.processingHeaderObj.profilesPerBlock)
                     self.shape_cspc_Buffer = (self.dataOut.nPairs,
                                               self.processingHeaderObj.nHeights,
                                               self.processingHeaderObj.profilesPerBlock)
                     self.shape_dc_Buffer = (self.dataOut.nChannels,
                                             self.processingHeaderObj.nHeights)
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.nWriteBlocks
                     Return: None
                     """
                     spc = numpy.transpose( self.data_spc, (0,2,1) )
                     if not( self.processingHeaderObj.shif_fft ):
                         spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                     data = spc.reshape((-1))
                     data.tofile(self.fp)
                     if self.data_cspc != None:
                         data = numpy.zeros( self.shape_cspc_Buffer, self.dtype )
                         cspc = numpy.transpose( self.data_cspc, (0,2,1) )
                         if not( self.processingHeaderObj.shif_fft ):
                             cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                         data['real'] = cspc.real
                         data['imag'] = cspc.imag
                         data = data.reshape((-1))
                         data.tofile(self.fp)
                     if self.data_dc != None:
                         data = numpy.zeros( self.shape_dc_Buffer, self.dtype )
                         dc = self.data_dc
                         data['real'] = dc.real
                         data['imag'] = dc.imag
                         data = data.reshape((-1))
                         data.tofile(self.fp)
                     self.data_spc.fill(0)
                     self.data_dc.fill(0)
                     if self.data_cspc != None:
                         self.data_cspc.fill(0)
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nWriteBlocks += 1
                     self.blockIndex += 1
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
                     if self.dataOut.flagNoData:
                         return 0
                     self.flagIsNewBlock = 0
                     if self.dataOut.flagTimeBlock:
                         self.data_spc.fill(0)
                         self.data_cspc.fill(0)
                         self.data_dc.fill(0)
                         self.setNextFile()
                     if self.flagIsNewFile == 0:
                         self.getBasicHeader()
                     self.data_spc = self.dataOut.data_spc
                     self.data_cspc = self.dataOut.data_cspc
                     self.data_dc = self.dataOut.data_dc
                     # #self.processingHeaderObj.dataBlocksPerFile)
                     if self.hasAllDataInBuffer():
             #            self.getDataHeader()
                         self.writeNextBlock()
                     if self.flagNoMoreFiles:
                         #print 'Process finished'
                         return 0
                     return 1
                 def __getProcessFlags(self):
                     processFlags = 0
                     dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
                     dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
                     dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
                     dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
                     dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
                     dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList =  [PROCFLAG.DATATYPE_CHAR,
                                        PROCFLAG.DATATYPE_SHORT,
                                        PROCFLAG.DATATYPE_LONG,
                                        PROCFLAG.DATATYPE_INT64,
                                        PROCFLAG.DATATYPE_FLOAT,
                                        PROCFLAG.DATATYPE_DOUBLE]
                     for index in range(len(dtypeList)):
                         if self.dataOut.dtype == dtypeList[index]:
                             dtypeValue = datatypeValueList[index]
                             break
                     processFlags += dtypeValue
                     if self.dataOut.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
                     if self.dataOut.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
                     if self.dataOut.code != None:
                         processFlags += PROCFLAG.DEFINE_PROCESS_CODE
                     if self.dataOut.nIncohInt > 1:
                         processFlags += PROCFLAG.INCOHERENT_INTEGRATION
                     if self.dataOut.data_dc != None:
                         processFlags += PROCFLAG.SAVE_CHANNELS_DC
                     return processFlags
                 def __getBlockSize(self):
                     '''
                     Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
                     '''
                     dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
                     dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
                     dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
                     dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
                     dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
                     dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList = [1,2,4,8,4,8]
                     for index in range(len(dtypeList)):
                         if self.dataOut.dtype == dtypeList[index]:
                             datatypeValue = datatypeValueList[index]
                             break
                     pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
                     pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
                     blocksize = (pts2write_SelfSpectra*datatypeValue)
                     if self.dataOut.data_cspc != None:
                         pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)
                         blocksize += (pts2write_CrossSpectra*datatypeValue*2)
                     if self.dataOut.data_dc != None:
                         pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights)
                         blocksize += (pts2write_DCchannels*datatypeValue*2)
                     blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
                     return blocksize
                 def getDataHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.dtype
                     Return:
                         None
                     """
                     self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
                     self.systemHeaderObj.nChannels = self.dataOut.nChannels
                     self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
                     self.getBasicHeader()
                     processingHeaderSize = 40 # bytes
                     self.processingHeaderObj.dtype = 0 # Voltage
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
                     self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
                     self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.processFlags = self.__getProcessFlags()
                     self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
                     self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
                     self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
                     if self.processingHeaderObj.totalSpectra > 0:
                         channelList = []
                         for channel in range(self.dataOut.nChannels):
                             channelList.append(channel)
                             channelList.append(channel)
                         pairsList = []
                         for pair in self.dataOut.pairsList:
                             pairsList.append(pair[0])
                             pairsList.append(pair[1])
                         spectraComb = channelList + pairsList
                         spectraComb = numpy.array(spectraComb,dtype="u1")
                         self.processingHeaderObj.spectraComb = spectraComb
                         sizeOfSpcComb = len(spectraComb)
                         processingHeaderSize += sizeOfSpcComb
                     if self.dataOut.code != None:
                         self.processingHeaderObj.code = self.dataOut.code
                         self.processingHeaderObj.nCode = self.dataOut.nCode
                         self.processingHeaderObj.nBaud = self.dataOut.nBaud
                         nCodeSize = 4 # bytes
                         nBaudSize = 4 # bytes
                         codeSize = 4 # bytes
                         sizeOfCode = int(nCodeSize + nBaudSize + codeSize * self.dataOut.nCode * self.dataOut.nBaud)
                         processingHeaderSize += sizeOfCode
                     if self.processingHeaderObj.nWindows != 0:
                         self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
                         self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                         self.processingHeaderObj.nHeights = self.dataOut.nHeights
                         self.processingHeaderObj.samplesWin = self.dataOut.nHeights
                         sizeOfFirstHeight = 4
                         sizeOfdeltaHeight = 4
                         sizeOfnHeights = 4
                         sizeOfWindows = (sizeOfFirstHeight + sizeOfdeltaHeight + sizeOfnHeights)*self.processingHeaderObj.nWindows
                         processingHeaderSize += sizeOfWindows
                     self.processingHeaderObj.size = processingHeaderSize
             class SpectraHeisWriter():
                 i=0
                 def __init__(self, dataOut):
                     self.wrObj = FITS()
                     self.dataOut = dataOut
                 def isNumber(str):
                     """
                     Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
                     Excepciones:
                     Si un determinado string no puede ser convertido a numero
                     Input:
                     str, string al cual se le analiza para determinar si convertible a un numero o no
                     Return:
                     True    :    si el string es uno numerico
                     False   :    no es un string numerico
                     """
                     try:
                         float( str )
                         return True
                     except:
                         return False
                 def setup(self, wrpath,):
                     if not(os.path.exists(wrpath)):
                         os.mkdir(wrpath)
                     self.wrpath = wrpath
                     self.setFile = 0
                 def putData(self):
                   # self.wrObj.writeHeader(nChannels=self.dataOut.nChannels, nFFTPoints=self.dataOut.nFFTPoints)
                     #name = self.dataOut.utctime
                     name= time.localtime( self.dataOut.utctime)
                     ext=".fits"
                     #folder='D%4.4d%3.3d'%(name.tm_year,name.tm_yday)
                     subfolder = 'D%4.4d%3.3d' % (name.tm_year,name.tm_yday)
                     doypath = os.path.join( self.wrpath, subfolder )
                     if not( os.path.exists(doypath) ):
                         os.mkdir(doypath)
                     self.setFile += 1
                     file = 'D%4.4d%3.3d%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)
                     filename = os.path.join(self.wrpath,subfolder, file)
                    # print self.dataOut.ippSeconds
                     freq=numpy.arange(-1*self.dataOut.nHeights/2.,self.dataOut.nHeights/2.)/(2*self.dataOut.ippSeconds)
                     col1=self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints)+'E', array=freq)
                     col2=self.wrObj.writeData(name="P_Ch1",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[0,:]))
                     col3=self.wrObj.writeData(name="P_Ch2",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[1,:]))
                     col4=self.wrObj.writeData(name="P_Ch3",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[2,:]))
                     col5=self.wrObj.writeData(name="P_Ch4",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[3,:]))
                     col6=self.wrObj.writeData(name="P_Ch5",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[4,:]))
                     col7=self.wrObj.writeData(name="P_Ch6",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[5,:]))
                     col8=self.wrObj.writeData(name="P_Ch7",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[6,:]))
                     col9=self.wrObj.writeData(name="P_Ch8",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[7,:]))
                     #n=numpy.arange((100))
                     n=self.dataOut.data_spc[6,:]
                     a=self.wrObj.cFImage(n)
                     b=self.wrObj.Ctable(col1,col2,col3,col4,col5,col6,col7,col8,col9)
                     self.wrObj.CFile(a,b)
                     self.wrObj.wFile(filename)
                     return 1
             class FITS:
                 name=None
                 format=None
                 array =None
                 data =None
                 thdulist=None
                 def __init__(self):
                     pass
                 def setColF(self,name,format,array):
                     self.name=name
                     self.format=format
                     self.array=array
                     a1=numpy.array([self.array],dtype=numpy.float32)
                     self.col1 = pyfits.Column(name=self.name, format=self.format, array=a1)
                     return self.col1
             #    def setColP(self,name,format,data):
             #        self.name=name
             #        self.format=format
             #        self.data=data
             #        a2=numpy.array([self.data],dtype=numpy.float32)
             #        self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
             #        return self.col2
                 def writeHeader(self,):
                     pass
                 def writeData(self,name,format,data):
                     self.name=name
                     self.format=format
                     self.data=data
                     a2=numpy.array([self.data],dtype=numpy.float32)
                     self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
                     return self.col2
                 def cFImage(self,n):
                     self.hdu= pyfits.PrimaryHDU(n)
                     return self.hdu
                 def Ctable(self,col1,col2,col3,col4,col5,col6,col7,col8,col9):
                     self.cols=pyfits.ColDefs( [col1,col2,col3,col4,col5,col6,col7,col8,col9])
                     self.tbhdu = pyfits.new_table(self.cols)
                     return self.tbhdu
                 def CFile(self,hdu,tbhdu):
                     self.thdulist=pyfits.HDUList([hdu,tbhdu])
                 def wFile(self,filename):
                     self.thdulist.writeto(filename)

schainpy/model/jroprocessing.py +15 -2

             '''
             $Author: dsuarez $
             $Id: Processor.py 1 2012-11-12 18:56:07Z dsuarez $
             '''
             import os
             import numpy
             import datetime
             import time
             from jrodata import *
             from jrodataIO import *
             from jroplot import *
             class ProcessingUnit:
                 """
                 Esta es la clase base para el procesamiento de datos.
                 Contiene el metodo "call" para llamar operaciones. Las operaciones pueden ser:
                     - Metodos internos (callMethod)
                     - Objetos del tipo Operation (callObject). Antes de ser llamados, estos objetos
                       tienen que ser agreagados con el metodo "add".
                 """
                 # objeto de datos de entrada (Voltage, Spectra o Correlation)
                 dataIn = None
                 # objeto de datos de entrada (Voltage, Spectra o Correlation)
                 dataOut = None
                 objectDict = None
                 def __init__(self):
                     self.objectDict = {}
+                def init(self):
+                    raise ValueError, "Not implemented"
                 def addOperation(self, object, objId):
                     """
                     Agrega el objeto "object" a la lista de objetos "self.objectList" y retorna el
                     identificador asociado a este objeto.
                     Input:
                         object    :    objeto de la clase "Operation"
                     Return:
                         objId    :    identificador del objeto, necesario para ejecutar la operacion
                     """
                     self.objectDict[objId] = object
                     return objId
                 def operation(self, **kwargs):
                     """
                     Operacion directa sobre la data (dataout.data). Es necesario actualizar los valores de los
                     atributos del objeto dataOut
                     Input:
                         **kwargs    :    Diccionario de argumentos de la funcion a ejecutar
                     """
                     raise ValueError, "ImplementedError"
                 def callMethod(self, name, **kwargs):
                     """
                     Ejecuta el metodo con el nombre "name" y con argumentos **kwargs de la propia clase.
                     Input:
                         name        :    nombre del metodo a ejecutar
                         **kwargs     :    diccionario con los nombres y valores de la funcion a ejecutar.
                     """
+                    if name != 'run':
+                        if name == 'init' and self.dataIn.isEmpty():
+                            return
+                        if name != 'init' and self.dataOut.isEmpty():
+                            return
                     methodToCall = getattr(self, name)
                     methodToCall(**kwargs)
                 def callObject(self, objId, **kwargs):
                     """
                     Ejecuta la operacion asociada al identificador del objeto "objId"
                     Input:
                         objId        :    identificador del objeto a ejecutar
                         **kwargs    :    diccionario con los nombres y valores de la funcion a ejecutar.
                     Return:
                         None
                     """
+                    if self.dataOut.isEmpty():
+                        return
                     object = self.objectDict[objId]
                     object.run(self.dataOut, **kwargs)
                 def call(self, operationConf, **kwargs):
                     """
                     Ejecuta la operacion "operationConf.name" con los argumentos "**kwargs". La operacion puede
                     ser de dos tipos:
 . Un metodo propio de esta clase:
                             operation.type = "self"
 . El metodo "run" de un objeto del tipo Operation o de un derivado de ella:
                             operation.type = "other".
                            Este objeto de tipo Operation debe de haber sido agregado antes con el metodo:
                            "addOperation" e identificado con el operation.id
                     con el id de la operacion.
                     Input:
                         Operation    :    Objeto del tipo operacion con los atributos: name, type y id.
                     """
-                    if self.dataIn.isEmpty():
-                        return None
                     if operationConf.type == 'self':
                         self.callMethod(operationConf.name, **kwargs)
                         return
                     if operationConf.type == 'other':
                         self.callObject(operationConf.id, **kwargs)
                         return
                 def setInput(self, dataIn):
                     self.dataIn = dataIn
                 def getOutput(self):
                     return self.dataOut
             class Operation():
                 """
                 Clase base para definir las operaciones adicionales que se pueden agregar a la clase ProcessingUnit
                 y necesiten acumular informacion previa de los datos a procesar. De preferencia usar un buffer de
                 acumulacion dentro de esta clase
                 Ejemplo: Integraciones coherentes, necesita la informacion previa de los n perfiles anteriores (bufffer)
                 """
                 __buffer = None
                 __isConfig = False
                 def __init__(self):
                     pass
                 def run(self, dataIn, **kwargs):
                     """
                     Realiza las operaciones necesarias sobre la dataIn.data y actualiza los atributos del objeto dataIn.
                     Input:
                         dataIn    :    objeto del tipo JROData
                     Return:
                         None
                     Affected:
                         __buffer    :    buffer de recepcion de datos.
                     """
                     raise ValueError, "ImplementedError"
             class VoltageProc(ProcessingUnit):
                 def __init__(self):
                     self.objectDict = {}
                     self.dataOut = Voltage()
                 def init(self):
                     self.dataOut.copy(self.dataIn)
                     # No necesita copiar en cada init() los atributos de dataIn
                     # la copia deberia hacerse por cada nuevo bloque de datos
                 def selectChannels(self, channelList):
                     if self.dataIn.isEmpty():
                         return 0
                     self.selectChannelsByIndex(channelList)
                 def selectChannelsByIndex(self, channelIndexList):
                     """
                     Selecciona un bloque de datos en base a canales segun el channelIndexList
                     Input:
                         channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
                         self.dataOut.data
                         self.dataOut.channelIndexList
                         self.dataOut.nChannels
                         self.dataOut.m_ProcessingHeader.totalSpectra
                         self.dataOut.systemHeaderObj.numChannels
                         self.dataOut.m_ProcessingHeader.blockSize
                     Return:
                         None
                     """
                     for channel in channelIndexList:
                         if channel not in self.dataOut.channelIndexList:
+                            print channelIndexList
                             raise ValueError, "The value %d in channelIndexList is not valid" %channel
                     nChannels = len(channelIndexList)
                     data = self.dataOut.data[channelIndexList,:]
                     self.dataOut.data = data
                     self.dataOut.channelIndexList = channelIndexList
                     self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
                     self.dataOut.nChannels = nChannels
                     return 1
             class CohInt(Operation):
                 __profIndex = 0
                 __withOverapping  = False
                 __byTime = False
                 __initime = None
                 __lastdatatime = None
                 __integrationtime = None
                 __buffer = None
                 __dataReady = False
                 nCohInt = None
                 def __init__(self):
                     self.__isConfig = False
                 def setup(self, nCohInt=None, timeInterval=None, overlapping=False):
                     """
                     Set the parameters of the integration class.
                     Inputs:
                         nCohInt        :    Number of coherent integrations
                         timeInterval   :    Time of integration. If the parameter "nCohInt" is selected this one does not work
                         overlapping    :
                     """
                     self.__initime = None
                     self.__lastdatatime = 0
                     self.__buffer = None
                     self.__dataReady = False
                     if nCohInt == None and timeInterval == None:
                         raise ValueError, "nCohInt or timeInterval should be specified ..."
                     if nCohInt != None:
                         self.nCohInt = nCohInt
                         self.__byTime = False
                     else:
                         self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
                         self.nCohInt = 9999
                         self.__byTime = True
                     if overlapping:
                         self.__withOverapping = True
                         self.__buffer = None
                     else:
                         self.__withOverapping = False
                         self.__buffer = 0
                     self.__profIndex = 0
                 def putData(self, data):
                     """
                     Add a profile to the __buffer and increase in one the __profileIndex
                     """
                     if not self.__withOverapping:
                         self.__buffer += data
                         self.__profIndex += 1
                         return
                     #Overlapping data
                     nChannels, nHeis = data.shape
                     data = numpy.reshape(data, (1, nChannels, nHeis))
                     #If the buffer is empty then it takes the data value
                     if self.__buffer == None:
                         self.__buffer = data
                         self.__profIndex += 1
                         return
                     #If the buffer length is lower than nCohInt then stakcing the data value
                     if self.__profIndex < self.nCohInt:
                         self.__buffer = numpy.vstack((self.__buffer, data))
                         self.__profIndex += 1
                         return
                     #If the buffer length is equal to nCohInt then replacing the last buffer value with the data value
                     self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
                     self.__buffer[self.nCohInt-1] = data
                     self.__profIndex = self.nCohInt
                     return
                 def pushData(self):
                     """
                     Return the sum of the last profiles and the profiles used in the sum.
                     Affected:
                     self.__profileIndex
                     """
                     if not self.__withOverapping:
                         data = self.__buffer
                         nCohInt = self.__profIndex
                         self.__buffer = 0
                         self.__profIndex = 0
                         return data, nCohInt
                     #Integration with Overlapping
                     data = numpy.sum(self.__buffer, axis=0)
                     nCohInt = self.__profIndex
                     return data, nCohInt
                 def byProfiles(self, data):
                     self.__dataReady = False
                     avgdata = None
                     nCohInt = None
                     self.putData(data)
                     if self.__profIndex == self.nCohInt:
                         avgdata, nCohInt = self.pushData()
                         self.__dataReady = True
                     return avgdata
                 def byTime(self, data, datatime):
                     self.__dataReady = False
                     avgdata = None
                     nCohInt = None
                     self.putData(data)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avgdata, nCohInt = self.pushData()
                         self.nCohInt = nCohInt
                         self.__dataReady = True
                     return avgdata
                 def integrate(self, data, datatime=None):
                     if self.__initime == None:
                         self.__initime = datatime
                     if self.__byTime:
                         avgdata = self.byTime(data, datatime)
                     else:
                         avgdata = self.byProfiles(data)
                     self.__lastdatatime = datatime
                     if avgdata == None:
                         return None, None
                     avgdatatime = self.__initime
                     deltatime = datatime -self.__lastdatatime
                     if not self.__withOverapping:
                         self.__initime = datatime
                     else:
                         self.__initime += deltatime
                     return avgdata, avgdatatime
                 def run(self, dataOut, nCohInt=None, timeInterval=None, overlapping=False):
                     if not self.__isConfig:
                         self.setup(nCohInt, timeInterval, overlapping)
                         self.__isConfig = True
                     avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
             #        dataOut.timeInterval *= nCohInt
                     dataOut.flagNoData = True
                     if self.__dataReady:
                         dataOut.data = avgdata
                         dataOut.timeInterval *= self.nCohInt
                         dataOut.nCohInt *= self.nCohInt
                         dataOut.utctime = avgdatatime
                         dataOut.flagNoData = False
             class SpectraProc(ProcessingUnit):
                 def __init__(self):
                     self.objectDict = {}
                     self.buffer = None
                     self.firstdatatime = None
                     self.profIndex = 0
                     self.dataOut = Spectra()
                 def init(self, nFFTPoints=None, pairsList=None):
                     if self.dataIn.type == "Spectra":
                         self.dataOut.copy(self.dataIn)
                         return
                     if self.dataIn.type == "Voltage":
                         if nFFTPoints == None:
                             raise ValueError, "This SpectraProc.setup() need nFFTPoints input variable"
                         if pairsList == None:
                             nPairs = 0
                         else:
                             nPairs = len(pairsList)
                         self.dataOut.nFFTPoints = nFFTPoints
                         self.dataOut.pairsList = pairsList
                         self.dataOut.nPairs = nPairs
                         if self.buffer == None:
                             self.buffer = numpy.zeros((self.dataIn.nChannels,
                                                        self.dataOut.nFFTPoints,
                                                        self.dataIn.nHeights),
                                                        dtype='complex')
                         self.buffer[:,self.profIndex,:] = self.dataIn.data
                         self.profIndex += 1
                         if self.firstdatatime == None:
                             self.firstdatatime = self.dataIn.utctime
                         if self.profIndex == self.dataOut.nFFTPoints:
                             self.__updateObjFromInput()
                             self.__getFft()
                             self.dataOut.flagNoData = False
                             self.buffer = None
                             self.firstdatatime = None
                             self.profIndex = 0
                         return
                     raise ValuError, "The type object %s is not valid"%(self.dataIn.type)
                 def __updateObjFromInput(self):
                     self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
                     self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.dtype = self.dataIn.dtype
                     self.dataOut.nHeights = self.dataIn.nHeights
                     self.dataOut.nChannels = self.dataIn.nChannels
                     self.dataOut.nBaud = self.dataIn.nBaud
                     self.dataOut.nCode = self.dataIn.nCode
                     self.dataOut.code = self.dataIn.code
                     self.dataOut.nProfiles = self.dataOut.nFFTPoints
                     self.dataOut.channelIndexList = self.dataIn.channelIndexList
                     self.dataOut.flagTimeBlock = self.dataIn.flagTimeBlock
                     self.dataOut.utctime = self.firstdatatime
                     self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
                     self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
                     self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                     self.dataOut.nIncohInt = 1
                     self.dataOut.ippSeconds = self.dataIn.ippSeconds
                     self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nFFTPoints
                 def __getFft(self):
                     """
                     Convierte valores de Voltaje a Spectra
                     Affected:
                         self.dataOut.data_spc
                         self.dataOut.data_cspc
                         self.dataOut.data_dc
                         self.dataOut.heightList
                         self.dataOut.m_BasicHeader
                         self.dataOut.m_ProcessingHeader
                         self.dataOut.radarControllerHeaderObj
                         self.dataOut.systemHeaderObj
                         self.profIndex
                         self.buffer
                         self.dataOut.flagNoData
                         self.dataOut.dtype
                         self.dataOut.nPairs
                         self.dataOut.nChannels
                         self.dataOut.nProfiles
                         self.dataOut.systemHeaderObj.numChannels
                         self.dataOut.m_ProcessingHeader.totalSpectra
                         self.dataOut.m_ProcessingHeader.profilesPerBlock
                         self.dataOut.m_ProcessingHeader.numHeights
                         self.dataOut.m_ProcessingHeader.spectraComb
                         self.dataOut.m_ProcessingHeader.shif_fft
                     """
                     fft_volt = numpy.fft.fft(self.buffer,axis=1)
                     dc = fft_volt[:,0,:]
                     #calculo de self-spectra
                     fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
                     spc = fft_volt * numpy.conjugate(fft_volt)
                     spc = spc.real
                     blocksize = 0
                     blocksize += dc.size
                     blocksize += spc.size
                     cspc = None
                     pairIndex = 0
                     if self.dataOut.pairsList != None:
                         #calculo de cross-spectra
                         cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
                         for pair in self.dataOut.pairsList:
                             cspc[pairIndex,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
                             pairIndex += 1
                         blocksize += cspc.size
                     self.dataOut.data_spc = spc
                     self.dataOut.data_cspc = cspc
                     self.dataOut.data_dc = dc
                     self.dataOut.blockSize = blocksize
             class IncohInt(Operation):
                 def __init__(self):
                     pass

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