schain Commit - r1324:10adac0db3a5 · Jicamarca Repository

update Agosto

avaldez -

r1324:10adac0db3a5

parent child

Context file:

r1324:10adac0db3a5

schainpy/model/data/jrodata.py +10 -4

                     return delta
                 def getltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone * 60
                 normFactor = property(getNormFactor, "I'm the 'normFactor property'")
-            class Parameters(Spectra):
+            class Parameters(JROData):
                 experimentInfo = None  # Information about the experiment
                 # Information from previous data
                     return datatime
                 def getTimeInterval(self):
                     if hasattr(self, 'timeInterval1'):
                         return self.timeInterval1
                     else:
                     '''
                     Update data object with new dataOut
                     '''
+                    print("UPDATE ESTOYU AQUI")
                     self.profileIndex = dataOut.profileIndex
                     self.tm = tm
                     self.type = dataOut.type
                             buffer = dataOut.dataPP_WIDTH
                             self.flagDataAsBlock = dataOut.flagDataAsBlock
                             self.nProfiles = dataOut.nProfiles
+                        if plot == 'pp_rti_power':
+                            buffer = 10*numpy.log10(dataOut.dataPP_POWER)
+                        if plot == 'pp_rti_signal':
+                            buffer = 10*numpy.log10(dataOut.dataPP_POW)
+                        if plot == 'weather':
+                            print("ESTOY AQUI")
+                            print("jrodata",dataOut.data_360.shape)
+                            buffer = 10*numpy.log10(dataOut.data_360/(625**2))
                         if plot == 'spc':
                             self.data['spc'][tm] = buffer

schainpy/model/graphics/jroplot_base.py +27 -27

             from functools import wraps
             from threading import Thread
             import matplotlib
+            import wradlib as wrl
             if 'BACKEND' in os.environ:
                 matplotlib.use(os.environ['BACKEND'])
                     self.__throttle_plot = apply_throttle(self.throttle)
                     self.data = PlotterData(
                         self.CODE, self.throttle, self.exp_code, self.buffering, snr=self.showSNR)
                     if self.plot_server:
                         if not self.plot_server.startswith('tcp://'):
                             self.plot_server = 'tcp://{}'.format(self.plot_server)
                     '''
                     self.setup()
+                    self.time_label = 'LT' if self.localtime else 'UTC'
-                    self.time_label = 'LT' if self.localtime else 'UTC'
                     if self.width is None:
                         self.width = 8
                                          facecolor='w')
                         self.figures.append(fig)
                         for n in range(self.nplots):
+                            #cgax,ax,paax = wrl.vis.create_cg(data_w,r=r,az=azi, proj='cg')
                             ax = fig.add_subplot(self.nrows, self.ncols,
                                                  n + 1, polar=self.polar)
                             ax.tick_params(labelsize=8)
                                 xmax += time.timezone
                         else:
                             xmax = self.xmax
                     ymin = self.ymin if self.ymin else numpy.nanmin(self.y)
                     ymax = self.ymax if self.ymax else numpy.nanmax(self.y)
                     for n, ax in enumerate(self.axes):
                         if ax.firsttime:
                                 ystep = ystep/5
                                 ystep = ystep/(10**digD)
                             else:
                                 ystep = ((ymax + (10**(dig)))//10**(dig))*(10**(dig))
                                 ystep = ystep/5
                             if self.xaxis is not 'time':
                                 dig = int(numpy.log10(xmax))
                                 if dig <= 0:
                                     digD = len(str(xmax)) - 2
                                     xdec = xmax*(10**digD)
                                     xstep = ((xdec + (10**(dig)))//10**(dig))*(10**(dig))
                                     xstep = xstep*0.5
                                     xstep = xstep/(10**digD)
                                 else:
                                     xstep = ((xmax + (10**(dig)))//10**(dig))*(10**(dig))
                                     xstep = xstep/5
                     self.plot()
                     self.format()
                     for n, fig in enumerate(self.figures):
                         if self.nrows == 0 or self.nplots == 0:
                             log.warning('No data', self.name)
                             fig.text(0.5, 0.5, 'No Data', fontsize='large', ha='center')
                             fig.canvas.manager.set_window_title(self.CODE)
                             continue
                         fig.canvas.manager.set_window_title('{} - {}'.format(self.title,
                                                                              self.getDateTime(self.data.max_time).strftime('%Y/%m/%d')))
                         fig.canvas.draw()
                         if self.save:
                             self.save_figure(n)
                     if self.plot_server:
                         self.send_to_server()
                     figname = os.path.join(
                         self.save,
                         labels[n],
                         '{}_{}.png'.format(
                             labels[n],
                             self.getDateTime(self.data.max_time).strftime(
                                 '%Y%m%d_%H%M%S'
                         return
                     self.sender_time = self.data.tm
                     attrs = ['titles', 'zmin', 'zmax', 'tag', 'ymin', 'ymax']
                     for attr in attrs:
                         value = getattr(self, attr)
                     self.data.meta['interval'] = int(interval)
                     # msg = self.data.jsonify(self.data.tm, self.plot_name, self.plot_type)
                     self.sender_queue.put(self.data.tm)
                     while True:
                         if self.sender_queue.empty():
                             break
                     self.ncols: number of cols
                     self.nplots: number of plots (channels or pairs)
                     self.ylabel: label for Y axes
                     self.titles: list of axes title
                     '''
                     raise NotImplementedError
                     Must be defined in the child class
                     '''
                     raise NotImplementedError
                 def run(self, dataOut, **kwargs):
                     '''
                     Main plotting routine
                     if self.isConfig is False:
                         self.__setup(**kwargs)
                         t = getattr(dataOut, self.attr_time)
                         if dataOut.useLocalTime:
                             self.getDateTime = datetime.datetime.utcfromtimestamp
                             if self.localtime:
                                 t -= time.timezone
                         if self.xmin is None:
                             self.tmin = t
                             if 'buffer' in self.plot_type:
                         else:
                             self.tmin = (
                                 self.getDateTime(t).replace(
                                     hour=int(self.xmin),
                                     minute=0,
                                     second=0) - self.getDateTime(0)).total_seconds()
                         self.data.setup()
                         tm -= time.timezone
                     if dataOut.useLocalTime and not self.localtime:
                         tm += time.timezone
                     if self.data and (tm - self.tmin) >= self.xrange*60*60:
                         self.save_counter = self.save_period
                         self.__plot()
                         if 'time' in self.xaxis:
                         self.clear_figures()
                     self.data.update(dataOut, tm)
