schain-jc Commit - r587:d717921bf643

Signal Chain GUI updated:...

Miguel Valdez -

r587:d717921bf643

parent child

Context file:

r587:d717921bf643

Collapse all files

schainpy/controller.py +14 -4

             #import datetime
             from model import *
+            try:
+                from gevent import sleep
+            except:
+                from time import sleep
             import ast
             def prettify(elem):
                     if self.__formated_value != None:
                         return self.__formated_value
                     value = self.value
                     if self.format == 'bool':
                     return procUnitConfObj
+                def removeProcUnit(self, id):
+                    if id in self.procUnitConfObjDict.keys():
+                        self.procUnitConfObjDict.pop(id)
                 def getReadUnitId(self):
                     readUnitConfObj = self.getReadUnitObj()
                             print "Process suspended"
                             while True:
-                                time.sleep(0.1)
+                                sleep(0.1)
                                 if not self.control['pause']:
                                     break
                             print "Process reinitialized"
                         if self.control['stop']:
-                            print "Stopping process"
+                            print "Process stopped"
                             break
                     #Closing every process
                         procUnitConfObj = self.procUnitConfObjDict[procKey]
                         procUnitConfObj.close()
-                    print "Process stopped"
+                    print "Process finished"
                 def start(self, filename):

schainpy/gui/viewcontroller/basicwindow.py +190 -68

             #from CodeWarrior.Standard_Suite import file
             from comm import *
+            try:
+                from gevent import sleep
+            except:
+                from time import sleep
             from schainpy.gui.figures import tools
             import numpy
                     self.create = False
                     self.selectedItemTree = None
                     self.commCtrlPThread = None
-                    self.setParameter()
-                    self.create_comm()
-            #         self.create_timers()
             #         self.create_figure()
                     self.temporalFTP = ftpBuffer()
                     self.projectProperCaracteristica = []
                     self.__ftpProcUnitAdded = False
                     self.__ftpProcUnitId = None
+                    self.__initialized = False
+                    self.create_comm()
+                    self.create_updating_timer()
+                    self.setParameter()
                 @pyqtSignature("")
                 def on_actionOpen_triggered(self):
                     """
                     if self.volOpCebChannels.isChecked():
-                        value = self.volOpChannel.text()
+                        value = str(self.volOpChannel.text())
+                        if value == "":
+                            print "Please fill channel list"
+                            return 0
                         format = 'intlist'
                         if self.volOpComChannels.currentIndex() == 0:
                             name_operation = "selectChannels"
                         opObj.addParameter(name=name_parameter, value=value, format=format)
                     if self.volOpCebHeights.isChecked():
-                       value = self.volOpHeights.text()
+                       value = str(self.volOpHeights.text())
+                       if value == "":
+                            print "Please fill height range"
+                            return 0
                        valueList = value.split(',')
                        format = 'float'
                        if  self.volOpComHeights.currentIndex() == 0:
                            name_operation = 'selectHeightsByIndex'
                            name_parameter1 = 'minIndex'
                            name_parameter2 = 'maxIndex'
                        opObj = puObj.addOperation(name=name_operation)
                        opObj.addParameter(name=name_parameter1, value=valueList[0], format=format)
                        opObj.addParameter(name=name_parameter2, value=valueList[1], format=format)
                     if self.volOpCebFilter.isChecked():
-                       value = self.volOpFilter.text()
+                       value = str(self.volOpFilter.text())
+                       if value == "":
+                            print "Please fill filter value"
+                            return 0
                        format = 'int'
                        name_operation = 'filterByHeights'
                        name_parameter = 'window'
                        opObj.addParameter(name=name_parameter, value=value, format=format)
                     if self.volOpCebProfile.isChecked():
-                        value = self.volOpProfile.text()
+                        value = str(self.volOpProfile.text())
+                        if value == "":
+                            print "Please fill profile value"
+                            return 0
                         format = 'intlist'
                         optype = 'other'
                         name_operation = 'ProfileSelector'
                         puObj.addParameter(name=name_parameter, value=value2, format=format)
                     if self.specOpCebHeights.isChecked():
-                        value = self.specOpHeights.text()
+                        value = str(self.specOpHeights.text())
+                        if value == "":
+                            print "Please fill height range"
+                            return 0
                         valueList = value.split(',')
                         format = 'float'
                         value0 = valueList[0]
                         opObj.addParameter(name=name_parameter2, value=value1, format=format)
                     if self.specOpCebChannel.isChecked():
-                        value = self.specOpChannel.text()
+                        value = str(self.specOpChannel.text())
+                        if value == "":
+                            print "Please fill channel list"
+                            return 0
                         format = 'intlist'
                         if self.specOpComChannel.currentIndex() == 0:
                             name_operation = "selectChannels"
                         else:
                             name_operation = "selectChannelsByIndex"
                             name_parameter = 'channelIndexList'
-                        opObj = puObj.addOperation(name="selectChannels")
+                        opObj = puObj.addOperation(name=name_operation)
                         opObj.addParameter(name=name_parameter, value=value, format=format)
                     if self.specOpCebIncoherent.isChecked():
-                        value = self.specOpIncoherent.text()
+                        value = str(self.specOpIncoherent.text())
+                        if value == "":
+                            print "Please fill Incoherent integration value"
+                            return 0
                         name_operation = 'IncohInt'
                         optype = 'other'
                         if self.specOpCobIncInt.currentIndex() == 0:
                         self.specHeisGraphPath.setEnabled(True)
                         self.specHeisGraphPrefix.setEnabled(True)
                         self.specHeisGraphToolPath.setEnabled(True)
-               #-------ftp-----#
                 @pyqtSignature("int")
                 def on_specHeisGraphftpSpectra_stateChanged(self, p0):
                     """
                 def on_right_click(self, pos):
                     self.menu = QtGui.QMenu()
