schain-jc Commit - r199:83ce53852b6c

Primera version del controlador probada y testeada incluyendo graficos

Miguel Valdez -

r199:83ce53852b6c

parent child

Context file:

r199:83ce53852b6c

Collapse all files

schainpy/controller.py ~~schainpy/schain.py~~ renamed +84 -59

             import datetime
             from model.jrodataIO import *
             from model.jroprocessing import *
+            from model.jroplot import *
             def prettify(elem):
                 """Return a pretty-printed XML string for the Element.
                 id = None
                 name = None
                 value = None
-                type = None
+                format = None
                 ELEMENTNAME = 'Parameter'
                 def __init__(self):
-                    self.type = 'str'
+                    self.format = 'str'
                 def getElementName(self):
                 def getValue(self):
-                    if self.type == 'list':
+                    if self.format == 'list':
                         strList = self.value.split(',')
                         return strList
-                    if self.type == 'intlist':
+                    if self.format == 'intlist':
                         strList = self.value.split(',')
                         intList = [int(x) for x in strList]
                         return intList
-                    if self.type == 'floatlist':
+                    if self.format == 'floatlist':
                         strList = self.value.split(',')
                         floatList = [float(x) for x in strList]
                         return floatList
-                    if self.type == 'date':
+                    if self.format == 'date':
                         strList = self.value.split('/')
                         intList = [int(x) for x in strList]
                         date = datetime.date(intList[0], intList[1], intList[2])
                         return date
-                    if self.type == 'time':
+                    if self.format == 'time':
                         strList = self.value.split(':')
                         intList = [int(x) for x in strList]
                         time = datetime.time(intList[0], intList[1], intList[2])
                         return time
-                    func = eval(self.type)
+                    func = eval(self.format)
                     return func(self.value)
-                def setup(self, id, name, value, type='str'):
+                def setup(self, id, name, value, format='str'):
                     self.id = id
                     self.name = name
                     self.value = str(value)
-                    self.type = type
+                    self.format = format
                 def makeXml(self, opElement):
                     parmElement.set('id', str(self.id))
                     parmElement.set('name', self.name)
                     parmElement.set('value', self.value)
-                    parmElement.set('type', self.type)
+                    parmElement.set('format', self.format)
                 def readXml(self, parmElement):
                     self.id = parmElement.get('id')
                     self.name = parmElement.get('name')
                     self.value = parmElement.get('value')
-                    self.type = parmElement.get('type')
+                    self.format = parmElement.get('format')
                 def printattr(self):
-                    print "Parameter[%s]: name = %s, value = %s, type = %s" %(self.id, self.name, self.value, self.type)
+                    print "Parameter[%s]: name = %s, value = %s, format = %s" %(self.id, self.name, self.value, self.format)
             class OperationConf():
                     self.parmConfObjList = []
-                def addParameter(self, name, value, type='str'):
+                def addParameter(self, name, value, format='str'):
                     id = self.__getNewId()
                     parmConfObj = ParameterConf()
-                    parmConfObj.setup(id, name, value, type)
+                    parmConfObj.setup(id, name, value, format)
                     self.parmConfObjList.append(parmConfObj)
                 id = None
                 name = None
-                type = None
+                datatype = None
                 inputId = None
                 opConfObjList = []
                 def __init__(self):
                     self.id = None
-                    self.type = None
+                    self.datatype = None
                     self.name = None
                     self.inputId = None
                     return self.procUnitObj
-                def setup(self, id, name, type, inputId):
+                def setup(self, id, name, datatype, inputId):
                     self.id = id
                     self.name = name
-                    self.type = type
+                    self.datatype = datatype
                     self.inputId = inputId
                     self.opConfObjList = []
                     upElement = SubElement(procUnitElement, self.ELEMENTNAME)
                     upElement.set('id', str(self.id))
                     upElement.set('name', self.name)
-                    upElement.set('type', self.type)
+                    upElement.set('datatype', self.datatype)
                     upElement.set('inputId', str(self.inputId))
                     for opConfObj in self.opConfObjList:
                     self.id = upElement.get('id')
                     self.name = upElement.get('name')
-                    self.type = upElement.get('type')
+                    self.datatype = upElement.get('datatype')
                     self.inputId = upElement.get('inputId')
                     self.opConfObjList = []
                 def printattr(self):
-                    print "%s[%s]: name = %s, type = %s, inputId = %s" %(self.ELEMENTNAME,
+                    print "%s[%s]: name = %s, datatype = %s, inputId = %s" %(self.ELEMENTNAME,
                                                                          self.id,
                                                                          self.name,
-                                                                         self.type,
+                                                                         self.datatype,
                                                                          self.inputId)
                     for opConfObj in self.opConfObjList:
                 def run(self):
+                    finalSts = False
                     for opConfObj in self.opConfObjList:
                         kwargs = {}
                         for parmConfObj in opConfObj.getParameterObjList():
                             kwargs[parmConfObj.name] = parmConfObj.getValue()
-                        self.procUnitObj.call(opConfObj, **kwargs)
+                        #print "\tRunning the '%s' operation with %s" %(opConfObj.name, opConfObj.id)
+                        sts = self.procUnitObj.call(opConfObj, **kwargs)
+                        finalSts = finalSts or sts
+                    return finalSts
             class ReadUnitConf(ProcUnitConf):
                 path = None
                 startDate = None
                 endDate = None
                 def __init__(self):
                     self.id = None
-                    self.type = None
+                    self.datatype = None
                     self.name = None
                     self.inputId = 0
                     return self.ELEMENTNAME
-                def setup(self, id, name, type, path, startDate, endDate, startTime, endTime, online=0, expLabel='', delay=60):
+                def setup(self, id, name, datatype, path, startDate, endDate, startTime, endTime, online=0, expLabel='', delay=60):
                     self.id = id
                     self.name = name
-                    self.type = type
+                    self.datatype = datatype
                     self.path = path
                     self.startDate = startDate
                     opObj = self.addOperation(name = 'run', optype = 'self')
-                    opObj.addParameter(name='path'     , value=self.path, type='str')
+                    opObj.addParameter(name='path'     , value=self.path, format='str')
-                    opObj.addParameter(name='startDate' , value=self.startDate, type='date')
+                    opObj.addParameter(name='startDate' , value=self.startDate, format='date')
-                    opObj.addParameter(name='endDate'   , value=self.endDate, type='date')
+                    opObj.addParameter(name='endDate'   , value=self.endDate, format='date')
-                    opObj.addParameter(name='startTime' , value=self.startTime, type='time')
+                    opObj.addParameter(name='startTime' , value=self.startTime, format='time')
-                    opObj.addParameter(name='endTime'   , value=self.endTime, type='time')
+                    opObj.addParameter(name='endTime'   , value=self.endTime, format='time')
-                    opObj.addParameter(name='expLabel'  , value=self.expLabel, type='str')
+                    opObj.addParameter(name='expLabel'  , value=self.expLabel, format='str')
-                    opObj.addParameter(name='online'  , value=self.online, type='bool')
+                    opObj.addParameter(name='online'  , value=self.online, format='int')
-                    opObj.addParameter(name='delay'  , value=self.delay, type='float')
+                    opObj.addParameter(name='delay'  , value=self.delay, format='float')
                     return opObj
                     self.name = name
                     self.description = description
-                def addReadUnit(self, type, path, startDate='', endDate='', startTime='', endTime='', online=0, expLabel='', delay=60):
+                def addReadUnit(self, datatype, path, startDate='', endDate='', startTime='', endTime='', online=0, expLabel='', delay=60):
                     id = self.__getNewId()
-                    name = '%sReader' %(type)
+                    name = '%sReader' %(datatype)
                     readUnitConfObj = ReadUnitConf()
-                    readUnitConfObj.setup(id, name, type, path, startDate, endDate, startTime, endTime, online, expLabel, delay)
+                    readUnitConfObj.setup(id, name, datatype, path, startDate, endDate, startTime, endTime, online, expLabel, delay)
                     self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     return readUnitConfObj
-                def addProcUnit(self, type, inputId):
+                def addProcUnit(self, datatype, inputId):
                     id = self.__getNewId()
-                    name = '%sProc' %(type)
+                    name = '%sProc' %(datatype)
                     procUnitConfObj = ProcUnitConf()
-                    procUnitConfObj.setup(id, name, type, inputId)
+                    procUnitConfObj.setup(id, name, datatype, inputId)
                     self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
             #        for readUnitConfObj in self.readUnitConfObjList:
             #            readUnitConfObj.run()
                     while(True):
+                        finalSts = False
                         for procUnitConfObj in self.procUnitConfObjDict.values():
-                            procUnitConfObj.run()
+                            #print "Running the '%s' process with %s" %(procUnitConfObj.name, procUnitConfObj.id)
+                            sts = procUnitConfObj.run()
+                            finalSts = finalSts or sts
+                        #If every process unit finished so end process
+                        if not(finalSts):
+                            print "Every process unit finished"
+                            break
             if __name__ == '__main__':
                 controllerObj.setup(id = '191', name='test01', description=desc)
-                readUnitConfObj = controllerObj.addReadUnit(type='Voltage',
+                readUnitConfObj = controllerObj.addReadUnit(datatype='Spectra',
-                                                            path='/home/roj-idl71/Data/RAWDATA/Meteors',
+                                                            path='D:\Data\IMAGING',
-                                                            startDate='2012/01/01',
+                                                            startDate='2011/01/01',
                                                             endDate='2012/12/31',
                                                             startTime='00:00:00',
                                                             endTime='23:59:59',
                                                             online=0)
-                procUnitConfObj1 = controllerObj.addProcUnit(type='Voltage', inputId=readUnitConfObj.getId())
+                opObj00 = readUnitConfObj.addOperation(name='printTotalBlocks')
-                procUnitConfObj2 = controllerObj.addProcUnit(type='Voltage', inputId=procUnitConfObj1.getId())
+                procUnitConfObj1 = controllerObj.addProcUnit(datatype='Spectra', inputId=readUnitConfObj.getId())
-                opObj11 = procUnitConfObj1.addOperation(name='selectChannels')
+                opObj10 = procUnitConfObj1.addOperation(name='selectChannels')
-                opObj11.addParameter(name='channelList', value='1,2', type='intlist')
+                opObj10.addParameter(name='channelList', value='0,1', format='intlist')
+                opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='other')
+                opObj11.addParameter(name='idfigure', value='1', format='int')
+                opObj11.addParameter(name='wintitle', value='SpectraPlot', format='str')
+                opObj11.addParameter(name='zmin', value='60', format='int')
+                opObj11.addParameter(name='zmax', value='100', format='int')
             #    opObj12 = procUnitConfObj1.addOperation(name='decoder')
-            #    opObj12.addParameter(name='ncode', value='2', type='int')
+            #    opObj12.addParameter(name='ncode', value='2', format='int')
-            #    opObj12.addParameter(name='nbauds', value='8', type='int')
+            #    opObj12.addParameter(name='nbauds', value='8', format='int')
-            #    opObj12.addParameter(name='code0', value='001110011', type='int')
+            #    opObj12.addParameter(name='code0', value='001110011', format='int')
-            #    opObj12.addParameter(name='code1', value='001110011', type='int')
+            #    opObj12.addParameter(name='code1', value='001110011', format='int')
+            #    procUnitConfObj2 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj1.getId())
-                opObj21 = procUnitConfObj2.addOperation(name='CohInt', optype='other')
+            #    opObj21 = procUnitConfObj2.addOperation(name='IncohInt', optype='other')
-                opObj21.addParameter(name='nCohInt', value='10', type='int')
+            #    opObj21.addParameter(name='nCohInt', value='10', format='int')
                 print "Escribiendo el archivo XML"

schainpy/model/graphics/mpldriver.py +7 -1

             import matplotlib
-            matplotlib.use("Agg")
+            matplotlib.use("TKAgg")
             import matplotlib.pyplot
             #import scitools.numpyutils
             from mpl_toolkits.axes_grid1 import make_axes_locatable
                     matplotlib.pyplot.tight_layout()
                     return imesh
                 else:
+                    ax.set_xlim([xmin,xmax])
+                    ax.set_ylim([ymin,ymax])
+                    ax.set_xlabel(xlabel)
+                    ax.set_ylabel(ylabel)
+                    ax.set_title(title)
                     z = z.T
                     z = z[0:-1,0:-1]
                     mesh.set_array(z.ravel())

schainpy/model/jrodata.py +178 -2

@@ -10,6 +10,99 import numpy
10		10
11	from jroheaderIO import SystemHeader, RadarControllerHeader	11	from jroheaderIO import SystemHeader, RadarControllerHeader
12		12
		13	def hildebrand_sekhon(data, navg):
		14	"""
		15	This method is for the objective determination of de noise level in Doppler spectra. This
		16	implementation technique is based on the fact that the standard deviation of the spectral
		17	densities is equal to the mean spectral density for white Gaussian noise
		18
		19	Inputs:
		20	Data : heights
		21	navg : numbers of averages
		22
		23	Return:
		24	-1 : any error
		25	anoise : noise's level
		26	"""
		27
		28	dataflat = data.reshape(-1)
		29	dataflat.sort()
		30	npts = dataflat.size #numbers of points of the data
		31
		32	if npts < 32:
		33	print "error in noise - requires at least 32 points"
		34	return -1.0
		35
		36	dataflat2 = numpy.power(dataflat,2)
		37
		38	cs = numpy.cumsum(dataflat)
		39	cs2 = numpy.cumsum(dataflat2)
		40
		41	# data sorted in ascending order
		42	nmin = int((npts + 7.)/8)
		43
		44	for i in range(nmin, npts):
		45	s = cs[i]
		46	s2 = cs2[i]
		47	p = s / float(i);
		48	p2 = p**2;
		49	q = s2 / float(i) - p2;
		50	leftc = p2;
		51	rightc = q * float(navg);
		52	R2 = leftc/rightc
		53
		54	# Signal detect: R2 < 1 (R2 = leftc/rightc)
		55	if R2 < 1:
		56	npts_noise = i
		57	break
		58
		59
		60	anoise = numpy.average(dataflat[0:npts_noise])
		61
		62	return anoise;
		63
		64	def sorting_bruce(Data, navg):
		65	sortdata = numpy.sort(Data)
		66	lenOfData = len(Data)
		67	nums_min = lenOfData/10
		68
		69	if (lenOfData/10) > 0:
		70	nums_min = lenOfData/10
		71	else:
		72	nums_min = 0
		73
		74	rtest = 1.0 + 1.0/navg
		75
		76	sum = 0.
		77
		78	sumq = 0.
		79
		80	j = 0
		81
		82	cont = 1
		83
		84	while((cont==1)and(j<lenOfData)):
		85
		86	sum += sortdata[j]
		87
		88	sumq += sortdata[j]**2
		89
		90	j += 1
		91
		92	if j > nums_min:
		93	if ((sumqj) <= (rtestsum**2)):
		94	lnoise = sum / j
		95	else:
		96	j = j - 1
		97	sum = sum - sordata[j]
		98	sumq = sumq - sordata[j]**2
		99	cont = 0
		100
		101	if j == nums_min:
		102	lnoise = sum /j
		103
		104	return lnoise
		105
13	class JROData:	106	class JROData:
14		107
15	# m_BasicHeader = BasicHeader()	108	# m_BasicHeader = BasicHeader()
@@ -60,6 +153,10 class JROData:
60	ippSeconds = None	153	ippSeconds = None
61		154
62	timeInterval = None	155	timeInterval = None
		156
		157	nCohInt = None
		158
		159	noise = None
63		160
64	def __init__(self):	161	def __init__(self):
65		162
@@ -83,8 +180,6 class JROData:
83		180
84	class Voltage(JROData):	181	class Voltage(JROData):
85		182
86	nCohInt = None
87
88	#data es un numpy array de 2 dmensiones (canales, alturas)	183	#data es un numpy array de 2 dmensiones (canales, alturas)
89	data = None	184	data = None
90		185
@@ -124,7 +219,30 class Voltage(JROData):
124	self.nCohInt = None	219	self.nCohInt = None
125		220
126	self.blocksize = None	221	self.blocksize = None
		222
		223	def getNoisebyHildebrand(self):
		224	"""
		225	Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
		226
		227	Return:
		228	noiselevel
		229	"""
127		230
		231	for channel in range(self.nChannels):
		232	daux = self.data_spc[channel,:,:]
		233	self.noise[channel] = hildebrand_sekhon(daux, self.nCohInt)
		234
		235	return self.noise
		236
		237	def getNoise(self, type = 1):
		238
		239	self.noise = numpy.zeros(self.nChannels)
		240
		241	if type == 1:
		242	noise = self.getNoisebyHildebrand()
		243
		244	return 10*numpy.log10(noise)
		245
128	class Spectra(JROData):	246	class Spectra(JROData):
129		247
130	#data es un numpy array de 2 dmensiones (canales, perfiles, alturas)	248	#data es un numpy array de 2 dmensiones (canales, perfiles, alturas)
@@ -181,6 +299,8 class Spectra(JROData):
181		299
182	self.utctime = None	300	self.utctime = None
183		301
		302	self.nCohInt = None
		303
184	self.nIncohInt = None	304	self.nIncohInt = None
185		305
186	self.blocksize = None	306	self.blocksize = None
@@ -194,7 +314,63 class Spectra(JROData):
194	xrange = numpy.arange(self.nFFTPoints)	314	xrange = numpy.arange(self.nFFTPoints)
195	xrange = xrange	315	xrange = xrange
196	return None	316	return None
		317
		318	def getNoisebyHildebrand(self):
		319	"""
		320	Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
		321
		322	Return:
		323	noiselevel
		324	"""
		325
		326	for channel in range(self.nChannels):
		327	daux = self.data_spc[channel,:,:]
		328	self.noise[channel] = hildebrand_sekhon(daux, self.nIncohInt)
		329
		330	return self.noise
		331
		332	def getNoisebyWindow(self, heiIndexMin=0, heiIndexMax=-1, freqIndexMin=0, freqIndexMax=-1):
		333	"""
		334	Determina el ruido del canal utilizando la ventana indicada con las coordenadas:
		335	(heiIndexMIn, freqIndexMin) hasta (heiIndexMax, freqIndexMAx)
		336
		337	Inputs:
		338	heiIndexMin: Limite inferior del eje de alturas
		339	heiIndexMax: Limite superior del eje de alturas
		340	freqIndexMin: Limite inferior del eje de frecuencia
		341	freqIndexMax: Limite supoerior del eje de frecuencia
		342	"""
		343
		344	data = self.data_spc[:, heiIndexMin:heiIndexMax, freqIndexMin:freqIndexMax]
		345
		346	for channel in range(self.nChannels):
		347	daux = data[channel,:,:]
		348	self.noise[channel] = numpy.average(daux)
		349
		350	return self.noise
		351
		352	def getNoisebySort(self):
		353
		354	for channel in range(self.nChannels):
		355	daux = self.data_spc[channel,:,:]
		356	self.noise[channel] = sorting_bruce(daux, self.nIncohInt)
		357
		358	return self.noise
		359
		360	def getNoise(self, type = 1):
		361
		362	self.noise = numpy.zeros(self.nChannels)
		363
		364	if type == 1:
		365	noise = self.getNoisebyHildebrand()
		366
		367	if type == 2:
		368	noise = self.getNoisebySort()
		369
		370	if type == 3:
		371	noise = self.getNoisebyWindow()
197		372
		373	return 10*numpy.log10(noise)
198		374
199	class SpectraHeis(JROData):	375	class SpectraHeis(JROData):
200		376

schainpy/model/jrodataIO.py +37 -35

                 ext = None
-                flagNoMoreFiles = 0
                 flagIsNewFile = 1
                 flagTimeBlock = 0
                 nTries  = 3  #quantity tries
                 nFiles = 3   #number of files for searching
+                flagNoMoreFiles = 0
                 def __init__(self):
                             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)
+                                doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext)
                                 if doypath:
                                     break
                     return self.dataOut
                 def getData():
-                    pass
+                    raise ValueError, "This method has not been implemented"
                 def hasNotDataInBuffer():
-                    pass
+                    raise ValueError, "This method has not been implemented"
                 def readBlock():
-                    pass
+                    raise ValueError, "This method has not been implemented"
+                def isEndProcess(self):
+                    return self.flagNoMoreFiles
+                def printReadBlocks(self):
+                    print "Number of read blocks per file %04d" %self.nReadBlocks
+                def printTotalBlocks(self):
+                    print "Number of read blocks %04d" %self.nTotalBlocks
                 def run(self, **kwargs):
                     if not(self.isConfig):
                         self.flagTimeBlock
                         self.flagIsNewBlock
                     """