+                    print("plotbase--",self.data['weather'].shape)
                     if self.isPlotConfig is False:
                         self.__setup_plot()
                         self.isPlotConfig = True
                         self.__plot()
                     if self.data and not self.data.flagNoData and self.pause:
                         figpause(10)

schainpy/model/graphics/jroplot_parameters.py +72 0

@@ -6,6 +6,10 from schainpy.model.graphics.jroplot_base import Plot, plt
6	from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot	6	from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot
7	from schainpy.utils import log	7	from schainpy.utils import log
8		8
		9	'''-------'''
		10	import wradlib as wrl
		11	'''-------'''
		12
9	EARTH_RADIUS = 6.3710e3	13	EARTH_RADIUS = 6.3710e3
10		14
11		15
@@ -69,6 +73,24 class PowerPlot(RTIPlot):
69	colormap = 'jet'	73	colormap = 'jet'
70	plot_name = 'TotalPower'	74	plot_name = 'TotalPower'
71		75
		76	class PPPowerPlot(RTIPlot):
		77	'''
		78	Plot for Pulse Pair Power Data P =S +N
		79	'''
		80
		81	CODE = 'pp_rti_power'
		82	colormap = 'jet'
		83	plot_name = 'TotalPP_Power'
		84
		85	class PPSignalPlot(RTIPlot):
		86	'''
		87	Plot for Pulse Pair Power Data S = P- N (0 moment)
		88	'''
		89
		90	CODE = 'pp_rti_signal'
		91	colormap = 'jet'
		92	plot_name = 'TotalPP_Signal'
		93
72		94
73	class SpectralWidthPlot(RTIPlot):	95	class SpectralWidthPlot(RTIPlot):
74	'''	96	'''
@@ -339,3 +361,53 class PolarMapPlot(Plot):
339	self.titles = ['{} {}'.format(	361	self.titles = ['{} {}'.format(
340	self.data.parameters[x], title) for x in self.channels]	362	self.data.parameters[x], title) for x in self.channels]
341		363
		364
		365	class WeatherPlot(Plot):
		366	CODE = 'weather'
		367	plot_name = 'Weather'
		368	plot_type = 'ppistyle'
		369
		370	def setup(self):
		371	#self.xaxis = 'Range (Km)'
		372	self.ncols = 1
		373	self.nrows = 1
		374	self.nplots = 1
		375	self.ylabel = 'Range (Km)'
		376	self.titles = ['Weather']
		377	self.colorbar = False
		378	self.width = 8
		379	self.height = 8
		380	self.ini = 50
		381
		382	def plot(self):
		383	stoprange = float(33*1.5)
		384	rangestep = float(0.15)
		385	r = numpy.arange(0, stoprange, rangestep)
		386	'''
		387	self.x= r
		388	self.y= r
		389	ini = self.ini
		390	self.ini = self.ini+100
		391	azi = numpy.linspace(0,359,360)
		392	azi = azi + ini
		393	azi = azi % 36
		394	'''
		395	azi = self.data['weather'][1]
		396	data = self.data['weather'][0]
		397	data_w= data[:,-1,:]
		398	try:
		399	zeros=numpy.zeros([(360-data_w.shape[0]),data_w.shape[1]])
		400	print("zeros",zeros.shape)
		401	data_w= numpy.vstack([data_w,zeros])
		402	except:
		403	pass
		404
		405	for i,ax in enumerate(self.axes):
		406	if ax.firsttime:
		407	plt.clf()
		408	cgax, pm = wrl.vis.plot_ppi(data_w,r=r,az=azi,fig=self.figures[0], proj='cg')
		409	else:
		410	plt.clf()
		411	cgax, pm = wrl.vis.plot_ppi(data_w,r=r,az=azi,fig=self.figures[0], proj='cg')
		412
		413	print("cgax",cgax)