-                    quitAction0 = self.menu.addAction("NewProject")
+                    quitAction0 = self.menu.addAction("Create a new project")
-                    quitAction1 = self.menu.addAction("NewProcessingUnit")
+                    quitAction1 = self.menu.addAction("Create a new processing unit")
-                    quitAction2 = self.menu.addAction("Delete")
+                    quitAction2 = self.menu.addAction("Delete selected unit")
-                    quitAction3 = self.menu.addAction("Exit")
+                    quitAction3 = self.menu.addAction("Quit")
                     if len(self.__itemTreeDict) == 0:
                         quitAction2.setEnabled(False)
                         #     print i.row()
                     if action == quitAction3:
-                        return
+                        self.close()
+                        return 0
                 def refreshProjectWindow(self, project_name, description, datatype, data_path, startDate, endDate, startTime, endTime, online, delay, set):
                         opObj = puObj.getOperationObj(name="selectChannels")
+                        if opObj == None:
+                            opObj = puObj.getOperationObj(name="selectChannelsByIndex")
                         if opObj == None:
                             self.volOpChannel.clear()
                             self.volOpCebChannels.setCheckState(0)
                         else:
-                            value = opObj.getParameterValue(parameterName='channelList')
+                            channelEnabled = False
-                            value = str(value)[1:-1]
+                            try:
-                            self.volOpChannel.setText(value)
+                                value = opObj.getParameterValue(parameterName='channelList')
-                            self.volOpChannel.setEnabled(True)
+                                value = str(value)[1:-1]
-                            self.volOpCebChannels.setCheckState(QtCore.Qt.Checked)
+                                channelEnabled = True
+                                channelMode = 0
+                            except:
+                                pass
+                            try:
+                                value = opObj.getParameterValue(parameterName='channelIndexList')
+                                value = str(value)[1:-1]
+                                channelEnabled = True
+                                channelMode = 1
+                            except:
+                                pass
+                            if channelEnabled:
+                                self.volOpChannel.setText(value)
+                                self.volOpChannel.setEnabled(True)
+                                self.volOpCebChannels.setCheckState(QtCore.Qt.Checked)
+                                self.VOLOpComChannel.setCurrentIndex(channelMode)
                         opObj = puObj.getOperationObj(name="selectHeights")
                         if opObj == None:
                             self.volOpHeights.clear()
                                 self.specOpCebCrossSpectra.setCheckState(QtCore.Qt.Checked)
                         opObj = puObj.getOperationObj(name="selectChannels")
+                        if opObj == None:
+                            opObj = puObj.getOperationObj(name="selectChannelsByIndex")
                         if opObj == None:
                             self.specOpChannel.clear()
                             self.specOpCebChannel.setCheckState(0)
                         else:
-                           value = opObj.getParameterValue(parameterName='channelList')
+                            channelEnabled = False
-                           value = str(value)[1:-1]
+                            try:
-                           self.specOpChannel.setText(value)
+                                value = opObj.getParameterValue(parameterName='channelList')
-                           self.specOpChannel.setEnabled(True)
+                                value = str(value)[1:-1]
-                           self.specOpCebChannel.setCheckState(QtCore.Qt.Checked)
+                                channelEnabled = True
+                                channelMode = 0
+                            except:
+                                pass
+                            try:
+                                value = opObj.getParameterValue(parameterName='channelIndexList')
+                                value = str(value)[1:-1]
+                                channelEnabled = True
+                                channelMode = 1
+                            except:
+                                pass
+                            if channelEnabled:
+                                self.specOpChannel.setText(value)
+                                self.specOpChannel.setEnabled(True)
+                                self.specOpCebChannel.setCheckState(QtCore.Qt.Checked)
+                                self.specOpComChannel.setCurrentIndex(channelMode)
                         opObj = puObj.getOperationObj(name="selectHeights")
                         if opObj == None:
                     self.specGgraphChannelList.clear()
                 def create_comm(self):
                     self.commCtrlPThread = CommCtrlProcessThread()
                     self.commCtrlPThread.start()
-                def create_timers(self):
+                def create_updating_timer(self):
                     self.comm_data_timer = QtCore.QTimer(self)
-                    self.comm_data_timer.timeout.connect(self.on_comm_data_timer)
+                    self.comm_data_timer.timeout.connect(self.on_comm_updating_timer)
-                    self.comm_data_timer.start(10)
+                    self.comm_data_timer.start(1000)
                 def create_figure(self):
                     self.queue_plot = Queue.Queue()
                     if not self.running:
                         app.quit()
-                def on_comm_data_timer(self):
+            #     def on_comm_data_timer(self):
-                    # lee el data_queue y la coloca en el queue de ploteo
+            #         # lee el data_queue y la coloca en el queue de ploteo
-                    try:
+            #         try:
-                        reply = self.commCtrlPThread.data_q.get(block=False)
+            #             reply = self.commCtrlPThread.data_q.get(block=False)
-                        self.queue_plot.put(reply.data)
+            #             self.queue_plot.put(reply.data)
+            #
-                    except Queue.Empty:
+            #         except Queue.Empty:
-                        pass
+            #             pass
                 def createProjectView(self, id):
                     self.create = False
                     if not procUnitConfObj:
                         return
-                    procUnitConfObj.removeOperations()
+                    projectObj.removeProcUnit(procUnitConfObj.getId())
+                    if procUnitConfObj.getId() not in self.__puObjDict.keys():
+                        return
                     self.__puObjDict.pop(procUnitConfObj.getId())
                         channel = value
                         self.bufferVoltage("Processing Unit", "Select Channel", channel)
+                    opObj = puObj.getOperationObj(name="selectChannelsByIndex")
+                    if opObj == None:
+                        channel = None
+                    else:
+                        value = opObj.getParameterValue(parameterName='channelIndexList')
+                        value = str(value)#[1:-1]
+                        channel = value
+                        self.bufferVoltage("Processing Unit", "Select Channel by Index", channel)
                     opObj = puObj.getOperationObj(name="selectHeights")
                     if opObj == None:
                         heights = None
                     opObj = puObj.getOperationObj(name="selectChannels")
                     if opObj == None:
                         channel = None
                     else:
-                       value = opObj.getParameterValue(parameterName='channelList')
+                        try:
-                       value = str(value)[1:-1]
+                            value = opObj.getParameterValue(parameterName='channelList')
-                       channel = value
+                            value = str(value)[1:-1]
-                       self.bufferSpectra("Processing Unit", "Channel", channel)
+                            channel = value
+                            self.bufferSpectra("Processing Unit", "Channel List", channel)
+                        except:
+                            pass
+                        try:
+                            value = opObj.getParameterValue(parameterName='channelIndexList')
+                            value = str(value)[1:-1]
+                            channel = value
+                            self.bufferSpectra("Processing Unit", "Channel Index List", channel)
+                        except:
+                            pass
                     opObj = puObj.getOperationObj(name="selectHeights")
                     if opObj == None:
                 def openProject(self):
+                    self.actionStart.setEnabled(False)
+                    self.actionStarToolbar.setEnabled(False)
                     self.create = False
                     self.frame_2.setEnabled(True)
                     home = expanduser("~")
                     self.console.append("The selected xml file has been loaded successfully")
                     # self.refreshPUWindow(datatype=datatype,puObj=puObj)
+                    self.actionStart.setEnabled(True)
+                    self.actionStarToolbar.setEnabled(True)
+                def on_comm_updating_timer(self):
+                    # Verifica si algun proceso ha sido inicializado y sigue ejecutandose
+                    if not self.__initialized:
+                        return
+                    if not self.commCtrlPThread.isRunning():
+                        self.stopProject()
                 def playProject(self, ext=".xml"):
                     projectObj = self.getSelectedProjectObj()
                     self.actionStopToolbar.setEnabled(True)
                     self.console.append("Please Wait...")