-                    if self.flagNoMoreFiles: return 0
+                    if self.flagNoMoreFiles:
+                        self.dataOut.flagNoData = True
+                        print 'Process finished'
+                        return 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                             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)
                     self.nTotalBlocks = 0
                     self.flagIsNewBlock = 0
-                    self.flagNoMoreFiles = 0
                     self.setFile = None
                     self.path = None
-                    self.noMoreFiles = 0
                     self.filename = None
                     self.basicHeaderObj = BasicHeader()
                         self.writeNextBlock()
             #            self.getDataHeader()
-                    if self.flagNoMoreFiles:
-                        #print 'Process finished'
-                        return 0
                     return 1
                 def __getProcessFlags(self):
                     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
+                        #desplaza a la derecha en el eje 2 determinadas posiciones
+                        shift = int(self.processingHeaderObj.profilesPerBlock/2)
+                        spc = numpy.roll( spc, shift , axis=2 )
                         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
+                            #desplaza a la derecha en el eje 2 determinadas posiciones
+                            cspc = numpy.roll( cspc, shift, axis=2 )
                     spc = numpy.transpose( spc, (0,2,1) )
                         self.flagIsNewBlock
                     """
-                    if self.flagNoMoreFiles: return 0
+                    if self.flagNoMoreFiles:
+                        self.dataOut.flagNoData = True
+                        print 'Process finished'
+                        return 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not( self.readNextBlock() ):
+                            self.dataOut.flagNoData = True
                             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.nTotalBlocks = 0
                     self.flagIsNewBlock = 0
-                    self.flagNoMoreFiles = 0
                     self.setFile = None
             #            self.getDataHeader()
                         self.writeNextBlock()
-                    if self.flagNoMoreFiles:
-                        #print 'Process finished'
-                        return 0
                     return 1

schainpy/model/jroplot.py +25 -18

             from graphics.figure import  *
             class SpectraPlot(Figure):
                 __isConfig = None
                 def __init__(self):
                     self.__isConfig = False
                     self.width = 850
                     self.height = 800
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setAxesWithOutProfiles(self, nrow, ncol):
                     colspan = 1
                     rowspan = 1
                     counter = 0
                             counter += 1
                 def setAxesWithProfiles(self, nrow, ncol):
                     colspan = 1
                     rowspan = 1
                     factor = 2
                             counter += 1
                 def setup(self, idfigure, wintitle, width, height, nplots, profile):
                     self.init(idfigure, wintitle, width, height, nplots)
                     nrow,ncol = self.getSubplots()
                         self.setAxesWithOutProfiles(nrow, ncol)
                 def run(self, dataOut, idfigure, wintitle="", channelList=None, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, profile=False):
-                    if dataOut.isEmpty():
-                        return None
                     if channelList == None:
                         channelList = dataOut.channelList
                     x = numpy.arange(dataOut.nFFTPoints)
+                    noise = dataOut.getNoise()
                     if not self.__isConfig:
                         self.setup(idfigure=idfigure,
                                    wintitle=wintitle,
                                    nplots=nplots,
                                    profile=profile)
-                        if xmin == None: self.xmin = numpy.min(x)
+                        if xmin == None: xmin = numpy.min(x)
-                        if xmax == None: self.xmax = numpy.max(x)
+                        if xmax == None: xmax = numpy.max(x)
-                        if ymin == None: self.ymin = numpy.min(y)
+                        if ymin == None: ymin = numpy.min(y)
-                        if ymax == None: self.ymax = numpy.max(y)
+                        if ymax == None: ymax = numpy.max(y)
-                        if zmin == None: self.zmin = 0
+                        if zmin == None: zmin = numpy.min(z)
-                        if zmax == None: self.zmax = 90
+                        if zmax == None: zmax = numpy.max(z)
+                        self.xmin = xmin
+                        self.xmax = xmax
+                        self.ymin = ymin
+                        self.ymax = ymax
+                        self.zmin = zmin
+                        self.zmax = zmax
                         self.__isConfig = True
                     thisDatetime = datetime.datetime.fromtimestamp(dataOut.utctime)
                     xlabel = "m/s"
                     for i in range(len(self.axesList)):
-                        title = "Channel %d"%i
+                        title = "Channel %d: %4.2fdB" %(i, noise[i])
                         axes = self.axesList[i]
                         z2 = z[i,:,:]
                         axes.pcolor(x, y, z2, self.xmin, self.xmax, self.ymin, self.ymax, self.zmin, self.zmax, xlabel, ylabel, title)
                     self.draw()
             class Scope(Figure):
                 __isConfig = None
                     xlabel = "Range[Km]"
                     for i in range(len(self.axesList)):
-                        title = "Channel %d"%i
+                        title = "Channel %d: %4.2fdB" %(i, noise[i])
                         axes = self.axesList[i]
                         y2 = y[i,:]
                         axes.pline(x, y2, self.xmin, self.xmax, self.ymin, self.ymax, xlabel, ylabel, title)

schainpy/model/jroprocessing.py +109 -59

@@ -86,15 +86,24 class ProcessingUnit:
86	if name != 'run':	86	if name != 'run':
87		87
88	if name == 'init' and self.dataIn.isEmpty():	88	if name == 'init' and self.dataIn.isEmpty():
89	return	89	self.dataOut.flagNoData = True
		90	return False
90		91
91	if name != 'init' and self.dataOut.isEmpty():	92	if name != 'init' and self.dataOut.isEmpty():
92	return	93	return False
93		94
94	methodToCall = getattr(self, name)	95	methodToCall = getattr(self, name)
95		96
96	methodToCall(**kwargs)	97	methodToCall(**kwargs)
97		98
		99	if name != 'run':
		100	return True
		101
		102	if self.dataOut.isEmpty():
		103	return False
		104
		105	return True
		106
98	def callObject(self, objId, **kwargs):	107	def callObject(self, objId, **kwargs):
99		108
100	"""	109	"""
@@ -112,17 +121,20 class ProcessingUnit:
112	"""	121	"""
113		122
114	if self.dataOut.isEmpty():	123	if self.dataOut.isEmpty():
115	return	124	return False
116		125
117	object = self.objectDict[objId]	126	object = self.objectDict[objId]
118		127
119	object.run(self.dataOut, **kwargs)	128	object.run(self.dataOut, **kwargs)
		129
		130	return True
120		131
121	def call(self, operationConf, **kwargs):	132	def call(self, operationConf, **kwargs):
122		133
123	"""	134	"""
124	Ejecuta la operacion "operationConf.name" con los ~~argumentos "**kwargs". La operacion puede~~	135	Return True si ejecuta la operacion "operationConf.name" con los
125	ser de dos tipos:	136	argumentos "**kwargs". False si la operacion no se ha ejecutado.
		137	La operacion puede ser de dos tipos:
126		138
127	1. Un metodo propio de esta clase:	139	1. Un metodo propio de esta clase:
128		140
@@ -144,12 +156,12 class ProcessingUnit:
144	"""	156	"""
145		157
146	if operationConf.type == 'self':	158	if operationConf.type == 'self':
147	self.callMethod(operationConf.name, **kwargs)	159	sts = self.callMethod(operationConf.name, **kwargs)
148	return
149		160
150	if operationConf.type == 'other':	161	if operationConf.type == 'other':
151	self.callObject(operationConf.id, **kwargs)	162	sts = self.callObject(operationConf.id, **kwargs)
152	~~return~~	163
		164	return sts
153		165
154	def setInput(self, dataIn):	166	def setInput(self, dataIn):
155		167
@@ -213,9 +225,6 class VoltageProc(ProcessingUnit):
213		225
214	def selectChannels(self, channelList):	226	def selectChannels(self, channelList):
215		227
216	if self.dataIn.isEmpty():
217	return 0
218
219	self.selectChannelsByIndex(channelList)	228	self.selectChannelsByIndex(channelList)
220		229
221	def selectChannelsByIndex(self, channelIndexList):	230	def selectChannelsByIndex(self, channelIndexList):
@@ -451,58 +460,13 class CohInt(Operation):
451	class SpectraProc(ProcessingUnit):	460	class SpectraProc(ProcessingUnit):
452		461
453	def __init__(self):	462	def __init__(self):
		463
454	self.objectDict = {}	464	self.objectDict = {}
455	self.buffer = None	465	self.buffer = None
456	self.firstdatatime = None	466	self.firstdatatime = None
457	self.profIndex = 0	467	self.profIndex = 0
458	self.dataOut = Spectra()	468	self.dataOut = Spectra()
459		469
460	def init(self, nFFTPoints=None, pairsList=None):
461	if self.dataIn.type == "Spectra":
462	self.dataOut.copy(self.dataIn)
463	return
464
465	if self.dataIn.type == "Voltage":
466
467	if nFFTPoints == None:
468	raise ValueError, "This SpectraProc.setup() need nFFTPoints input variable"
469
470	if pairsList == None:
471	nPairs = 0
472	else:
473	nPairs = len(pairsList)
474
475	self.dataOut.nFFTPoints = nFFTPoints
476	self.dataOut.pairsList = pairsList
477	self.dataOut.nPairs = nPairs
478
479	if self.buffer == None:
480	self.buffer = numpy.zeros((self.dataIn.nChannels,
481	self.dataOut.nFFTPoints,
482	self.dataIn.nHeights),
483	dtype='complex')
484
485
486	self.buffer[:,self.profIndex,:] = self.dataIn.data
487	self.profIndex += 1
488
489	if self.firstdatatime == None:
490	self.firstdatatime = self.dataIn.utctime
491
492	if self.profIndex == self.dataOut.nFFTPoints:
493	self.__updateObjFromInput()
494	self.__getFft()
495
496	self.dataOut.flagNoData = False
497
498	self.buffer = None
499	self.firstdatatime = None
500	self.profIndex = 0
501
502	return
503
504	raise ValuError, "The type object %s is not valid"%(self.dataIn.type)
505
506	def __updateObjFromInput(self):	470	def __updateObjFromInput(self):
507		471
508	self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()	472	self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
@@ -526,7 +490,7 class SpectraProc(ProcessingUnit):
526	self.dataOut.nIncohInt = 1	490	self.dataOut.nIncohInt = 1
527	self.dataOut.ippSeconds = self.dataIn.ippSeconds	491	self.dataOut.ippSeconds = self.dataIn.ippSeconds
528	self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nFFTPoints	492	self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nFFTPoints
529		493
530	def __getFft(self):	494	def __getFft(self):
531	"""	495	"""
532	Convierte valores de Voltaje a Spectra	496	Convierte valores de Voltaje a Spectra
@@ -580,6 +544,92 class SpectraProc(ProcessingUnit):
580	self.dataOut.data_cspc = cspc	544	self.dataOut.data_cspc = cspc
581	self.dataOut.data_dc = dc	545	self.dataOut.data_dc = dc
582	self.dataOut.blockSize = blocksize	546	self.dataOut.blockSize = blocksize
		547
		548	def init(self, nFFTPoints=None, pairsList=None):
		549
		550	if self.dataIn.type == "Spectra":
		551	self.dataOut.copy(self.dataIn)
		552	return
		553
		554	if self.dataIn.type == "Voltage":
		555
		556	if nFFTPoints == None:
		557	raise ValueError, "This SpectraProc.setup() need nFFTPoints input variable"
		558
		559	if pairsList == None:
		560	nPairs = 0
		561	else:
		562	nPairs = len(pairsList)
		563
		564	self.dataOut.nFFTPoints = nFFTPoints
		565	self.dataOut.pairsList = pairsList
		566	self.dataOut.nPairs = nPairs
		567
		568	if self.buffer == None:
		569	self.buffer = numpy.zeros((self.dataIn.nChannels,
		570	self.dataOut.nFFTPoints,
		571	self.dataIn.nHeights),
		572	dtype='complex')
		573
		574
		575	self.buffer[:,self.profIndex,:] = self.dataIn.data
		576	self.profIndex += 1
		577
		578	if self.firstdatatime == None:
		579	self.firstdatatime = self.dataIn.utctime
		580
		581	if self.profIndex == self.dataOut.nFFTPoints:
		582	self.__updateObjFromInput()
		583	self.__getFft()
		584
		585	self.dataOut.flagNoData = False
		586
		587	self.buffer = None
		588	self.firstdatatime = None
		589	self.profIndex = 0
		590
		591	return
		592
		593	raise ValuError, "The type object %s is not valid"%(self.dataIn.type)
		594
		595	def selectChannels(self, channelList):
		596
		597	self.selectChannelsByIndex(channelList)
		598
		599	def selectChannelsByIndex(self, channelIndexList):
		600	"""
		601	Selecciona un bloque de datos en base a canales segun el channelIndexList
		602
		603	Input:
		604	channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
		605
		606	Affected:
		607	self.dataOut.data
		608	self.dataOut.channelIndexList
		609	self.dataOut.nChannels
		610	self.dataOut.m_ProcessingHeader.totalSpectra
		611	self.dataOut.systemHeaderObj.numChannels
		612	self.dataOut.m_ProcessingHeader.blockSize
		613
		614	Return:
		615	None
		616	"""
		617
		618	for channel in channelIndexList:
		619	if channel not in self.dataOut.channelIndexList:
		620	print channelIndexList
		621	raise ValueError, "The value %d in channelIndexList is not valid" %channel
		622
		623	nChannels = len(channelIndexList)
		624
		625	data = self.dataOut.data_spc[channelIndexList,:]
		626
		627	self.dataOut.data_spc = data
		628	self.dataOut.channelIndexList = channelIndexList
		629	self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
		630	self.dataOut.nChannels = nChannels
		631
		632	return 1
583		633
584		634
585	class IncohInt(Operation):	635	class IncohInt(Operation):

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