schainpy/model/graphics/jroplot_spectra.py +17 -17

                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                         noise = self.data['noise'][:,-1]
                         pair = self.data.pairs[n]
                         ax = self.axes[4 * n]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(nspc)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(nspc)
                             ax.plt = ax.pcolormesh(x , y , nspc[pair[0]].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
+                                                   )
                         else:
                             ax.plt.set_array(nspc[pair[0]].T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(pair[0], noise[pair[0]]))
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(nspc[pair[1]].T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(pair[1], noise[pair[1]]))
                         out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
                         phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                             ax.plt.set_array(coh.T.ravel())
                         self.titles.append(
                             'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[4 * n + 3]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, phase.T,
                                                    vmin=-180,
                                                    vmax=180,
                                                    cmap=plt.get_cmap(self.colormap_phase)
                                                    )
                         else:
                             ax.plt.set_array(phase.T.ravel())
             class NoisePlot(Plot):
                 '''
                 Plot for noise
                 '''
                 CODE = 'noise'
                     self.y = y
                     x = self.data['spcprofile']
                     if self.xmin is None: self.xmin = numpy.nanmin(x)*0.9
                     if self.xmax is None: self.xmax = numpy.nanmax(x)*1.1
                     if self.axes[0].firsttime:
                         for ch in self.data.channels:
                             self.axes[0].plot(x[ch], y, lw=1, label='Ch{}'.format(ch))
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if dataOut.flagNoData:
                         return dataOut
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
-                    return dataOut
  No newline at end of file
+                    return dataOut

schainpy/model/io/jroIO_param.py +71 -51

             from schainpy.model.io.jroIO_base import *
             from schainpy.utils import log
