schain-jc Commit - r923:872a2100b6b2

Add WindProfiler support, multiSchain by_day

jespinoza -

r923:872a2100b6b2

parent child

Context file:

r923:872a2100b6b2

Collapse all files

schainpy/controller.py +12 -10

                 reparsed = minidom.parseString(rough_string)
                 return reparsed.toprettyxml(indent="  ")
-            def multiSchain(child, nProcess=cpu_count(), startDate=None, endDate=None, receiver=None):
+            def multiSchain(child, nProcess=cpu_count(), startDate=None, endDate=None, by_day=False):
                 skip = 0
                 cursor = 0
                 nFiles = None
                 dt1 = datetime.datetime.strptime(startDate, '%Y/%m/%d')
                 dt2 = datetime.datetime.strptime(endDate, '%Y/%m/%d')
                 days = (dt2 - dt1).days
-                print days
                 for day in range(days+1):
                     skip = 0
                     cursor = 0
                     dt = (dt1 + datetime.timedelta(day)).strftime('%Y/%m/%d')
                     firstProcess = Process(target=child, args=(cursor, skip, q, dt))
                     firstProcess.start()
+                    if by_day:
+                        continue
                     nFiles = q.get()
                     firstProcess.terminate()
                     skip = int(math.ceil(nFiles/nProcess))
                 def createObject(self, plotter_queue=None):
                     if self.type == 'self':
                         raise ValueError, "This operation type cannot be created"
                     if self.type == 'plotter':
                         opObj = Plotter(self.name, plotter_queue)
                     if self.type == 'external' or self.type == 'other':
                         className = eval(self.name)
                         kwargs = self.getKwargs()
                         opObj = className(**kwargs)
                     return opObj
                     kwargs = self.getKwargs()
                     procUnitObj = className(**kwargs)
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type=='self' and self.name=='run':
                             continue
                         elif opConfObj.type=='self':
                             procUnitObj.addOperationKwargs(opConfObj.id, **opConfObj.getKwargs())
                             continue
                         opObj = opConfObj.createObject(plotter_queue)
                         self.opObjDict[opConfObj.id] = opObj
                         procUnitObj.addOperation(opObj, opConfObj.id)
                     self.procUnitObj = procUnitObj

schainpy/model/data/jrodata.py +5 -1

                 abscissaList = None    #Abscissa, can be velocities, lags or time
-                #noise = None            #Noise Potency
+            #    noise = None            #Noise Potency
                 utctimeInit = None      #Initial UTC time
                     datatime = numpy.array(datatime)
                     return datatime
+                def getTimeInterval(self):
+                    return self.paramInterval

schainpy/model/graphics/jroplot_data.py +87 -1