-            #             try:
                     self.commCtrlPThread.cmd_q.put(ProcessCommand(ProcessCommand.PROCESS, filename))
-            # #
+                    sleep(0.5)
-            #             except:
+                    self.__initialized = True
-            #                 self.console.append("Error............................................!")
-            #                 self.actionStarToolbar.setEnabled(True)
-            #                 self.actionPauseToolbar.setEnabled(False)
-            #                 self.actionStopToolbar.setEnabled(False)
-            #         filename = '/home/dsuarez/workspace_signalchain/schain_guiJune04/test/ewdrifts3.xml'
-            #         data = filename
-            #         self.commCtrlPThread.cmd_q.put(ProcessCommand(ProcessCommand.PROCESS, data))
                 def stopProject(self):
+                    self.__initialized = False
                     self.commCtrlPThread.cmd_q.put(ProcessCommand(ProcessCommand.STOP, True))
                     self.actionStart.setEnabled(True)
                     sys.stderr = sys.__stderr__
                 def normalOutputWritten(self, text):
-                    self.console.append(text)
+                    color_black = QtGui.QColor(0,0,0)
+                    self.console.setTextColor(color_black)
+                    self.console.append(text)
+                def errorOutputWritten(self, text):
+                    color_red = QtGui.QColor(255,0,0)
+                    color_black = QtGui.QColor(0,0,0)
+                    self.console.setTextColor(color_red)
+                    self.console.append(text)
+                    self.console.setTextColor(color_black)
                 def setParameter(self):
                     self.setWindowTitle("ROJ-Signal Chain")
                     self.setWindowIcon(QtGui.QIcon( os.path.join(FIGURES_PATH,"adn.jpg") ))
-                    sys.stdout = ShowMeConsole(textWritten=self.normalOutputWritten)
-                    # sys.stderr = ShowMeConsole(textWritten=self.normalOutputWritten)
                     self.tabWidgetProject.setEnabled(False)
                     self.tabVoltage.setEnabled(False)
                     self.tabSpectra.setEnabled(False)
                     self.specGgraphDbsrange.setToolTip('Example: 30,170')
                     self.specGraphPrefix.setToolTip('Example: EXPERIMENT_NAME')
+                    sys.stdout = ShowMeConsole(textWritten=self.normalOutputWritten)
+                    sys.stderr = ShowMeConsole(textWritten=self.errorOutputWritten)
             class UnitProcessWindow(QMainWindow, Ui_UnitProcess):

schainpy/gui/viewcontroller/comm.py +17 -2

             import threading
             import Queue
-            from time import sleep
+            try:
+                from gevent import sleep
+            except:
+                from time import sleep
             from schainpy.controller  import Project
             from command import *
                     self.socketIO = None
                     self.mySocket = None