+            import wradlib as wrl
             class ParamReader(JRODataReader,ProcessingUnit):
                 '''
                     except IOError:
                         traceback.print_exc()
                         raise IOError("The file %s can't be opened" %(filename))
                     #In case has utctime attribute
                     grp2 = grp1['utctime']
              #         thisUtcTime = grp2.value[0] - 5*3600 #To convert to local time
                     thisUtcTime = grp2.value[0]
+                    #thisUtcTime  = grp2
                     fp.close()
                     if self.timezone == 'lt':
                         thisUtcTime -= 5*3600
                     thisDatetime = datetime.datetime.fromtimestamp(thisUtcTime[0] + 5*3600)
                     thisDate = thisDatetime.date()
                     thisTime = thisDatetime.time()
                     endTime = self.endTime
                     grp = fp['Data']
+                    #grp2 = grp['utctime'][()] # nuevo
+                    #thisUtcTime = grp2         # nuevo
                     thisUtcTime = grp['utctime'].value.astype(numpy.float)[0]
                     #ERROOOOR
                     if self.timezone == 'lt':
                         thisUtcTime -= 5*3600
                     listMetaname = []
                     listMetadata = []
+                    listShapes = {}
                     for item in list(gp.items()):
                         name = item[0]
                         if name=='array dimensions':
                             table = gp[name][:]
                             listShapes = {}
                             for shapes in table:
-                                listShapes[shapes[0]] = numpy.array([shapes[1],shapes[2],shapes[3],shapes[4],shapes[5]])
+                                listShapes[shapes[0].decode()] = numpy.array([shapes[1],shapes[2],shapes[3],shapes[4],shapes[5]])
                         else:
                             data = gp[name].value
                             listMetaname.append(name)
                     grp = self.fp['Data']
                     listdataname = []
                     listdata = []
                     for item in list(grp.items()):
                         name = item[0]
                         listdataname.append(name)
                         array = self.__setDataArray(grp[name],self.listShapes[name])
                         listdata.append(array)
                     return
                 def __setDataArray(self, dataset, shapes):
                     nDims = shapes[0]
                     nDim2 = shapes[1]      #Dimension 0
                     nDim1 = shapes[2]      #Dimension 1, number of Points or Parameters
                     listShapes = self.listShapes
                     blockIndex = self.blockIndex
-             #         blockList = self.blockList
                     for i in range(len(listMeta)):
                         setattr(self.dataOut,listMetaname[i],listMeta[i])
                 setType = None
                 def __init__(self):
                     Operation.__init__(self)
                     return
                         dsDict['variable'] = self.dataList[i]
                         #---------------------    Conditionals    ------------------------
                         #There is no data
                         if dataAux is None:
                             return 0
                         if isinstance(dataAux, (int, float, numpy.integer, numpy.float)):
                         return False
                 def setNextFile(self):
                     ext = self.ext
                     path = self.path
                     setFile = self.setFile
                             for j in range(dsInfo['dsNumber']):
                                 dsInfo = dsList[i]
                                 tableName = dsInfo['dsName']
                                 if dsInfo['nDim'] == 3:
                                     shape = dsInfo['shape'].astype(int)
                     self.dataOut = dataOut
                     if not(self.isConfig):
                         self.setup(dataOut, path=path, blocksPerFile=blocksPerFile,
                                    metadataList=metadataList, dataList=dataList, mode=mode,
                                    setType=setType)
                     self.putData()
                     return
             class ParameterReader(Reader, ProcessingUnit):
                     self.set_kwargs(**kwargs)
                     if not self.ext.startswith('.'):
                         self.ext = '.{}'.format(self.ext)
                     if self.online:
                         log.log("Searching files in online mode...", self.name)
                         for nTries in range(self.nTries):
                             fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk,
                                 self.filefmt, self.folderfmt)
                             try:
                                 fullpath = next(fullpath)
                             except:
                                 fullpath = None
                             if fullpath:
                                 break
                             log.warning(
                                 'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                     self.delay, self.path, nTries + 1),
                                 self.name)
                             time.sleep(self.delay)
                         if not(fullpath):
                             raise schainpy.admin.SchainError(
                                 'There isn\'t any valid file in {}'.format(self.path))
                         pathname, filename = os.path.split(fullpath)
                         self.year = int(filename[1:5])
                         self.doy = int(filename[5:8])
                         self.set = int(filename[8:11]) - 1
                     else:
                         log.log("Searching files in {}".format(self.path), self.name)
                         self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                             self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
-                    self.setNextFile()
+                    self.setNextFile()
+                    '''
+                    # try to implement wradlib
+                    pathname,filename = os.path.split(self.filename)
+                    f = wrl.util.get_wradlib_data_file(self.filename)
+                    fcontent = wrl.io.read_generic_hdf5(f)
+                    print(pathname,filename)
+                    '''
                     return
                 def readFirstHeader(self):
                     '''Read metadata and data'''
                     self.__readMetadata()
                     self.__readData()
                     self.__setBlockList()
                     self.blockIndex = 0
                     return
                 def __setBlockList(self):
                     startTime = self.startTime
                     endTime = self.endTime
                     index = self.listDataname.index('utctime')
                     thisUtcTime = self.listData[index]
                     self.interval = numpy.min(thisUtcTime[1:] - thisUtcTime[:-1])
+                    try:
+                        index = self.listMetaname.index('timeZone')
+                        tz = self.listMeta[index]
+                        if tz == 0:
+                            print("[Metadata] Attribute timeZone = %d,  dataOut in utc"%(tz))
+                        else:
+                            print("[Metadata] Attribute timeZone = %d,  dataOut in LT"%(tz))
+                        thisUtcTime += tz*60
+                    except:
+                        print("[Metadata] There is no attribute timeZone , by default assume dataOut was recorded in LT")
+                        tz=300
+                        thisUtcTime += tz*60
                     if self.timezone == 'lt':
                         thisUtcTime -= 5*3600
-                    thisDatetime = datetime.datetime.fromtimestamp(thisUtcTime[0] + 5*3600)
+                    thisDatetime = datetime.datetime.fromtimestamp(thisUtcTime[0])
                     thisDate = thisDatetime.date()
                     thisTime = thisDatetime.time()
                     startUtcTime = (datetime.datetime.combine(thisDate,startTime) - datetime.datetime(1970, 1, 1)).total_seconds()
                     endUtcTime = (datetime.datetime.combine(thisDate,endTime) - datetime.datetime(1970, 1, 1)).total_seconds()
                             else:
                                 data = gp[name].value
                                 listMetaname.append(name)
                                 listMetadata.append(data)
                     elif self.metadata:
                         metadata = json.loads(self.metadata)
                         listShapes = {}
                     self.listShapes = listShapes
                     self.listMetaname = listMetaname
                     self.listMeta = listMetadata
                     return
                     listdataname = []
                     listdata = []
                     if 'Data' in self.fp:
                         grp = self.fp['Data']
                         for item in list(grp.items()):
                                 for i in range(dim):
                                     array.append(grp[name]['table{:02d}'.format(i)].value)
                                 array = numpy.array(array)
                             listdata.append(array)
                     elif self.metadata:
                         metadata = json.loads(self.metadata)
                     self.listDataname = listdataname
                     self.listData = listdata
                     return
-                def getData(self):
+                def getData(self):
                     for i in range(len(self.listMeta)):
                         setattr(self.dataOut, self.listMetaname[i], self.listMeta[i])
                             setattr(self.dataOut, self.listDataname[j], self.listData[j][:,self.blockIndex])
                     self.dataOut.paramInterval = self.interval
+                    try:
+                        thisDatetime = datetime.datetime.fromtimestamp(self.dataOut.utctime)
+                        '''REMEMBER THIS'''
+                        #print("[Reading] Block No. %d -> %s" % (self.blockIndex,thisDatetime.ctime()))
+                    except:
+                        pass
                     self.dataOut.flagNoData = False
                     self.blockIndex += 1
                     return
                 def run(self, **kwargs):
                 lastTime = None
                 def __init__(self):
                     Operation.__init__(self)
                     return
                             dsDict['nDim'] = len(dataAux.shape)
                             dsDict['shape'] = dataAux.shape
                             dsDict['dsNumber'] = dataAux.shape[0]
                         dsList.append(dsDict)
                         tableList.append((self.dataList[i], dsDict['nDim']))
                         self.lastTime = currentTime
                         self.currentDay = dataDay
                         return False
                     timeDiff = currentTime - self.lastTime
                     #Si el dia es diferente o si la diferencia entre un dato y otro supera la hora
                     self.dataOut = dataOut
                     if not(self.isConfig):
                         self.setup(path=path, blocksPerFile=blocksPerFile,
                                    metadataList=metadataList, dataList=dataList,
                                    setType=setType)
                     self.putData()
                     return
                 def setNextFile(self):
                     ext = self.ext
                     path = self.path
                     setFile = self.setFile
                     return
                 def writeData(self, fp):
                     grp = fp.create_group("Data")
                     dtsets = []
                     data = []
                     for dsInfo in self.dsList:
                         if dsInfo['nDim'] == 0:
                             ds = grp.create_dataset(
                                 dsInfo['variable'],
                                 (self.blocksPerFile, ),
                                 chunks=True,
                                 dtype=numpy.float64)
                             dtsets.append(ds)
                             data.append((dsInfo['variable'], -1))
                             sgrp = grp.create_group(dsInfo['variable'])
                             for i in range(dsInfo['dsNumber']):
                                 ds = sgrp.create_dataset(
                                     'table{:02d}'.format(i),
                                     (self.blocksPerFile, ) + dsInfo['shape'][1:],
                                     chunks=True)
                                 dtsets.append(ds)
                     fp.flush()
                     log.log('Creating file: {}'.format(fp.filename), self.name)
                     self.ds = dtsets
                     self.data = data
                     self.firsttime = True

schainpy/model/proc/jroproc_parameters.py +332 -1

@@ -109,6 +109,13 class ParametersProc(ProcessingUnit):
109	self.dataOut.flagNoData = False	109	self.dataOut.flagNoData = False
110	self.dataOut.utctimeInit = self.dataIn.utctime	110	self.dataOut.utctimeInit = self.dataIn.utctime
111	self.dataOut.paramInterval = self.dataIn.nProfilesself.dataIn.nCohIntself.dataIn.ippSeconds	111	self.dataOut.paramInterval = self.dataIn.nProfilesself.dataIn.nCohIntself.dataIn.ippSeconds
		112
		113	if hasattr(self.dataIn, 'flagDataAsBlock'):
		114	self.dataOut.flagDataAsBlock = self.dataIn.flagDataAsBlock
		115
		116	if hasattr(self.dataIn, 'profileIndex'):
		117	self.dataOut.profileIndex = self.dataIn.profileIndex
		118
112	if hasattr(self.dataIn, 'dataPP_POW'):	119	if hasattr(self.dataIn, 'dataPP_POW'):
113	self.dataOut.dataPP_POW = self.dataIn.dataPP_POW	120	self.dataOut.dataPP_POW = self.dataIn.dataPP_POW
114		121
@@ -183,7 +190,6 class ParametersProc(ProcessingUnit):
183	if self.dataIn.type == "Parameters":	190	if self.dataIn.type == "Parameters":
184	self.dataOut.copy(self.dataIn)	191	self.dataOut.copy(self.dataIn)
185	self.dataOut.flagNoData = False	192	self.dataOut.flagNoData = False
186
187	return True	193	return True
188		194
189	self.__updateObjFromInput()	195	self.__updateObjFromInput()
@@ -592,7 +598,86 class GaussianFit(Operation):
592	def misfit2(self,state,y_data,x,num_intg):	598	def misfit2(self,state,y_data,x,num_intg):
593	return num_intgsum((numpy.log(y_data)-numpy.log(self.y_model2(x,state)))*2)#/(64-9.)	599	return num_intgsum((numpy.log(y_data)-numpy.log(self.y_model2(x,state)))*2)#/(64-9.)
594		600
		601	class WeatherRadar(Operation):
		602	'''
		603	Function tat implements Weather Radar operations-
		604	Input:
		605	Output:
		606	Parameters affected:
		607	'''
		608	isConfig = False
		609
		610	def __init__(self):
		611	Operation.__init__(self)
595		612
		613	def setup(self,dataOut,Pt=0,Gt=0,Gr=0,lambda_=0, aL=0,
		614	tauW= 0,thetaT=0,thetaR=0,Km =0):
		615	self.nCh = dataOut.nChannels
		616	self.nHeis = dataOut.nHeights
		617	deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
		618	self.Range = numpy.arange(dataOut.nHeights)*deltaHeight + dataOut.heightList[0]
		619	self.Range = self.Range.reshape(1,self.nHeis)
		620	self.Range = numpy.tile(self.Range,[self.nCh,1])
		621	'''-----------1 Constante del Radar----------'''
		622	self.Pt = Pt
		623	self.Gt = Gt
		624	self.Gr = Gr
		625	self.lambda_ = lambda_
		626	self.aL = aL
		627	self.tauW = tauW
		628	self.thetaT = thetaT
		629	self.thetaR = thetaR
		630	self.Km = Km
		631	Numerator = ((4numpy.pi)3 aL*2 16 *numpy.log(2))
		632	Denominator = (Pt * Gt * Gr * lambda_*2 SPEED_OF_LIGHT * tauW * numpy.pithetaTthetaR)
		633	self.RadarConstant = Numerator/Denominator
		634	'''-----------2 Reflectividad del Radar y Factor de Reflectividad------'''
		635	self.n_radar = numpy.zeros((self.nCh,self.nHeis))
		636	self.Z_radar = numpy.zeros((self.nCh,self.nHeis))
		637
		638	def setMoments(self,dataOut,i):
		639
		640	type = dataOut.inputUnit
		641	nCh = dataOut.nChannels
		642	nHeis= dataOut.nHeights
		643	data_param = numpy.zeros((nCh,4,nHeis))
		644	if type == "Voltage":
		645	data_param[:,0,:] = dataOut.dataPP_POW/(dataOut.nCohInt**2)
		646	data_param[:,1,:] = dataOut.dataPP_DOP
		647	data_param[:,2,:] = dataOut.dataPP_WIDTH
		648	data_param[:,3,:] = dataOut.dataPP_SNR
		649	if type == "Spectra":
		650	data_param[:,0,:] = dataOut.data_POW
		651	data_param[:,1,:] = dataOut.data_DOP
		652	data_param[:,2,:] = dataOut.data_WIDTH
		653	data_param[:,3,:] = dataOut.data_SNR
		654
		655	return data_param[:,i,:]
		656
		657
		658	def run(self,dataOut,Pt=25,Gt=200.0,Gr=50.0,lambda_=0.32, aL=2.5118,
		659	tauW= 4.0e-6,thetaT=0.165,thetaR=0.367,Km =0.93):
		660
		661	if not self.isConfig:
		662	self.setup(dataOut= dataOut,Pt=25,Gt=200.0,Gr=50.0,lambda_=0.32, aL=2.5118,
		663	tauW= 4.0e-6,thetaT=0.165,thetaR=0.367,Km =0.93)
		664	self.isConfig = True
		665	'''-----------------------------Potencia de Radar -Signal S-----------------------------'''
		666	Pr = self.setMoments(dataOut,0)
		667
		668	for R in range(self.nHeis):
		669	self.n_radar[:,R] = self.RadarConstantPr[:,R] (self.Range[:,R])**2
		670
		671	self.Z_radar[:,R] = self.n_radar[:,R]* self.lambda_4/( numpy.pi5 * self.Km**2)
		672
		673	'''----------- Factor de Reflectividad Equivalente lamda_ < 10 cm , lamda_= 3.2cm-------'''
		674	Zeh = self.Z_radar
		675	dBZeh = 10*numpy.log10(Zeh)
		676	dataOut.factor_Zeh= dBZeh
		677	self.n_radar = numpy.zeros((self.nCh,self.nHeis))
		678	self.Z_radar = numpy.zeros((self.nCh,self.nHeis))
		679
		680	return dataOut
596		681
597	class PrecipitationProc(Operation):	682	class PrecipitationProc(Operation):
598		683
@@ -3998,3 +4083,249 class SMOperations():
3998	# error[indInvalid1] = 13	4083	# error[indInvalid1] = 13
3999	#	4084	#
4000	# return heights, error	4085	# return heights, error
		4086
		4087	class PulsePairVoltage(Operation):
		4088	'''
		4089	Function PulsePair(Signal Power, Velocity)
		4090	The real component of Lag[0] provides Intensity Information
		4091	The imag component of Lag[1] Phase provides Velocity Information
		4092
		4093	Configuration Parameters:
		4094	nPRF = Number of Several PRF
		4095	theta = Degree Azimuth angel Boundaries
		4096
		4097	Input:
		4098	self.dataOut
		4099	lag[N]
		4100	Affected:
		4101	self.dataOut.spc
		4102	'''
		4103	isConfig = False
		4104	__profIndex = 0
		4105	__initime = None
		4106	__lastdatatime = None
		4107	__buffer = None
		4108	noise = None
		4109	__dataReady = False
		4110	n = None
		4111	__nch = 0
		4112	__nHeis = 0
		4113	removeDC = False
		4114	ipp = None
		4115	lambda_ = 0
		4116
		4117	def __init__(self,**kwargs):
		4118	Operation.__init__(self,**kwargs)
		4119
		4120	def setup(self, dataOut, n = None, removeDC=False):
		4121	'''
		4122	n= Numero de PRF's de entrada
		4123	'''
		4124	self.__initime = None
		4125	self.__lastdatatime = 0
		4126	self.__dataReady = False
		4127	self.__buffer = 0
		4128	self.__profIndex = 0
		4129	self.noise = None
		4130	self.__nch = dataOut.nChannels
		4131	self.__nHeis = dataOut.nHeights
		4132	self.removeDC = removeDC
		4133	self.lambda_ = 3.0e8/(9345.0e6)
		4134	self.ippSec = dataOut.ippSeconds
		4135	self.nCohInt = dataOut.nCohInt
		4136	print("IPPseconds",dataOut.ippSeconds)
		4137
		4138	print("ELVALOR DE n es:", n)
		4139	if n == None:
		4140	raise ValueError("n should be specified.")
		4141
		4142	if n != None:
		4143	if n<2:
		4144	raise ValueError("n should be greater than 2")
		4145
		4146	self.n = n
		4147	self.__nProf = n
		4148
		4149	self.__buffer = numpy.zeros((dataOut.nChannels,
		4150	n,
		4151	dataOut.nHeights),
		4152	dtype='complex')
		4153
		4154	def putData(self,data):
		4155	'''
		4156	Add a profile to he __buffer and increase in one the __profiel Index
		4157	'''
		4158	self.__buffer[:,self.__profIndex,:]= data
		4159	self.__profIndex += 1
		4160	return
		4161
		4162	def pushData(self,dataOut):
		4163	'''
		4164	Return the PULSEPAIR and the profiles used in the operation
		4165	Affected : self.__profileIndex
		4166	'''
		4167	#················· Remove DC···································
		4168	if self.removeDC==True:
		4169	mean = numpy.mean(self.__buffer,1)
		4170	tmp = mean.reshape(self.__nch,1,self.__nHeis)
		4171	dc= numpy.tile(tmp,[1,self.__nProf,1])
		4172	self.__buffer = self.__buffer - dc
		4173	#··················Calculo de Potencia ························
		4174	pair0 = self.__buffer*numpy.conj(self.__buffer)
		4175	pair0 = pair0.real
		4176	lag_0 = numpy.sum(pair0,1)
		4177	#··················Calculo de Ruido x canal····················
		4178	self.noise = numpy.zeros(self.__nch)
		4179	for i in range(self.__nch):
		4180	daux = numpy.sort(pair0[i,:,:],axis= None)
		4181	self.noise[i]=hildebrand_sekhon( daux ,self.nCohInt)
		4182
		4183	self.noise = self.noise.reshape(self.__nch,1)
		4184	self.noise = numpy.tile(self.noise,[1,self.__nHeis])
		4185	noise_buffer = self.noise.reshape(self.__nch,1,self.__nHeis)
		4186	noise_buffer = numpy.tile(noise_buffer,[1,self.__nProf,1])
		4187	#·················· Potencia recibida= P , Potencia senal = S , Ruido= N··
		4188	#·················· P= S+N ,P=lag_0/N ·································
		4189	#···················· Power ··················································
		4190	data_power = lag_0/(self.n*self.nCohInt)
		4191	#------------------ Senal ···················································
		4192	data_intensity = pair0 - noise_buffer
		4193	data_intensity = numpy.sum(data_intensity,axis=1)(self.nself.nCohInt)#*self.nCohInt)
		4194	#data_intensity = (lag_0-self.noiseself.n)(self.n*self.nCohInt)
		4195	for i in range(self.__nch):
		4196	for j in range(self.__nHeis):
		4197	if data_intensity[i][j] < 0:
		4198	data_intensity[i][j] = numpy.min(numpy.absolute(data_intensity[i][j]))
		4199
		4200	#················· Calculo de Frecuencia y Velocidad doppler········
		4201	pair1 = self.__buffer[:,:-1,:]*numpy.conjugate(self.__buffer[:,1:,:])
		4202	lag_1 = numpy.sum(pair1,1)
		4203	data_freq = (-1/(2.0math.piself.ippSecself.nCohInt))numpy.angle(lag_1)
		4204	data_velocity = (self.lambda_/2.0)*data_freq
		4205
		4206	#················ Potencia promedio estimada de la Senal···········
		4207	lag_0 = lag_0/self.n
		4208	S = lag_0-self.noise
		4209
		4210	#················ Frecuencia Doppler promedio ·····················
		4211	lag_1 = lag_1/(self.n-1)
		4212	R1 = numpy.abs(lag_1)
		4213
		4214	#················ Calculo del SNR··································
		4215	data_snrPP = S/self.noise
		4216	for i in range(self.__nch):
		4217	for j in range(self.__nHeis):
		4218	if data_snrPP[i][j] < 1.e-20:
		4219	data_snrPP[i][j] = 1.e-20
		4220
		4221	#················· Calculo del ancho espectral ······················
		4222	L = S/R1
		4223	L = numpy.where(L<0,1,L)
		4224	L = numpy.log(L)
		4225	tmp = numpy.sqrt(numpy.absolute(L))
		4226	data_specwidth = (self.lambda_/(2math.sqrt(2)math.piself.ippSecself.nCohInt))tmpnumpy.sign(L)
		4227	n = self.__profIndex
		4228	class Block360(Operation):
		4229	'''
		4230	'''
		4231	isConfig = False
		4232	__profIndex = 0
		4233	__initime = None
		4234	__lastdatatime = None
		4235	__buffer = None
		4236	__dataReady = False
		4237	n = None
		4238	__nch = 0
		4239	__nHeis = 0
		4240
		4241	def __init__(self,**kwargs):
		4242	Operation.__init__(self,**kwargs)
		4243
		4244	def setup(self, dataOut, n = None):
		4245	'''
		4246	n= Numero de PRF's de entrada
		4247	'''
		4248	self.__initime = None
		4249	self.__lastdatatime = 0
		4250	self.__dataReady = False
		4251	self.__buffer = 0
		4252	self.__profIndex = 0
		4253
		4254
		4255	print("ELVALOR DE n es:", n)
		4256	if n == None:
		4257	raise ValueError("n should be specified.")
		4258
		4259	if n != None:
		4260	if n<2:
		4261	raise ValueError("n should be greater than 2")
		4262
		4263	self.n = n
		4264
		4265	self.__buffer = numpy.zeros(( n, dataOut.nHeights))
		4266
		4267	def putData(self,data):
		4268	'''
		4269	Add a profile to he __buffer and increase in one the __profiel Index
		4270	'''
		4271	self.__buffer[self.__profIndex,:]= data
		4272	self.__profIndex += 1
		4273	return #················· Remove DC···································
		4274
		4275	def pushData(self,dataOut):
		4276	'''
		4277	Return the PULSEPAIR and the profiles used in the operation
		4278	Affected : self.__profileIndex
		4279	'''
		4280
		4281
		4282	data_360 = self.__buffer
		4283	n = self.__profIndex
		4284
		4285	self.__buffer = numpy.zeros(( self.n,330))
		4286	self.__profIndex = 0
		4287	return data_360,n
		4288
		4289
		4290	def byProfiles(self,dataOut):
		4291
		4292	self.__dataReady = False
		4293	data_360 = None
		4294	self.putData(data=dataOut.data_POW[0])
		4295	if self.__profIndex == self.n:
		4296	data_360, n = self.pushData(dataOut=dataOut)
		4297	self.__dataReady = True
		4298
		4299	return data_360
		4300
		4301
		4302	def blockOp(self, dataOut, datatime= None):
		4303
		4304	if self.__initime == None:
		4305	self.__initime = datatime
		4306	data_360 = self.byProfiles(dataOut)
		4307	self.__lastdatatime = datatime
		4308
		4309	if data_360 is None:
		4310	return None, None
		4311
		4312	avgdatatime = self.__initime
		4313	deltatime = datatime - self.__lastdatatime
		4314	self.__initime = datatime
		4315
		4316	return data_360, avgdatatime
		4317
		4318	def run(self, dataOut,n = None,**kwargs):
		4319
		4320	if not self.isConfig:
		4321	self.setup(dataOut = dataOut, n = n , **kwargs)
		4322	self.isConfig = True
		4323	data_360, avgdatatime = self.blockOp(dataOut, dataOut.utctime)
		4324	dataOut.flagNoData = True
		4325
		4326	if self.__dataReady:
		4327	dataOut.data_360 = data_360 # S
		4328	print("data_360",data_360.shape,avgdatatime)
		4329	dataOut.utctime = avgdatatime
		4330	dataOut.flagNoData = False
		4331	return dataOut

schainpy/model/proc/jroproc_voltage.py +1 0

                         dataOut.dataPP_SNR      = data_snrPP
                         dataOut.dataPP_WIDTH    = data_specwidth
                         dataOut.PRFbyAngle      = self.n         #numero de PRF*cada angulo rotado que equivale a un tiempo.
+                        dataOut.nProfiles       = int(dataOut.nProfiles/n)
                         dataOut.utctime         = avgdatatime
                         dataOut.flagNoData      = False
                     return dataOut

schainpy/scripts/pedestal_client.py +1 -1

                 elev.append(ang_elev)
                 time0.append(seconds)
                 count +=1
-                if count == 100:
+                if count == 360:
                     timetuple=time.localtime()
                     epoc = time.mktime(timetuple)
                      #print(epoc)

schainpy/scripts/test_sim00010.py +2 -2

             opObj10.addParameter(name='path',value=figpath)
             #opObj10.addParameter(name='mode',value=0)
             opObj10.addParameter(name='blocksPerFile',value='100',format='int')
-            opObj10.addParameter(name='metadataList',value='utctimeInit,timeInterval',format='list')
+            opObj10.addParameter(name='metadataList',value='utctimeInit,paramInterval,heightList',format='list')
-            opObj10.addParameter(name='dataList',value='data_POW,data_DOP,data_WIDTH,data_SNR')#,format='list'
+            opObj10.addParameter(name='dataList',value='data_POW,data_DOP,utctime')#,format='list'
             controllerObj.start()

schainpy/scripts/test_sim0009.py +6 -8

             import datetime
             import time
             from schainpy.controller import Project
-            path    = '/home/alex/Downloads/NEW_WR2/spc16removeDC'
+            path    = '/home/alex/Downloads/hdf5_testPP2'
             figpath = path
             desc            = "Simulator Test"
             opObj11.addParameter(name='n', value='625', format='int')#10
             opObj11.addParameter(name='removeDC', value=1, format='int')
-            #opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other')
+            #opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other')#,dataPP_SNR,dataPP_WIDTH
             #opObj11 = procUnitConfObjA.addOperation(name='PulsepairSignalPlot', optype='other')
             #opObj11 = procUnitConfObjA.addOperation(name='PulsepairSpecwidthPlot', optype='other')
             procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
             opObj10 = procUnitConfObjB.addOperation(name='ParameterWriter')
             opObj10.addParameter(name='path',value=figpath)
-            #opObj10.addParameter(name='mode',value=0)
+            #opObj10.addParameter(name='mode',value=2)
-            opObj10.addParameter(name='blocksPerFile',value='100',format='int')
+            opObj10.addParameter(name='blocksPerFile',value='50',format='int')
-            opObj10.addParameter(name='metadataList',value='utctimeInit,timeInterval',format='list')
+            opObj10.addParameter(name='metadataList',value='utctimeInit,paramInterval,heightList,profileIndex,flagDataAsBlock',format='list')
-            opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,dataPP_SNR,dataPP_WIDTH')#,format='list'
+            opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,utctime',format='list')#,format='list'
             controllerObj.start()

schainpy/scripts/wr_integrador.py +4 -4

             dir_pedestal = "/home/alex/Downloads/pedestal"
             #·········· DATA ADQ······························
             if mode=="T":
-                dir_adq  = "/home/alex/Downloads/hdf5_testPP/d2020194" # Time domain
+                dir_adq  = "/home/alex/Downloads/hdf5_testPP/d2020204" # Time domain
             else:
-                dir_adq  = "/home/alex/Downloads/hdf5_test/d2020194"   # Frequency domain
+                dir_adq  = "/home/alex/Downloads/hdf5_test/d2020204"   # Frequency domain
             print( "Velocidad angular             :", w)
             print( "Resolucion minima en grados   :", alfa)
             print("utc_adq                       :",utc_adq)
             #·············Relacion:  utc_adq (+/-) var_tiempo*nro_file= utc_pedestal
             time_Interval_p   = 0.01
-            n_perfiles_p      = 100
+            n_perfiles_p      = 360
             if utc_adq>utc_pedestal:
                 nro_file = int((int(utc_adq) - int(utc_pedestal))/(time_Interval_p*n_perfiles_p))
                 ff_pedestal  = list_pedestal[nro_file]
             nro_file       = nro_file #10
             nro_key_perfil = nro_key_p
-            blocksPerFile  = 100
+            blocksPerFile  = 360
             wr_path        = "/home/alex/Downloads/hdf5_wr/"
             # Lectura  de archivos de adquisicion para adicion de azimuth
             for thisFile in range(len(list_adq)):

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