@@ -325,7 +325,7 class PlotCrossSpectraData(PlotData):
325		325
326	ax.set_xlim(self.xmin, self.xmax)	326	ax.set_xlim(self.xmin, self.xmax)
327	ax.set_ylim(self.ymin, self.ymax)	327	ax.set_ylim(self.ymin, self.ymax)
328		328
329	ax.set_ylabel(self.ylabel)	329	ax.set_ylabel(self.ylabel)
330	ax.set_xlabel(xlabel)	330	ax.set_xlabel(xlabel)
331	ax.firsttime = False	331	ax.firsttime = False
@@ -590,6 +590,92 class PlotNoiseData(PlotData):
590	self.saveTime = self.min_time	590	self.saveTime = self.min_time
591		591
592		592
		593	class PlotWindProfilerData(PlotRTIData):
		594	CODE = 'wind'
		595	colormap = 'seismic'
		596
		597	def setup(self):
		598	self.ncols = 1
		599	self.nrows = self.dataOut.data_output.shape[0]
		600	self.width = 10
		601	self.height = 2.2*self.nrows
		602	self.ylabel = 'Height [Km]'
		603	self.titles = ['Zonal' ,'Meridional', 'Vertical']
		604	self.clabels = ['Velocity (m/s)','Velocity (m/s)','Velocity (cm/s)']
		605	self.windFactor = [1, 1, 100]
		606
		607	if self.figure is None:
		608	self.figure = plt.figure(figsize=(self.width, self.height),
		609	edgecolor='k',
		610	facecolor='w')
		611	else:
		612	self.figure.clf()
		613	self.axes = []
		614
		615	for n in range(self.nrows):
		616	ax = self.figure.add_subplot(self.nrows, self.ncols, n+1)
		617	ax.firsttime = True
		618	self.axes.append(ax)
		619
		620	def plot(self):
		621
		622	self.x = np.array(self.times)
		623	self.y = self.dataOut.heightList
		624	self.z = []
		625
		626	for ch in range(self.nrows):
		627	self.z.append([self.data[self.CODE][t][ch] for t in self.times])
		628
		629	self.z = np.array(self.z)
		630	self.z = numpy.ma.masked_invalid(self.z)
		631
		632	cmap=plt.get_cmap(self.colormap)
		633	cmap.set_bad('white', 1.)
		634
		635	for n, ax in enumerate(self.axes):
		636	x, y, z = self.fill_gaps(*self.decimate())
		637	xmin = self.min_time
		638	xmax = xmin+self.xrange6060
		639	if ax.firsttime:
		640	self.ymin = self.ymin if self.ymin else np.nanmin(self.y)
		641	self.ymax = self.ymax if self.ymax else np.nanmax(self.y)
		642	self.zmax = self.zmax if self.zmax else numpy.nanmax(abs(self.z[:-1, :]))
		643	self.zmin = self.zmin if self.zmin else -self.zmax
		644
		645	plot = ax.pcolormesh(x, y, z[n].T*self.windFactor[n],
		646	vmin=self.zmin,
		647	vmax=self.zmax,
		648	cmap=cmap
		649	)
		650	divider = make_axes_locatable(ax)
		651	cax = divider.new_horizontal(size='2%', pad=0.05)
		652	cax.set_ylabel(self.clabels[n])
		653	self.figure.add_axes(cax)
		654	plt.colorbar(plot, cax)
		655	ax.set_ylim(self.ymin, self.ymax)
		656
		657	ax.xaxis.set_major_formatter(FuncFormatter(func))
		658	ax.xaxis.set_major_locator(LinearLocator(6))
		659
		660	ax.set_ylabel(self.ylabel)
		661
		662	ax.set_xlim(xmin, xmax)
		663	ax.firsttime = False
		664	else:
		665	ax.collections.remove(ax.collections[0])
		666	ax.set_xlim(xmin, xmax)
		667	plot = ax.pcolormesh(x, y, z[n].T*self.windFactor[n],
		668	vmin=self.zmin,
		669	vmax=self.zmax,
		670	cmap=plt.get_cmap(self.colormap)
		671	)
		672	ax.set_title('{} {}'.format(self.titles[n],
		673	datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')),
		674	size=8)
		675
		676	self.saveTime = self.min_time
		677
		678
593	class PlotSNRData(PlotRTIData):	679	class PlotSNRData(PlotRTIData):
594	CODE = 'snr'	680	CODE = 'snr'
595	colormap = 'jet'	681	colormap = 'jet'

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

                     param = dataOut.data_param
                     if dataOut.abscissaList != None:
                         absc = dataOut.abscissaList[:-1]
-                    noise = dataOut.noise
+                    #noise = dataOut.noise
                     heightList = dataOut.heightList
                     SNR = dataOut.data_SNR

schainpy/model/utils/jroutils_publish.py +11 -3

                 def close(self):
                     if self.zeromq is 1:
                         self.dataOut.finished = True
-                        self.zmq_socket.send_pyobj(self.dataOut)
+                        # self.zmq_socket.send_pyobj(self.dataOut) CHECK IT!!!
                     if self.client:
                         self.client.loop_stop()
                             pass
                         if self.connections == 0 and self.started is True:
                             self.ended = True
-                            # send('ENDED')
                         evt.update({'description': events[evt['event']]})
                         if evt['event'] == zmq.EVENT_MONITOR_STOPPED:
                     self.sender.send_pyobj(data)
                 def update(self):
                     t = self.dataOut.utctime
+                    if t in self.data['times']:
+                        return
                     self.data['times'].append(t)
                     self.data['dataOut'] = self.dataOut
                     for plottype in self.plottypes:
                         if plottype == 'spc':
                             z = self.dataOut.data_spc/self.dataOut.normFactor
                             self.data[plottype][t] = self.dataOut.getCoherence()
                         if plottype == 'phase':
                             self.data[plottype][t] = self.dataOut.getCoherence(phase=True)
+                        if plottype == 'wind':
+                            self.data[plottype][t] = self.dataOut.data_output
                         if self.realtime:
                             self.data_web['timestamp'] = t
                             if plottype == 'spc':
                                 self.data_web[plottype] = roundFloats(decimate(self.data[plottype]).tolist())
                             elif plottype == 'cspc':

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