+                    self.controllerObj = None
                     self.handlers = {
                         ProcessCommand.PROCESS: self._handle_ioPROCESSTHREAD,
                             sleep(0.1)
                             continue
+                def isRunning(self):
+                    if self.controllerObj == None:
+                        return False
+                    if self.controllerObj.isAlive():
+                        return True
+                    return False
                 def _handle_ioPROCESSTHREAD(self, cmd):
                     filename = cmd.data
                     self.controllerObj = ControllerThread(filename=filename)
                 def _handle_ioSTOP(self, cmd):
                     self.controllerObj.stop()
+                    self.controllerObj.join()
+            #         print "Process thread finished"
                 def _handle_ioDATA(self, cmd):
                     self.reply_q.put(self._success_reply_data(data=cmd.data))

schainpy/model/data/jroamisr.py +7 0

@@ -79,5 +79,12 class AMISR:
79	def isEmpty(self):	79	def isEmpty(self):
80		80
81	return self.flagNoData	81	return self.flagNoData
		82
		83	def getTimeInterval(self):
		84
		85	timeInterval = self.ippSeconds * self.nCohInt
		86
		87	return timeInterval
82		88
		89	timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
83	nHeights = property(getNHeights, "I'm the 'nHeights' property.") No newline at end of file	90	nHeights = property(getNHeights, "I'm the 'nHeights' property.")

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

                 pairsList = None
+                nCohInt = None
                 nIncohInt = None
                 def __init__(self):
                     self.blocksize = None
                     self.profileIndex = 0
+                    self.nCohInt = 1
+                    self.nIncohInt = 1
                 def getNormFactor(self):
                     pwcode = 1
                 normFactor = property(getNormFactor, "I'm the 'getNormFactor' property.")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
-            class Fits:
+            class Fits(JROData):
                 heightList = None
                     self.utctime = None
-                    self.nCohInt = None
+                    self.nCohInt = 1
-                    self.nIncohInt = None
+                    self.nIncohInt = 1
                     self.useLocalTime = True
                 def getTimeInterval(self):
-                    raise ValueError, "This method is not implemented yet"
+                    timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
+                    return timeInterval
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                     noise = jspectra0[:,freq_dc,:] - jspectra[:,freq_dc,:]
                     return noise
+                def getTimeInterval(self):
+                    timeInterval = self.ippSeconds * self.nCohInt * self.nPoints
+                    return timeInterval
+                timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             #     pairsList = property(getPairsList, "I'm the 'pairsList' property.")
             #     nPoints = property(getNPoints, "I'm the 'nPoints' property.")
                 calculateVelocity = property(getCalculateVelocity, "I'm the 'calculateVelocity' property.")
                 noise = None            #Noise Potency
-                initUtcTime = None      #Initial UTC time
+            #     initUtcTime = None      #Initial UTC time
                 paramInterval = None    #Time interval to calculate Parameters in seconds
                 data_output = None       #Out signal
                 def __init__(self):
                     '''
                     Constructor
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Parameters"
                 def getTimeRange1(self):
                     datatime = []
-                    datatime.append(self.initUtcTime)
+                    datatime.append(self.ltctime)
-                    datatime.append(self.initUtcTime + self.outputInterval - 1)
+                    datatime.append(self.ltctime + self.outputInterval - 1)
                     datatime = numpy.array(datatime)

schainpy/model/graphics/figure.py +2 -38

@@ -102,42 +102,6 class Figure(Operation):
102	xmax_sec = time.mktime(maxdt.timetuple())	102	xmax_sec = time.mktime(maxdt.timetuple())
103		103
104	return xmin_sec, xmax_sec	104	return xmin_sec, xmax_sec
105
106
107
108
109
110	# if timerange != None:
111	# txmin = x[0] - x[0]%timerange
112	# else:
113	# txmin = numpy.min(x)
114	#
115	# thisdatetime = datetime.datetime.utcfromtimestamp(txmin)
116	# thisdate = datetime.datetime.combine(thisdatetime.date(), datetime.time(0,0,0))
117	#
118	# ####################################################
119	# #If the x is out of xrange
120	# if xmax != None:
121	# if xmax < (thisdatetime - thisdate).seconds/(60*60.):
122	# xmin = None
123	# xmax = None
124	#
125	# if xmin == None:
126	# td = thisdatetime - thisdate
127	# xmin = td.seconds/(60*60.)
128	#
129	# if xmax == None:
130	# xmax = xmin + self.timerange/(60*60.)
131	#
132	# mindt = thisdate + datetime.timedelta(hours=xmin) - datetime.timedelta(seconds=time.timezone)
133	# tmin = time.mktime(mindt.timetuple())
134	#
135	# maxdt = thisdate + datetime.timedelta(hours=xmax) - datetime.timedelta(seconds=time.timezone)
136	# tmax = time.mktime(maxdt.timetuple())
137	#
138	# #self.timerange = tmax - tmin
139	#
140	# return tmin, tmax
141		105
142	def init(self, id, nplots, wintitle):	106	def init(self, id, nplots, wintitle):
143		107
@@ -284,9 +248,9 class Figure(Operation):
284		248
285	raise ValueError, "This method is not implemented"	249	raise ValueError, "This method is not implemented"
286		250
287	def close(self):	251	def close(self, show=False):
288		252
289	self.__driver.closeFigure()	253	self.__driver.closeFigure(show=show, fig=self.fig)
290		254
291	axesList = property(getAxesObjList)	255	axesList = property(getAxesObjList)
292		256

schainpy/model/graphics/jroplot_spectra.py +2 -1

                                 raise ValueError, "Pair %s is not in dataOut.pairsList" %str(pair)
                             pairsIndexList.append(dataOut.pairsList.index(pair))
-                    if pairsIndexList == []:
+                    if not pairsIndexList:
                         return
                     if len(pairsIndexList) > 4:
                         pairsIndexList = pairsIndexList[0:4]
                     factor = dataOut.normFactor
                     x = dataOut.getVelRange(1)
                     y = dataOut.getHeiRange()

schainpy/model/graphics/mpldriver.py +14 -4

                 return fig
-            def closeFigure(show=False):
+            def closeFigure(show=False, fig=None):
                 matplotlib.pyplot.ioff()
+                matplotlib.pyplot.pause(0.1)
                 if show:
                     matplotlib.pyplot.show()
-                matplotlib.pyplot.close()
+                if fig != None:
+                    matplotlib.pyplot.close(fig)
+                    matplotlib.pyplot.pause(0.1)
+                    matplotlib.pyplot.ion()
+                    return
+                matplotlib.pyplot.close("all")
+                matplotlib.pyplot.pause(0.1)
+                matplotlib.pyplot.ion()
                 return
             def saveFigure(fig, filename):
             def draw(fig):
                 if type(fig) == 'int':
-                    raise ValueError, "This parameter should be of tpye matplotlib figure"
+                    raise ValueError, "Error drawing: Fig parameter should be a matplotlib figure object figure"
                 fig.canvas.draw()

schainpy/model/io/jroIO_amisr.py +6 -1

             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jroamisr import AMISR
+            try:
+                from gevent import sleep
+            except:
+                from time import sleep
             class RadacHeader():
                 def __init__(self, fp):
                     header = 'Raw11/Data/RadacHeader'
                         filename = self.filenameList[0]
                         while self.__filename_online == filename:
                             print 'waiting %d seconds to get a new file...'%(self.__waitForNewFile)
-                            time.sleep(self.__waitForNewFile)
+                            sleep(self.__waitForNewFile)
                             self.__selectDataForTimes(online=True)
                             filename = self.filenameList[0]

schainpy/model/io/jroIO_heispectra.py +25 -10

@@ -384,6 +384,21 class FitsReader(ProcessingUnit):
384		384
385	return 1	385	return 1
386		386
		387	def __setValuesFromHeader(self):
		388
		389	self.dataOut.header = self.header_dict
		390	self.dataOut.expName = self.expName
		391	self.dataOut.nChannels = self.nChannels
		392	self.dataOut.timeZone = self.timeZone
		393	self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile
		394	self.dataOut.comments = self.comments
		395	# self.dataOut.timeInterval = self.timeInterval
		396	self.dataOut.channelList = self.channelList
		397	self.dataOut.heightList = self.heightList
		398
		399	self.dataOut.nCohInt = self.nCohInt
		400	self.dataOut.nIncohInt = self.nIncohInt
		401
387	def readHeader(self):	402	def readHeader(self):
388	headerObj = self.fitsObj[0]	403	headerObj = self.fitsObj[0]
389		404
@@ -438,7 +453,7 class FitsReader(ProcessingUnit):
438	return 0	453	return 0
439		454
440	self.readHeader()	455	self.readHeader()
441		456	self.__setValuesFromHeader()
442	self.nReadBlocks = 0	457	self.nReadBlocks = 0
443	# self.blockIndex = 1	458	# self.blockIndex = 1
444	return 1	459	return 1
@@ -695,15 +710,15 class FitsReader(ProcessingUnit):
695	self.dataOut.data_header = self.data_header_dict	710	self.dataOut.data_header = self.data_header_dict
696	self.dataOut.utctime = self.utc	711	self.dataOut.utctime = self.utc
697		712
698	self.dataOut.header = self.header_dict	713	# self.dataOut.header = self.header_dict
699	self.dataOut.expName = self.expName	714	# self.dataOut.expName = self.expName
700	self.dataOut.nChannels = self.nChannels	715	# self.dataOut.nChannels = self.nChannels
701	self.dataOut.timeZone = self.timeZone	716	# self.dataOut.timeZone = self.timeZone
702	self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile	717	# self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile
703	self.dataOut.comments = self.comments	718	# self.dataOut.comments = self.comments
704	self.dataOut.timeInterval = self.timeInterval	719	# # self.dataOut.timeInterval = self.timeInterval
705	self.dataOut.channelList = self.channelList	720	# self.dataOut.channelList = self.channelList
706	self.dataOut.heightList = self.heightList	721	# self.dataOut.heightList = self.heightList
707	self.dataOut.flagNoData = False	722	self.dataOut.flagNoData = False
708		723
709	return self.dataOut.data	724	return self.dataOut.data

schainpy/model/io/jroIO_hf.py +7 -3

             from model.data.jrodata import Voltage
             from model.proc.jroproc_base import ProcessingUnit, Operation
+            try:
+                from gevent import sleep
+            except:
+                from time import sleep
             def isNumber(str):
                 """
                         filename = self.filenameList[0]
                         while self.filename_online == filename:
                             print 'waiting %d seconds to get a new file...'%(self.__waitForNewFile)
-                            time.sleep(self.__waitForNewFile)
+                            sleep(self.__waitForNewFile)
                             #self.__findDataForDates(online=True)
                             self.__selectDataForTimes(online=True)
                             filename = self.filenameList[0]
                         print "%s is not the rigth  size"%filename
                         delay=2
                         print 'waiting %d seconds for delay...'%(delay)
-                        time.sleep(delay)
+                        sleep(delay)
                     sizeoffile=os.path.getsize(filename)
                     if sizeoffile<1670240:
                         delay
                         print 'waiting %d  more seconds for delay...'%(delay)
-                        time.sleep(delay)
+                        sleep(delay)

schainpy/model/proc/jroproc_correlation.py +3 -3

                     self.profIndex = 0
                     self.dataOut = Correlation()
-                def __updateObjFromInput(self):
+                def __updateObjFromVoltage(self):
                     self.dataOut.timeZone = self.dataIn.timeZone
                     self.dataOut.dstFlag = self.dataIn.dstFlag
                     self.dataOut.ippSeconds = self.dataIn.ippSeconds
             #        self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
-                    self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nPoints
+            #         self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nPoints
                 def removeDC(self, jspectra):
                                 self.buffer = self.removeDC(self.buffer)
                             #---------------------------------------------
                             self.dataOut.data_volts = self.buffer
-                            self.__updateObjFromInput()
+                            self.__updateObjFromVoltage()
                             self.dataOut.data_corr = numpy.zeros((len(pairsList),
                                                              len(lagT),len(lagR),
                                                              self.dataIn.nHeights),

schainpy/model/proc/jroproc_heispectra.py +8 -4

             #        self.profIndex = 0
                     self.dataOut = SpectraHeis()
-                def __updateObjFromInput(self):
+                def __updateObjFromVoltage(self):
                     self.dataOut.timeZone = self.dataIn.timeZone
                     self.dataOut.dstFlag = self.dataIn.dstFlag
             #         self.dataOut.ippSeconds= self.dataIn.ippSeconds
                     self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
-                    self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nIncohInt
+            #         self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nIncohInt
             #        self.dataOut.set=self.dataIn.set
             #        self.dataOut.deltaHeight=self.dataIn.deltaHeight
                 def __updateObjFromFits(self):
                     self.dataOut.utctime = self.dataIn.utctime
                     self.dataOut.channelIndexList = self.dataIn.channelIndexList
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.data_spc = self.dataIn.data
-                    self.dataOut.timeInterval = self.dataIn.timeInterval
+                    self.dataOut.ippSeconds = self.dataIn.ippSeconds
+                    self.dataOut.nCohInt = self.dataIn.nCohInt
+                    self.dataOut.nIncohInt = self.dataIn.nIncohInt
+            #         self.dataOut.timeInterval = self.dataIn.timeInterval
                     self.dataOut.timeZone = self.dataIn.timeZone
                     self.dataOut.useLocalTime = True
             #         self.dataOut.
                         return
                     if self.dataIn.type == "Voltage":
-                        self.__updateObjFromInput()
+                        self.__updateObjFromVoltage()
                         self.__getFft()
                         self.dataOut.flagNoData = False

schainpy/model/proc/jroproc_parameters.py +8 -2

                     return A1
                 def __correctValues(self, heiRang, phi, velRadial, SNR):
                     listPhi = phi.tolist()
                     maxid = listPhi.index(max(listPhi))
                     minid = listPhi.index(min(listPhi))
                         else:   correctFactor = 1
                         if kwargs.has_key('channelList'):
                             channelList = kwargs['channelList']
-                            if len(channelList) == 2:
-                                horizontalOnly = True
                             arrayChannel = numpy.array(channelList)
                             param = param[arrayChannel,:,:]
                             theta_x = theta_x[arrayChannel]
                             theta_y = theta_y[arrayChannel]
                         velRadial0 = param[:,1,:] #Radial velocity
+                        if velRadial0.shape[0] != theta_x.shape[0] or velRadial0.shape[0] != theta_y.shape[0]:
+                            raise ValueError, "The max number of channels is %d, and the length of cosine director is %d. Please check: dirCosX, dirCosY, elevation or azimuth arguments" %(velRadial0.shape[0], theta_x.shape[0])
+                        if theta_x.shape[0] == 2:
+                                horizontalOnly = True
                         dataOut.data_output, dataOut.heightList, dataOut.data_SNR = self.techniqueDBS(velRadial0, theta_x, theta_y, azimuth, correctFactor, horizontalOnly, heightList, SNR) #DBS Function
                         dataOut.utctimeInit = dataOut.utctime
                         dataOut.outputInterval = dataOut.timeInterval

schainpy/model/proc/jroproc_spectra.py +47 -7

                         #calculo de cross-spectra
                         cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
                         for pair in self.dataOut.pairsList:
+                            if pair[0] not in self.dataOut.channelList:
+                                raise ValueError, "Error getting CrossSpectra: pair 0 of (%s) is not in channelList=%s" %(str(pair), str(self.dataOut.channelList))
+                            if pair[1] not in self.dataOut.channelList:
+                                raise ValueError, "Error getting CrossSpectra: pair 1 of (%s) is not in channelList=%s" %(str(pair), str(self.dataOut.channelList))
                             cspc[pairIndex,:,:] = fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:])
                             pairIndex += 1
                         blocksize += cspc.size
                         return True
-                    raise ValueError, "The type object %s is not valid"%(self.dataIn.type)
+                    raise ValueError, "The type of input object '%s' is not valid"%(self.dataIn.type)
+                def __selectPairs(self, channelList=None):
+                    if channelList == None:
+                        return
+                    pairsIndexListSelected = []
+                    for pairIndex in self.dataOut.pairsIndexList:
+                        #First pair
+                        if self.dataOut.pairsList[pairIndex][0] not in channelList:
+                            continue
+                        #Second pair
+                        if self.dataOut.pairsList[pairIndex][1] not in channelList:
+                            continue
+                        pairsIndexListSelected.append(pairIndex)
+                    if not pairsIndexListSelected:
+                        self.dataOut.data_cspc = None
+                        self.dataOut.pairsList = []
+                        return
+                    self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndexListSelected]
+                    self.dataOut.pairsList = self.dataOut.pairsList[pairsIndexListSelected]
+                    return
                 def selectChannels(self, channelList):
                     for channel in channelList:
                         if channel not in self.dataOut.channelList:
-                            continue
+                            raise ValueError, "Error selecting channels: The value %d in channelList is not valid.\nAvailable channels = %s" %(channel, str(self.dataOut.channelList))
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
-                            print channelIndexList
+                            raise ValueError, "Error selecting channels: The value %d in channelIndexList is not valid.\nAvailable channel indexes = " %(channelIndex, self.dataOut.channelIndexList)
-                            raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
             #         nChannels = len(channelIndexList)
                     data_spc = self.dataOut.data_spc[channelIndexList,:]
+                    data_dc = self.dataOut.data_dc[channelIndexList,:]
                     self.dataOut.data_spc = data_spc
+                    self.dataOut.data_dc = data_dc
                     self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
             #        self.dataOut.nChannels = nChannels
+                    self.__selectPairs(self.dataOut.channelList)
                     return 1
                 def selectHeights(self, minHei, maxHei):
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
-                    if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
-                        raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
+                    if (minHei > maxHei):
+                        raise ValueError, "Error selecting heights: Height range (%d,%d) is not valid" % (minHei, maxHei)
+                    if (minHei < self.dataOut.heightList[0]):
+                        minHei = self.dataOut.heightList[0]
                     if (maxHei > self.dataOut.heightList[-1]):
                         maxHei = self.dataOut.heightList[-1]
                     """
                     if (minIndex < 0) or (minIndex > maxIndex):
-                        raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
+                        raise ValueError, "Error selecting heights by index: Index range in (%d,%d) is not valid" % (minIndex, maxIndex)
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights-1

schainpy/model/proc/jroproc_voltage.py +4 -4

                     self.dataOut.data = self.dataIn.data
                     self.dataOut.utctime = self.dataIn.utctime
                     self.dataOut.channelList = self.dataIn.channelList
-                    self.dataOut.timeInterval = self.dataIn.timeInterval
+            #         self.dataOut.timeInterval = self.dataIn.timeInterval
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.nProfiles = self.dataIn.nProfiles
                     for channel in channelList:
                         if channel not in self.dataOut.channelList:
-                            continue
+                            raise ValueError, "Channel %d is not in %s" %(channel, str(self.dataOut.channelList))
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                         flip = self.flip
                         profileList = range(self.dataOut.nProfiles)
-                        if channelList == []:
+                        if not channelList:
                             for thisProfile in profileList:
                                 data[:,thisProfile,:] = data[:,thisProfile,:]*flip
                                 flip *= -1.0
                         self.flip = flip
                     else:
-                        if channelList == []:
+                        if not channelList:
                             data[:,:] = data[:,:]*self.flip
                         else:
                             for thisChannel in channelList:

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