schain Commit - r672:a1a5642b5594 · Jicamarca Repository

Version: 2.1.3.2...

Miguel Valdez -

r672:a1a5642b5594

parent child

Context file:

r672:a1a5642b5594

Collapse all files

The requested changes are too big and content was truncated. Show full diff

schainpy/VERSION +4 0

             VERSIONS:
 .1.2:
             -jroutils_ftp.py: Bug fixed, Any error sending file stopped the Server Thread
             				  Server thread opens and closes remote server each time file list is sent
             -jroplot_spectra.py: Noise path was not being created saving noise data.
             -jroIO_base.py: startTime can be greater than endTime
 .1.3:
             -jroplot_heispectra.py: SpectraHeisScope was not showing the right channels
             -jroproc_voltage.py: Bug fixed selecting profiles (self.nProfiles took a wrong value),
             					 Bug fixed selecting heights by block (selecting profiles instead heights)
             -jroproc_voltage.py: New feature added: decoding data by block using FFT.
             -jroIO_heispectra.py: Bug fixed in FitsReader. Using local Fits object instead schainpy.mode.data.jrodata.Fits object.
             -jroIO_heispectra.py: Channel index list does not exist.
 .1.3.1:
             -GUI: every icon were resized
             -jroproc_voltage.py: Print a message when "Read from code" option is selected and the code is not defined inside data file
+.1.3.2:
+            -GUI: user interaction enhanced
+            -controller_api.py: Safe access to ControllerThead
  No newline at end of file

schainpy/__init__.py +1 -1

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
-            __version__ = "2.1.3.1"
  No newline at end of file
+            __version__ = "2.1.3.2"
  No newline at end of file

schainpy/controller.py +84 -38

             '''
             Created on September , 2012
             @author:
             '''
             from xml.etree.ElementTree import ElementTree, Element, SubElement, tostring
             from xml.dom import minidom
             from model import *
+            from time import sleep
-            try:
-                from gevent import sleep
-            except:
-                from time import sleep
+            import sys
             import ast
+            import traceback
+            SCHAIN_MAIL = "miguel.urco@jro.igp.gob.pe"
+            EMAIL_SERVER = "jro.igp.gob.pe"
             def prettify(elem):
                 """Return a pretty-printed XML string for the Element.
                 """
                 rough_string = tostring(elem, 'utf-8')
                 reparsed = minidom.parseString(rough_string)
                 return reparsed.toprettyxml(indent="  ")
             class ParameterConf():
                 id = None
                 name = None
                 value = None
                 format = None
                 __formated_value = None
                 ELEMENTNAME = 'Parameter'
                 def __init__(self):
                     self.format = 'str'
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getValue(self):
                     value = self.value
                     format = self.format
                     if self.__formated_value != None:
                         return self.__formated_value
                     if format == 'str':
                         self.__formated_value = str(value)
                         return self.__formated_value
                     if value == '':
                         raise ValueError, "%s: This parameter value is empty" %self.name
                     if format == 'bool':
                         value = int(value)
                     if format == 'list':
                         strList = value.split(',')
                         self.__formated_value = strList
                         return self.__formated_value
                     if format == 'intlist':
                         """
                         Example:
                             value = (0,1,2)
                         """
                         value = value.replace('(', '')
                         value = value.replace(')', '')
                         value = value.replace('[', '')
                         value = value.replace(']', '')
                         strList = value.split(',')
                         intList = [int(float(x)) for x in strList]
                         self.__formated_value = intList
                         return self.__formated_value
                     if format == 'floatlist':
                         """
                         Example:
                             value = (0.5, 1.4, 2.7)
                         """
                         value = value.replace('(', '')
                         value = value.replace(')', '')
                         value = value.replace('[', '')
                         value = value.replace(']', '')
                         strList = value.split(',')
                         floatList = [float(x) for x in strList]
                         self.__formated_value = floatList
                         return self.__formated_value
                     if format == 'date':
                         strList = value.split('/')
                         intList = [int(x) for x in strList]
                         date = datetime.date(intList[0], intList[1], intList[2])
                         self.__formated_value = date
                         return self.__formated_value
                     if format == 'time':
                         strList = value.split(':')
                         intList = [int(x) for x in strList]
                         time = datetime.time(intList[0], intList[1], intList[2])
                         self.__formated_value = time
                         return self.__formated_value
                     if format == 'pairslist':
                         """
                         Example:
                             value = (0,1),(1,2)
                         """
                         value = value.replace('(', '')
                         value = value.replace(')', '')
                         value = value.replace('[', '')
                         value = value.replace(']', '')
                         strList = value.split(',')
                         intList = [int(item) for item in strList]
                         pairList = []
                         for i in range(len(intList)/2):
                             pairList.append((intList[i*2], intList[i*2 + 1]))
                         self.__formated_value = pairList
                         return self.__formated_value
                     if format == 'multilist':
                         """
                         Example:
                             value = (0,1,2),(3,4,5)
                         """
                         multiList = ast.literal_eval(value)
                         if type(multiList[0]) == int:
                             multiList = ast.literal_eval("(" + value + ")")
                         self.__formated_value = multiList
                         return self.__formated_value
                     format_func = eval(format)
                     self.__formated_value = format_func(value)
                     return self.__formated_value
                 def updateId(self, new_id):
                     self.id = str(new_id)
                 def setup(self, id, name, value, format='str'):
                     self.id = str(id)
                     self.name = name
                     self.value = str(value)
                     self.format = str.lower(format)
                     try:
                         self.getValue()
                     except:
                         return 0
                     return 1
                 def update(self, name, value, format='str'):
                     self.name = name
                     self.value = str(value)
                     self.format = format
                 def makeXml(self, opElement):
                     parmElement = SubElement(opElement, self.ELEMENTNAME)
                     parmElement.set('id', str(self.id))
                     parmElement.set('name', self.name)
                     parmElement.set('value', self.value)
                     parmElement.set('format', self.format)
                 def readXml(self, parmElement):
                     self.id = parmElement.get('id')
                     self.name = parmElement.get('name')
                     self.value = parmElement.get('value')
                     self.format = str.lower(parmElement.get('format'))
                     #Compatible with old signal chain version
                     if self.format == 'int' and self.name == 'idfigure':
                         self.name = 'id'
                 def printattr(self):
                     print "Parameter[%s]: name = %s, value = %s, format = %s" %(self.id, self.name, self.value, self.format)
             class OperationConf():
                 id = None
                 name = None
                 priority = None
                 type = None
                 parmConfObjList = []
                 ELEMENTNAME = 'Operation'
                 def __init__(self):
                     self.id = '0'
                     self.name = None
                     self.priority = None
                     self.type = 'self'
                 def __getNewId(self):
                     return int(self.id)*10 + len(self.parmConfObjList) + 1
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     n = 1
                     for parmObj in self.parmConfObjList:
                         idParm = str(int(new_id)*10 + n)
                         parmObj.updateId(idParm)
                         n += 1
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getParameterObjList(self):
                     return self.parmConfObjList
                 def getParameterObj(self, parameterName):
                     for parmConfObj in self.parmConfObjList:
                         if parmConfObj.name != parameterName:
                             continue
                         return parmConfObj
                     return None
                 def getParameterObjfromValue(self, parameterValue):
                     for parmConfObj in self.parmConfObjList:
                         if parmConfObj.getValue() != parameterValue:
                             continue
                         return parmConfObj.getValue()
                     return None
                 def getParameterValue(self, parameterName):
                     parameterObj = self.getParameterObj(parameterName)
             #         if not parameterObj:
             #             return None
                     value = parameterObj.getValue()
                     return value
                 def setup(self, id, name, priority, type):
                     self.id = str(id)
                     self.name = name
                     self.type = type
                     self.priority = priority
                     self.parmConfObjList = []
                 def removeParameters(self):
                     for obj in self.parmConfObjList:
                         del obj
                     self.parmConfObjList = []
                 def addParameter(self, name, value, format='str'):
                     id = self.__getNewId()
                     parmConfObj = ParameterConf()
                     if not parmConfObj.setup(id, name, value, format):
                         return None
                     self.parmConfObjList.append(parmConfObj)
                     return parmConfObj
                 def changeParameter(self, name, value, format='str'):
                     parmConfObj = self.getParameterObj(name)
                     parmConfObj.update(name, value, format)
                     return parmConfObj
                 def makeXml(self, upElement):
                     opElement = SubElement(upElement, self.ELEMENTNAME)
                     opElement.set('id', str(self.id))
                     opElement.set('name', self.name)
                     opElement.set('type', self.type)
                     opElement.set('priority', str(self.priority))
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.makeXml(opElement)
                 def readXml(self, opElement):
                     self.id = opElement.get('id')
                     self.name = opElement.get('name')
                     self.type = opElement.get('type')
                     self.priority = opElement.get('priority')
                     #Compatible with old signal chain version
                     #Use of 'run' method instead 'init'
                     if self.type == 'self' and self.name == 'init':
                         self.name = 'run'
                     self.parmConfObjList = []
                     parmElementList = opElement.getiterator(ParameterConf().getElementName())
                     for parmElement in parmElementList:
                         parmConfObj = ParameterConf()
                         parmConfObj.readXml(parmElement)
                         #Compatible with old signal chain version
                         #If an 'plot' OPERATION is found, changes name operation by the value of its type PARAMETER
                         if self.type != 'self' and self.name == 'Plot':
                             if parmConfObj.format == 'str' and parmConfObj.name == 'type':
                                 self.name = parmConfObj.value
                                 continue
                         self.parmConfObjList.append(parmConfObj)
                 def printattr(self):
                     print "%s[%s]: name = %s, type = %s, priority = %s" %(self.ELEMENTNAME,
                                                                           self.id,
                                                                           self.name,
                                                                           self.type,
                                                                           self.priority)
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.printattr()
                 def createObject(self):
                     if self.type == 'self':
                         raise ValueError, "This operation type cannot be created"
                     if self.type == 'external' or self.type == 'other':
                         className = eval(self.name)
                         opObj = className()
                     return opObj
             class ProcUnitConf():
                 id = None
                 name = None
                 datatype = None
                 inputId = None
                 parentId = None
                 opConfObjList = []
                 procUnitObj = None
                 opObjList = []
                 ELEMENTNAME = 'ProcUnit'
                 def __init__(self):
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.opConfObjList = []
                     self.procUnitObj = None
                     self.opObjDict = {}
                 def __getPriority(self):
                     return len(self.opConfObjList)+1
                 def __getNewId(self):
                     return int(self.id)*10 + len(self.opConfObjList) + 1
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getId(self):
                     return self.id
                 def updateId(self, new_id, parentId=parentId):
                     new_id = int(parentId)*10 + (int(self.id) % 10)
                     new_inputId = int(parentId)*10 + (int(self.inputId) % 10)
                     #If this proc unit has not inputs
                     if self.inputId == '0':
                         new_inputId = 0
                     n = 1
                     for opConfObj in self.opConfObjList:
                         idOp = str(int(new_id)*10 + n)
                         opConfObj.updateId(idOp)
                         n += 1
                     self.parentId = str(parentId)
                     self.id = str(new_id)
                     self.inputId = str(new_inputId)
                 def getInputId(self):
                     return self.inputId
                 def getOperationObjList(self):
                     return self.opConfObjList
                 def getOperationObj(self, name=None):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.name != name:
                             continue
                         return opConfObj
                     return None
                 def getOpObjfromParamValue(self, value=None):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.getParameterObjfromValue(parameterValue=value) != value:
                             continue
                         return opConfObj
                     return None
                 def getProcUnitObj(self):
                     return self.procUnitObj
                 def setup(self, id, name, datatype, inputId, parentId=None):
                     #Compatible with old signal chain version
                     if datatype==None and name==None:
                         raise ValueError, "datatype or name should be defined"
                     if name==None:
                         if 'Proc' in datatype:
                             name = datatype
                         else:
                             name = '%sProc' %(datatype)
                     if datatype==None:
                         datatype = name.replace('Proc','')
                     self.id = str(id)
                     self.name = name
                     self.datatype = datatype
                     self.inputId = inputId
                     self.parentId = parentId
                     self.opConfObjList = []
                     self.addOperation(name='run', optype='self')
                 def removeOperations(self):
                     for obj in self.opConfObjList:
                         del obj
                     self.opConfObjList = []
                     self.addOperation(name='run')
                 def addParameter(self, **kwargs):
                     '''
                     Add parameters to "run" operation
                     '''
                     opObj = self.opConfObjList[0]
                     opObj.addParameter(**kwargs)
                     return opObj
                 def addOperation(self, name, optype='self'):
                     id = self.__getNewId()
                     priority = self.__getPriority()
                     opConfObj = OperationConf()
                     opConfObj.setup(id, name=name, priority=priority, type=optype)
                     self.opConfObjList.append(opConfObj)
                     return opConfObj
                 def makeXml(self, procUnitElement):
                     upElement = SubElement(procUnitElement, self.ELEMENTNAME)
                     upElement.set('id', str(self.id))
                     upElement.set('name', self.name)
                     upElement.set('datatype', self.datatype)
                     upElement.set('inputId', str(self.inputId))
                     for opConfObj in self.opConfObjList:
                         opConfObj.makeXml(upElement)
                 def readXml(self, upElement):
                     self.id = upElement.get('id')
                     self.name = upElement.get('name')
                     self.datatype = upElement.get('datatype')
                     self.inputId = upElement.get('inputId')
                     if self.ELEMENTNAME == "ReadUnit":
                         self.datatype = self.datatype.replace("Reader", "")
                     if self.ELEMENTNAME == "ProcUnit":
                         self.datatype = self.datatype.replace("Proc", "")
                     if self.inputId == 'None':
                         self.inputId = '0'
                     self.opConfObjList = []
                     opElementList = upElement.getiterator(OperationConf().getElementName())
                     for opElement in opElementList:
                         opConfObj = OperationConf()
                         opConfObj.readXml(opElement)
                         self.opConfObjList.append(opConfObj)
                 def printattr(self):
                     print "%s[%s]: name = %s, datatype = %s, inputId = %s" %(self.ELEMENTNAME,
                                                                          self.id,
                                                                          self.name,
                                                                          self.datatype,
                                                                          self.inputId)
                     for opConfObj in self.opConfObjList:
                         opConfObj.printattr()
                 def createObjects(self):
                     className = eval(self.name)
                     procUnitObj = className()
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type == 'self':
                             continue
                         opObj = opConfObj.createObject()
                         self.opObjDict[opConfObj.id] = opObj
                         procUnitObj.addOperation(opObj, opConfObj.id)
                     self.procUnitObj = procUnitObj
                     return procUnitObj
                 def run(self):
-                    finalSts = False
+                    is_ok = False
                     for opConfObj in self.opConfObjList:
                         kwargs = {}
                         for parmConfObj in opConfObj.getParameterObjList():
                             if opConfObj.name == 'run' and parmConfObj.name == 'datatype':
                                 continue
                             kwargs[parmConfObj.name] = parmConfObj.getValue()
                         #print "\tRunning the '%s' operation with %s" %(opConfObj.name, opConfObj.id)
                         sts = self.procUnitObj.call(opType = opConfObj.type,
                                                     opName = opConfObj.name,
                                                     opId = opConfObj.id,
                                                      **kwargs)
-                        finalSts = finalSts or sts
+                        is_ok = is_ok or sts
-                    return finalSts
+                    return is_ok
                 def close(self):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type == 'self':
                             continue
                         opObj = self.procUnitObj.getOperationObj(opConfObj.id)
                         opObj.close()
                     self.procUnitObj.close()
                     return
             class ReadUnitConf(ProcUnitConf):
                 path = None
                 startDate = None
                 endDate = None
                 startTime = None
                 endTime = None
                 ELEMENTNAME = 'ReadUnit'
                 def __init__(self):
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.parentId = None
                     self.opConfObjList = []
                     self.opObjList = []
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def setup(self, id, name, datatype, path, startDate="", endDate="", startTime="", endTime="", parentId=None, **kwargs):
                     #Compatible with old signal chain version
                     if datatype==None and name==None:
                         raise ValueError, "datatype or name should be defined"
                     if name==None:
                         if 'Reader' in datatype:
                             name = datatype
                         else:
                             name = '%sReader' %(datatype)
                     if datatype==None:
                         datatype = name.replace('Reader','')
                     self.id = id
                     self.name = name
                     self.datatype = datatype
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.inputId = '0'
                     self.parentId = parentId
                     self.addRunOperation(**kwargs)
                 def update(self, datatype, path, startDate, endDate, startTime, endTime, parentId=None, name=None, **kwargs):
                     #Compatible with old signal chain version
                     if datatype==None and name==None:
                         raise ValueError, "datatype or name should be defined"
                     if name==None:
                         if 'Reader' in datatype:
                             name = datatype
                         else:
                             name = '%sReader' %(datatype)
                     if datatype==None:
                         datatype = name.replace('Reader','')
                     self.datatype = datatype
                     self.name = name
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.inputId = '0'
                     self.parentId = parentId
                     self.updateRunOperation(**kwargs)
                 def addRunOperation(self, **kwargs):
                     opObj = self.addOperation(name = 'run', optype = 'self')
                     opObj.addParameter(name='datatype' , value=self.datatype, format='str')
                     opObj.addParameter(name='path'     , value=self.path, format='str')
                     opObj.addParameter(name='startDate' , value=self.startDate, format='date')
                     opObj.addParameter(name='endDate'   , value=self.endDate, format='date')
                     opObj.addParameter(name='startTime' , value=self.startTime, format='time')
                     opObj.addParameter(name='endTime'   , value=self.endTime, format='time')
                     for key, value in kwargs.items():
                         opObj.addParameter(name=key, value=value, format=type(value).__name__)
                     return opObj
                 def updateRunOperation(self, **kwargs):
                     opObj = self.getOperationObj(name = 'run')
                     opObj.removeParameters()
                     opObj.addParameter(name='datatype' , value=self.datatype, format='str')
                     opObj.addParameter(name='path'     , value=self.path, format='str')
                     opObj.addParameter(name='startDate' , value=self.startDate, format='date')
                     opObj.addParameter(name='endDate'   , value=self.endDate, format='date')
                     opObj.addParameter(name='startTime' , value=self.startTime, format='time')
                     opObj.addParameter(name='endTime'   , value=self.endTime, format='time')
                     for key, value in kwargs.items():
                         opObj.addParameter(name=key, value=value, format=type(value).__name__)
                     return opObj
             class Project():
                 id = None
                 name = None
                 description = None
             #    readUnitConfObjList = None
                 procUnitConfObjDict = None
                 ELEMENTNAME = 'Project'
-                def __init__(self, control=None, dataq=None):
+                def __init__(self):
                     self.id = None
                     self.name = None
                     self.description = None
                     self.procUnitConfObjDict = {}
-                    #global data_q
-                    #data_q = dataq
-                    if control==None:
-                        control = {'stop':False,'pause':False}
-                    self.control = control
                 def __getNewId(self):
                     id = int(self.id)*10 + len(self.procUnitConfObjDict) + 1
                     return str(id)
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getId(self):
                     return self.id
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     keyList = self.procUnitConfObjDict.keys()
                     keyList.sort()
                     n = 1
                     newProcUnitConfObjDict = {}
                     for procKey in keyList:
                         procUnitConfObj = self.procUnitConfObjDict[procKey]
                         idProcUnit = str(int(self.id)*10 + n)
                         procUnitConfObj.updateId(idProcUnit, parentId = self.id)
                         newProcUnitConfObjDict[idProcUnit] = procUnitConfObj
                         n += 1
                     self.procUnitConfObjDict = newProcUnitConfObjDict
                 def setup(self, id, name, description):
                     self.id = str(id)
                     self.name = name
                     self.description = description
                 def update(self, name, description):
                     self.name = name
                     self.description = description
                 def addReadUnit(self, datatype=None, name=None, **kwargs):
                     idReadUnit = self.__getNewId()
                     readUnitConfObj = ReadUnitConf()
                     readUnitConfObj.setup(idReadUnit, name, datatype, parentId=self.id, **kwargs)
                     self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     return readUnitConfObj
                 def addProcUnit(self, inputId='0', datatype=None, name=None):
                     idProcUnit = self.__getNewId()
                     procUnitConfObj = ProcUnitConf()
                     procUnitConfObj.setup(idProcUnit, name, datatype, inputId, parentId=self.id)
                     self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                     return procUnitConfObj
                 def removeProcUnit(self, id):
                     if id in self.procUnitConfObjDict.keys():
                         self.procUnitConfObjDict.pop(id)
                 def getReadUnitId(self):
                     readUnitConfObj = self.getReadUnitObj()
                     return readUnitConfObj.id
                 def getReadUnitObj(self):
                     for obj in self.procUnitConfObjDict.values():
                         if obj.getElementName() == "ReadUnit":
                             return obj
                     return None
                 def getProcUnitObj(self, id=None, name=None):
                     if id != None:
                         return self.procUnitConfObjDict[id]
                     if name != None:
                         return self.getProcUnitObjByName(name)
                     return None
                 def getProcUnitObjByName(self, name):
                     for obj in self.procUnitConfObjDict.values():
                         if obj.name == name:
                             return obj
                     return None
                 def procUnitItems(self):
                     return self.procUnitConfObjDict.items()
                 def makeXml(self):
                     projectElement = Element('Project')
                     projectElement.set('id', str(self.id))
                     projectElement.set('name', self.name)
                     projectElement.set('description', self.description)
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.makeXml(projectElement)
                     self.projectElement = projectElement
                 def writeXml(self, filename):
                     self.makeXml()
                     #print prettify(self.projectElement)
                     ElementTree(self.projectElement).write(filename, method='xml')
                 def readXml(self, filename):
                     self.projectElement = None
                     self.procUnitConfObjDict = {}
                     self.projectElement = ElementTree().parse(filename)
                     self.project = self.projectElement.tag
                     self.id = self.projectElement.get('id')
                     self.name = self.projectElement.get('name')
                     self.description = self.projectElement.get('description')
                     readUnitElementList = self.projectElement.getiterator(ReadUnitConf().getElementName())
                     for readUnitElement in readUnitElementList:
                         readUnitConfObj = ReadUnitConf()
                         readUnitConfObj.readXml(readUnitElement)
                         if readUnitConfObj.parentId == None:
                             readUnitConfObj.parentId = self.id
                         self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     procUnitElementList = self.projectElement.getiterator(ProcUnitConf().getElementName())
                     for procUnitElement in procUnitElementList:
                         procUnitConfObj = ProcUnitConf()
                         procUnitConfObj.readXml(procUnitElement)
                         if procUnitConfObj.parentId == None:
                             procUnitConfObj.parentId = self.id
                         self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                 def printattr(self):
                     print "Project[%s]: name = %s, description = %s" %(self.id,
                                                                           self.name,
                                                                           self.description)
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.printattr()
                 def createObjects(self):
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.createObjects()
                 def __connect(self, objIN, thisObj):
                     thisObj.setInput(objIN.getOutputObj())
                 def connectObjects(self):
                     for thisPUConfObj in self.procUnitConfObjDict.values():
                         inputId = thisPUConfObj.getInputId()
                         if int(inputId) == 0:
                             continue
                         #Get input object
                         puConfINObj = self.procUnitConfObjDict[inputId]
                         puObjIN = puConfINObj.getProcUnitObj()
                         #Get current object
                         thisPUObj = thisPUConfObj.getProcUnitObj()
                         self.__connect(puObjIN, thisPUObj)
+                def isPaused(self):
+                    return 0
+                def isStopped(self):
+                    return 0
+                def runController(self):
+                    """
+                    returns 0 when this process has been stopped, 1 otherwise
+                    """
+                    if self.isPaused():
+                        print "Process suspended"
+                        while True:
+                            sleep(0.1)
+                            if not self.isPaused():
+                                break
+                            if self.isStopped():
+                                break
+                        print "Process reinitialized"
+                    if self.isStopped():
+                        print "Process stopped"
+                        return 0
+                    return 1
                 def run(self):
                     print
-                    print "*"*50
+                    print "*"*60
                     print "   Starting SIGNAL CHAIN PROCESSING  "
-                    print "*"*50
+                    print "*"*60
                     print
                     keyList = self.procUnitConfObjDict.keys()
                     keyList.sort()
                     while(True):
-                        finalSts = False
+                        is_ok = False
                         for procKey in keyList:
             #                 print "Running the '%s' process with %s" %(procUnitConfObj.name, procUnitConfObj.id)
                             procUnitConfObj = self.procUnitConfObjDict[procKey]
-                            sts = procUnitConfObj.run()
-                            finalSts = finalSts or sts
+                            message = ""
+                            try:
+                                sts = procUnitConfObj.run()
+                                is_ok = is_ok or sts
+                            except:
+                                sleep(1)
+                                err = traceback.format_exception(sys.exc_info()[0],
+                                                                 sys.exc_info()[1],
+                                                                 sys.exc_info()[2])
+                                for thisLine in err:
+                                    message += thisLine
+                                print message
+            #                     self.sendReport(message)
+                                sleep(0.1)
+                                is_ok = False
+                                break
                         #If every process unit finished so end process
-                        if not(finalSts):
+                        if not(is_ok):
+                            print message
                             print "Every process unit have finished"
                             break
-                        if self.control['pause']:
+                        if not self.runController():
-                            print "Process suspended"
-                            while True:
-                                sleep(0.1)
-                                if not self.control['pause']:
-                                    break
-                                if self.control['stop']:
-                                    break
-                            print "Process reinitialized"
-                        if self.control['stop']:
-            #                 print "Process stopped"
                             break
                     #Closing every process
                     for procKey in keyList:
                         procUnitConfObj = self.procUnitConfObjDict[procKey]
                         procUnitConfObj.close()
                     print "Process finished"
                 def start(self, filename):
                     self.writeXml(filename)
                     self.readXml(filename)
                     self.createObjects()
                     self.connectObjects()
                     self.run()
+                def sendReport(self, message, subject="Error occurred in Signal Chain", email=SCHAIN_MAIL):
+                    import smtplib
+                    print subject
+                    print "Sending report to %s ..." %email
+                    message = 'From: (Python Signal Chain API) ' + email + '\n' + \
+                    'To: ' + email + '\n' + \
+                    'Subject: ' + str(subject) + '\n' + \
+                    'Content-type: text/html\n\n' + message
+                    server = smtplib.SMTP(EMAIL_SERVER)
+                    server.sendmail(email.split(',')[0],
+                                    email.split(','), message)
+                    server.quit()
             if __name__ == '__main__':
                 desc = "Segundo Test"
                 filename = "schain.xml"
                 controllerObj = Project()
                 controllerObj.setup(id = '191', name='test01', description=desc)
                 readUnitConfObj = controllerObj.addReadUnit(datatype='Voltage',
                                                             path='data/rawdata/',
                                                             startDate='2011/01/01',
                                                             endDate='2012/12/31',
                                                             startTime='00:00:00',
                                                             endTime='23:59:59',
                                                             online=1,
                                                             walk=1)
                 procUnitConfObj0 = controllerObj.addProcUnit(datatype='Voltage', inputId=readUnitConfObj.getId())
                 opObj10 = procUnitConfObj0.addOperation(name='selectChannels')
                 opObj10.addParameter(name='channelList', value='3,4,5', format='intlist')
                 opObj10 = procUnitConfObj0.addOperation(name='selectHeights')
                 opObj10.addParameter(name='minHei', value='90', format='float')
                 opObj10.addParameter(name='maxHei', value='180', format='float')
                 opObj12 = procUnitConfObj0.addOperation(name='CohInt', optype='external')
                 opObj12.addParameter(name='n', value='10', format='int')
                 procUnitConfObj1 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj0.getId())
                 procUnitConfObj1.addParameter(name='nFFTPoints', value='32', format='int')
             #    procUnitConfObj1.addParameter(name='pairList', value='(0,1),(0,2),(1,2)', format='')
                 opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
                 opObj11.addParameter(name='idfigure', value='1', format='int')
                 opObj11.addParameter(name='wintitle', value='SpectraPlot0', format='str')
                 opObj11.addParameter(name='zmin', value='40', format='int')
                 opObj11.addParameter(name='zmax', value='90', format='int')
                 opObj11.addParameter(name='showprofile', value='1', format='int')
                 print "Escribiendo el archivo XML"
                 controllerObj.writeXml(filename)
                 print "Leyendo el archivo XML"
                 controllerObj.readXml(filename)
                 #controllerObj.printattr()
                 controllerObj.createObjects()
                 controllerObj.connectObjects()
                 controllerObj.run()
   No newline at end of file

schainpy/controller_api.py +62 -60

             import threading
             from PyQt4 import QtCore
             from PyQt4.QtCore import SIGNAL
             from schainpy.controller import Project
             class ControllerThread(threading.Thread, Project):
                 def __init__(self, filename):
                     threading.Thread.__init__(self)
                     Project.__init__(self)
                     self.setDaemon(True)
                     self.filename = filename
+                    self.lock = threading.Lock()
                     self.control = {'stop':False, 'pause':False}
                 def __del__(self):
                     self.control['stop'] = True
-            #         self.pause(1)
-            #         self.wait()
                 def stop(self):
+                    self.lock.acquire()
                     self.control['stop'] = True
+                    self.lock.release()
                 def pause(self):
+                    self.lock.acquire()
                     self.control['pause'] = not(self.control['pause'])
+                    paused = self.control['pause']
+                    self.lock.release()
-                    return self.control['pause']
+                    return paused
-                def __run(self):
+                def isPaused(self):
-                    print
+                    self.lock.acquire()
-                    print "*"*40
+                    paused = self.control['pause']
-                    print "   Starting SIGNAL CHAIN PROCESSING  "
+                    self.lock.release()
-                    print "*"*40
-                    print
-                    keyList = self.procUnitConfObjDict.keys()
+                    return paused
-                    keyList.sort()
+                def isStopped(self):
-                    while(True):
-                        finalSts = False
-                        #executed proc units
-                        procUnitExecutedList = []
-                        for procKey in keyList:
-            #                 print "Running the '%s' process with %s" %(procUnitConfObj.name, procUnitConfObj.id)
-                            procUnitConfObj = self.procUnitConfObjDict[procKey]
-                            inputId = procUnitConfObj.getInputId()
-                            sts = procUnitConfObj.run()
-                            finalSts = finalSts or sts
-                            procUnitExecutedList.append(procUnitConfObj.id)
-                        #If every process unit finished so end process
-                        if not(finalSts):
-                            print "Every process unit have finished"
-                            break
-                        if self.control['pause']:
-                            print "Process suspended"
-                            while True:
-                                sleep(0.1)
-                                if not self.control['pause']:
-                                    break
-                                if self.control['stop']:
-                                    break
-                            print "Process reinitialized"
-                        if self.control['stop']:
-            #                 print "Process stopped"
-                            break
-                    #Closing every process
-                    for procKey in keyList:
-                        procUnitConfObj = self.procUnitConfObjDict[procKey]
-                        procUnitConfObj.close()
-                    print "Process finished"
+                    self.lock.acquire()
+                    stopped = self.control['stop']
+                    self.lock.release()
+                    return stopped
                 def run(self):
                     self.control['stop'] = False
                     self.control['pause'] = False
                     self.readXml(self.filename)
                     self.createObjects()
                     self.connectObjects()
                     Project.run(self)
                 def isRunning(self):
                     return self.is_alive()
                 def isFinished(self):
                     return not self.is_alive()
             class ControllerQThread(QtCore.QThread, Project):
                 def __init__(self, filename):
                     QtCore.QThread.__init__(self)
                     Project.__init__(self)
                     self.filename = filename
+                    self.lock = threading.Lock()
                     self.control = {'stop':False, 'pause':False}
                 def __del__(self):
                     self.control['stop'] = True
                     self.wait()
                 def stop(self):
+                    self.lock.acquire()
                     self.control['stop'] = True
+                    self.lock.release()
                 def pause(self):
+                    self.lock.acquire()
                     self.control['pause'] = not(self.control['pause'])
+                    paused = self.control['pause']
+                    self.lock.release()
+                    return paused
+                def isPaused(self):
+                    self.lock.acquire()
+                    paused = self.control['pause']
+                    self.lock.release()
+                    return paused
+                def isStopped(self):
+                    self.lock.acquire()
+                    stopped = self.control['stop']
+                    self.lock.release()
+                    return stopped
                 def run(self):
                     self.control['stop'] = False
                     self.control['pause'] = False
                     self.readXml(self.filename)
                     self.createObjects()
                     self.connectObjects()
                     self.emit( SIGNAL( "jobStarted( PyQt_PyObject )" ), 1)
                     Project.run(self)
-                    self.emit( SIGNAL( "jobFinished( PyQt_PyObject )" ), 1)
  No newline at end of file
+                    self.emit( SIGNAL( "jobFinished( PyQt_PyObject )" ), 1)
+  No newline at end of file

schainpy/gui/viewcontroller/basicwindow.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/gui/viewer/ui_mainwindow.py +3 -4

             # -*- coding: utf-8 -*-
             # Form implementation generated from reading ui file '/home/alex/ui/MainWindow_21_02_13_v49.ui'
             #
             # Created: Mon Mar 24 13:28:36 2014
             #      by: PyQt4 UI code generator 4.10
             #
             # WARNING! All changes made in this file will be lost!
             from PyQt4 import QtCore, QtGui
             from windows import *
             try:
                 _fromUtf8 = QtCore.QString.fromUtf8
             except AttributeError:
                 def _fromUtf8(s):
                     return s
             try:
                 _encoding = QtGui.QApplication.UnicodeUTF8
                 def _translate(context, text, disambig):
                     return QtGui.QApplication.translate(context, text, disambig, _encoding)
             except AttributeError:
                 def _translate(context, text, disambig):
                     return QtGui.QApplication.translate(context, text, disambig)
             import os
             from schainpy.gui.figures import tools
             from schainpy import __version__
             FIGURES_PATH = tools.get_path()
             class Ui_EnvWindow(object):
                 paused = False
                 def restorePauseIcon(self):
                     icon_name = "pause.png"
                     iconPause = QtGui.QIcon()
                     iconPause.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH, icon_name) )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     self.actionPauseToolbar.setIcon(iconPause)
                 def restoreStartIcon(self):
                     icon_name = "start.png"
                     iconStart = QtGui.QIcon()
                     iconStart.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH, icon_name) )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     self.actionStarToolbar.setIcon(iconStart)
                 def changePauseIcon(self, paused=False):
                     if paused == True:
                         icon_name = "pausered.png"
                     else:
                         icon_name = "pause.png"
                     iconPause = QtGui.QIcon()
                     iconPause.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH, icon_name) )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     self.actionPauseToolbar.setIcon(iconPause)
                     return
                 def changeStartIcon(self, started=False):
                     if started == True:
                         icon_name = "startred.png"
                     else:
                         icon_name = "start.png"
                     iconStart = QtGui.QIcon()
                     iconStart.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH, icon_name) )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     self.actionStarToolbar.setIcon(iconStart)
                     return
                 def setupUi(self, MainWindow):
                     self.paused=False
                     MainWindow.setObjectName(_fromUtf8("MainWindow"))
                     MainWindow.resize(1200, 800)
                     self.centralWidget = QtGui.QWidget(MainWindow)
                     self.centralWidget.setObjectName(_fromUtf8("centralWidget"))
                     self.gridLayout_16 = QtGui.QGridLayout(self.centralWidget)
                     self.gridLayout_16.setObjectName(_fromUtf8("gridLayout_16"))
                     self.splitter_2 = QtGui.QSplitter(self.centralWidget)
                     self.splitter_2.setOrientation(QtCore.Qt.Horizontal)
                     self.splitter_2.setObjectName(_fromUtf8("splitter_2"))
                     self.projectExplorerTree = QtGui.QTreeView(self.splitter_2)
                     self.projectExplorerTree.setObjectName(_fromUtf8("projectExplorerTree"))
                     self.splitter = QtGui.QSplitter(self.splitter_2)
                     self.splitter.setOrientation(QtCore.Qt.Vertical)
                     self.splitter.setObjectName(_fromUtf8("splitter"))
                     self.tabWidgetProject = QtGui.QTabWidget(self.splitter)
                     self.tabWidgetProject.setMinimumSize(QtCore.QSize(0, 278))
                     self.tabWidgetProject.setMaximumSize(QtCore.QSize(16777215, 16777215))
                     self.tabWidgetProject.setObjectName(_fromUtf8("tabWidgetProject"))
                     self.tabConsole = QtGui.QTabWidget(self.splitter)
                     self.tabConsole.setMinimumSize(QtCore.QSize(0, 0))
                     self.tabConsole.setObjectName(_fromUtf8("tabConsole"))
                     self.tab_5 = QtGui.QWidget()
                     self.tab_5.setObjectName(_fromUtf8("tab_5"))
                     self.gridLayout_4 = QtGui.QGridLayout(self.tab_5)
                     self.gridLayout_4.setObjectName(_fromUtf8("gridLayout_4"))
                     self.console = QtGui.QTextEdit(self.tab_5)
                     self.console.setObjectName(_fromUtf8("console"))
                     self.gridLayout_4.addWidget(self.console, 0, 0, 1, 1)
                     self.tabConsole.addTab(self.tab_5, _fromUtf8(""))
                     self.tabWidget = QtGui.QTabWidget(self.splitter_2)
                     self.tabWidget.setObjectName(_fromUtf8("tabWidget"))
                     self.tabProjectProperty = QtGui.QWidget()
                     self.tabProjectProperty.setObjectName(_fromUtf8("tabProjectProperty"))
                     self.gridLayout_8 = QtGui.QGridLayout(self.tabProjectProperty)
                     self.gridLayout_8.setObjectName(_fromUtf8("gridLayout_8"))
                     self.treeProjectProperties = QtGui.QTreeView(self.tabProjectProperty)
                     self.treeProjectProperties.setObjectName(_fromUtf8("treeProjectProperties"))
                     self.gridLayout_8.addWidget(self.treeProjectProperties, 0, 0, 1, 1)
                     self.tabWidget.addTab(self.tabProjectProperty, _fromUtf8(""))
                     self.gridLayout_16.addWidget(self.splitter_2, 1, 0, 1, 1)
                     MainWindow.setCentralWidget(self.centralWidget)
                     self.toolBar = QtGui.QToolBar(MainWindow)
                     self.toolBar.setObjectName(_fromUtf8("toolBar"))
                     MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)
                     self.menuBar = QtGui.QMenuBar(MainWindow)
                     self.menuBar.setGeometry(QtCore.QRect(0, 0, 1065, 25))
                     self.menuBar.setObjectName(_fromUtf8("menuBar"))
                     self.menuProject = QtGui.QMenu(self.menuBar)
                     self.menuProject.setObjectName(_fromUtf8("menuProject"))
                     self.menuRun = QtGui.QMenu(self.menuBar)
                     self.menuRun.setObjectName(_fromUtf8("menuRun"))
                     self.menuOptions = QtGui.QMenu(self.menuBar)
                     self.menuOptions.setObjectName(_fromUtf8("menuOptions"))
                     self.menuHelp = QtGui.QMenu(self.menuBar)
                     self.menuHelp.setObjectName(_fromUtf8("menuHelp"))
                     MainWindow.setMenuBar(self.menuBar)
                     iconOpen = QtGui.QIcon()
                     iconOpen.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"open.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     iconCreate = QtGui.QIcon()
                     iconCreate.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"new.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     iconSave = QtGui.QIcon()
                     iconSave.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"save.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     iconStart = QtGui.QIcon()
                     iconStart.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"start.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     iconStop = QtGui.QIcon()
                     iconStop.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"stop.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     iconPause = QtGui.QIcon()
                     iconPause.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"pause.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     iconAddPU = QtGui.QIcon()
                     iconAddPU.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"branch.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     iconClose = QtGui.QIcon()
                     iconClose.addPixmap(QtGui.QPixmap(_fromUtf8( os.path.join(FIGURES_PATH,"close.png") )), QtGui.QIcon.Normal, QtGui.QIcon.Off)
                     self.actionOpen = QtGui.QAction(MainWindow)
                     self.actionOpen.setIcon(iconOpen)
                     self.actionOpen.setObjectName(_fromUtf8("actionOpen"))
                     self.actionCreate = QtGui.QAction(MainWindow)
                     self.actionCreate.setIcon(iconCreate)
                     self.actionCreate.setObjectName(_fromUtf8("actionCreate"))
                     self.actionSave = QtGui.QAction(MainWindow)
                     self.actionSave.setIcon(iconSave)
                     self.actionSave.setObjectName(_fromUtf8("actionSave"))
                     self.actionClose = QtGui.QAction(MainWindow)
                     self.actionClose.setIcon(iconClose)
                     self.actionClose.setObjectName(_fromUtf8("actionClose"))
                     self.actionStart = QtGui.QAction(MainWindow)
                     self.actionStart.setIcon(iconStart)
                     self.actionStart.setObjectName(_fromUtf8("actionStart"))
                     self.actionPause = QtGui.QAction(MainWindow)
                     self.actionPause.setIcon(iconPause)
                     self.actionPause.setObjectName(_fromUtf8("actionPause"))
                     self.actionStop = QtGui.QAction(MainWindow)
                     self.actionStop.setIcon(iconStop)
                     self.actionStop.setObjectName(_fromUtf8("actionStop"))
                     self.actionAbout = QtGui.QAction(MainWindow)
                     self.actionAbout.setObjectName(_fromUtf8("actionAbout"))
                     self.actionOpenToolbar = QtGui.QAction(MainWindow)
                     self.actionOpenToolbar.setIcon(iconOpen)
                     self.actionOpenToolbar.setObjectName(_fromUtf8("actionOpenToolbar"))
                     self.actionCreateToolbar = QtGui.QAction(MainWindow)
                     self.actionCreateToolbar.setIcon(iconCreate)
                     self.actionCreateToolbar.setObjectName(_fromUtf8("actionCreateToolbar"))
                     self.actionSaveToolbar = QtGui.QAction(MainWindow)
                     self.actionSaveToolbar.setIcon(iconSave)
                     self.actionSaveToolbar.setObjectName(_fromUtf8("actionSaveToolbar"))
                     self.actionStarToolbar = QtGui.QAction(MainWindow)
                     self.actionStarToolbar.setIcon(iconStart)
                     self.actionStarToolbar.setObjectName(_fromUtf8("actionStarToolbar"))
                     self.actionStopToolbar = QtGui.QAction(MainWindow)
                     self.actionStopToolbar.setIcon(iconStop)
                     self.actionStopToolbar.setObjectName(_fromUtf8("actionStopToolbar"))
                     self.actionPauseToolbar = QtGui.QAction(MainWindow)
                     self.actionPause.setIcon(iconPause)
                     self.actionPauseToolbar.setIcon(iconPause)
                     self.actionPauseToolbar.setObjectName(_fromUtf8("actionPauseToolbar"))
                     self.actionAddPU = QtGui.QAction(MainWindow)
                     self.actionAddPU.setIcon(iconAddPU)
                     self.actionAddPU.setObjectName(_fromUtf8("actionAddPU"))
                     self.actionFTP = QtGui.QAction(MainWindow)
                     self.actionFTP.setObjectName(_fromUtf8("actionFTP"))
                     self.toolBar.addAction(self.actionOpenToolbar)
                     self.toolBar.addSeparator()
                     self.toolBar.addAction(self.actionCreateToolbar)
                     self.toolBar.addSeparator()
                     self.toolBar.addAction(self.actionAddPU)
                     self.toolBar.addSeparator()
                     self.toolBar.addAction(self.actionSaveToolbar)
                     self.toolBar.addSeparator()
                     self.toolBar.addAction(self.actionStarToolbar)
                     self.toolBar.addSeparator()
                     self.toolBar.addAction(self.actionPauseToolbar)
                     self.toolBar.addSeparator()
                     self.toolBar.addAction(self.actionStopToolbar)
                     self.toolBar.addSeparator()
             #         self.actionPause.triggered.connect(self.changePauseIcon)
             #         self.actionPauseToolbar.triggered.connect(self.changePauseIcon)
                     self.menuProject.addAction(self.actionOpen)
                     self.menuProject.addAction(self.actionCreate)
                     self.menuProject.addAction(self.actionSave)
                     self.menuProject.addAction(self.actionClose)
                     self.menuRun.addAction(self.actionStart)
                     self.menuRun.addAction(self.actionPause)
                     self.menuRun.addAction(self.actionStop)
                     self.menuOptions.addAction(self.actionFTP)
                     self.menuHelp.addAction(self.actionAbout)
                     self.menuBar.addAction(self.menuProject.menuAction())
                     self.menuBar.addAction(self.menuRun.menuAction())
                     self.menuBar.addAction(self.menuOptions.menuAction())
                     self.menuBar.addAction(self.menuHelp.menuAction())
                     self.tabConsole.setCurrentIndex(0)
                     self.tabWidget.setCurrentIndex(0)
                 def retranslateUi(self, MainWindow):
                     MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow", None))
                     self.tabConsole.setTabText(self.tabConsole.indexOf(self.tab_5), _translate("MainWindow", "Console", None))
                     self.tabWidget.setTabText(self.tabWidget.indexOf(self.tabProjectProperty), _translate("MainWindow", "Project Property", None))
                     self.toolBar.setWindowTitle(_translate("MainWindow", "toolBar", None))
                     self.menuProject.setTitle(_translate("MainWindow", "Project", None))
                     self.menuRun.setTitle(_translate("MainWindow", "Run", None))
                     self.menuOptions.setTitle(_translate("MainWindow", "Options", None))
                     self.menuHelp.setTitle(_translate("MainWindow", "Help", None))
                     self.actionOpen.setText(_translate("MainWindow", "Open", None))
                     self.actionCreate.setText(_translate("MainWindow", "Create", None))
                     self.actionSave.setText(_translate("MainWindow", "Save", None))
                     self.actionClose.setText(_translate("MainWindow", "Close", None))
                     self.actionStart.setText(_translate("MainWindow", "Start", None))
                     self.actionPause.setText(_translate("MainWindow", "Pause", None))
                     self.actionStop.setText(_translate("MainWindow", "Stop", None))
                     self.actionAbout.setText(_translate("MainWindow", "About SChain", None))
                     self.actionOpenToolbar.setText(_translate("MainWindow", "openToolbar", None))
                     self.actionOpenToolbar.setToolTip(_translate("MainWindow", "Open a project", None))
                     self.actionCreateToolbar.setText(_translate("MainWindow", "createToolbar", None))
                     self.actionCreateToolbar.setToolTip(_translate("MainWindow", "Create a new project", None))
                     self.actionSaveToolbar.setText(_translate("MainWindow", "saveToolbar", None))
                     self.actionSaveToolbar.setToolTip(_translate("MainWindow", "Save a project", None))
                     self.actionStarToolbar.setText(_translate("MainWindow", "starToolbar", None))
                     self.actionStarToolbar.setToolTip(_translate("MainWindow", "Start process", None))
                     self.actionStopToolbar.setText(_translate("MainWindow", "stopToolbar", None))
                     self.actionStopToolbar.setToolTip(_translate("MainWindow", "Stop process", None))
                     self.actionPauseToolbar.setText(_translate("MainWindow", "pauseToolbar", None))
                     self.actionPauseToolbar.setToolTip(_translate("MainWindow", "Pause process", None))
                     self.actionAddPU.setText(_translate("MainWindow", "Add Processing Unit", None))
                     self.actionFTP.setText(_translate("MainWindow", "FTP", None))
                 def closeEvent(self, event):
                     reply = QtGui.QMessageBox.question(self, 'Message',
                         "Are you sure to quit?", QtGui.QMessageBox.Yes |
                         QtGui.QMessageBox.No, QtGui.QMessageBox.No)
                     if reply == QtGui.QMessageBox.Yes:
                         event.accept()
                     else:
                         event.ignore()
                 def aboutEvent(self):
                     title = "Signal Chain Processing Software v%s" %__version__
                     message = """
-                    Developed by Jicamarca Radio Observatory
+            Developed by Jicamarca Radio Observatory
-                    Any comment to miguel.urco@jro.igp.gob.pe
+            Any comment to miguel.urco@jro.igp.gob.pe
-                    """
+            """
                     QtGui.QMessageBox.about(self, title, message)
             class Ui_BasicWindow(Ui_EnvWindow, Ui_ProjectTab, Ui_VoltageTab, Ui_SpectraTab, Ui_SpectraHeisTab, Ui_CorrelationTab):
                 def setupUi(self, MainWindow):
                     Ui_EnvWindow.setupUi(self, MainWindow)
                     Ui_ProjectTab.setupUi(self)
                     Ui_VoltageTab.setupUi(self)
                     Ui_SpectraTab.setupUi(self)
                     Ui_SpectraHeisTab.setupUi(self)
                     Ui_CorrelationTab.setupUi(self)
                     self.retranslateUi(MainWindow)
                     QtCore.QMetaObject.connectSlotsByName(MainWindow)
                 def retranslateUi(self, MainWindow):
                     Ui_EnvWindow.retranslateUi(self, MainWindow)
                     Ui_ProjectTab.retranslateUi(self)
                     Ui_VoltageTab.retranslateUi(self)
                     Ui_SpectraTab.retranslateUi(self)
                     Ui_SpectraHeisTab.retranslateUi(self)
                     Ui_CorrelationTab.retranslateUi(self)
             class Ui_AdvancedWindow(Ui_EnvWindow):
                 def setupUi(self, AdvancedWindow):
                     Ui_MainWindow.setupUi(self, AdvancedWindow)
                 def retranslateUi(self, AdvancedWindow):
                     Ui_MainWindow.retranslateUi(self, AdvancedWindow)
             if __name__ == "__main__":
                 import sys
                 app = QtGui.QApplication(sys.argv)
                 MainWindow = QtGui.QMainWindow()
                 ui = Ui_BasicWindow()
                 ui.setupUi(MainWindow)
                 MainWindow.show()
                 sys.exit(app.exec_())

schainpy/model/data/jroheaderIO.py +7 -4

             '''
             $Author: murco $
             $Id: JROHeaderIO.py 151 2012-10-31 19:00:51Z murco $
             '''
             import numpy
             import copy
             import datetime
             SPEED_OF_LIGHT = 299792458
             SPEED_OF_LIGHT = 3e8
             BASIC_STRUCTURE = numpy.dtype([
                                       ('nSize','<u4'),
                                       ('nVersion','<u2'),
                                       ('nDataBlockId','<u4'),
                                       ('nUtime','<u4'),
                                       ('nMilsec','<u2'),
                                       ('nTimezone','<i2'),
                                       ('nDstflag','<i2'),
                                       ('nErrorCount','<u4')
                                       ])
             SYSTEM_STRUCTURE = numpy.dtype([
                                         ('nSize','<u4'),
                                         ('nNumSamples','<u4'),
                                         ('nNumProfiles','<u4'),
                                         ('nNumChannels','<u4'),
                                         ('nADCResolution','<u4'),
                                         ('nPCDIOBusWidth','<u4'),
                                         ])
             RADAR_STRUCTURE = numpy.dtype([
                                          ('nSize','<u4'),
                                          ('nExpType','<u4'),
                                          ('nNTx','<u4'),
                                          ('fIpp','<f4'),
                                          ('fTxA','<f4'),
                                          ('fTxB','<f4'),
                                          ('nNumWindows','<u4'),
                                          ('nNumTaus','<u4'),
                                          ('nCodeType','<u4'),
                                          ('nLine6Function','<u4'),
                                          ('nLine5Function','<u4'),
                                          ('fClock','<f4'),
                                          ('nPrePulseBefore','<u4'),
                                          ('nPrePulseAfter','<u4'),
                                          ('sRangeIPP','<a20'),
                                          ('sRangeTxA','<a20'),
                                          ('sRangeTxB','<a20'),
                                          ])
             SAMPLING_STRUCTURE = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
             PROCESSING_STRUCTURE = numpy.dtype([
                                            ('nSize','<u4'),
                                            ('nDataType','<u4'),
                                            ('nSizeOfDataBlock','<u4'),
                                            ('nProfilesperBlock','<u4'),
                                            ('nDataBlocksperFile','<u4'),
                                            ('nNumWindows','<u4'),
                                            ('nProcessFlags','<u4'),
                                            ('nCoherentIntegrations','<u4'),
                                            ('nIncoherentIntegrations','<u4'),
                                            ('nTotalSpectra','<u4')
                                            ])
             class Header(object):
                 def __init__(self):
                     raise
                 def copy(self):
                     return copy.deepcopy(self)
                 def read(self):
                     raise ValueError
                 def write(self):
                     raise ValueError
                 def printInfo(self):
-                    print "#"*100
+                    message = "#"*50 + "\n"
-                    print self.__class__.__name__.upper()
+                    message += self.__class__.__name__.upper() + "\n"
-                    print "#"*100
+                    message += "#"*50 + "\n"
                     for key in self.__dict__.keys():
-                        print "%s = %s" %(key, self.__dict__[key])
+                        message += "%s = %s" %(key, self.__dict__[key]) + "\n"
+                    print message
             class BasicHeader(Header):
                 size = None
                 version = None
                 dataBlock = None
                 utc = None
                 ltc = None
                 miliSecond = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 datatime = None
                 __LOCALTIME = None
                 def __init__(self, useLocalTime=True):
                     self.size = 24
                     self.version = 0
                     self.dataBlock = 0
                     self.utc = 0
                     self.miliSecond = 0
                     self.timeZone = 0
                     self.dstFlag = 0
                     self.errorCount = 0
                     self.useLocalTime = useLocalTime
                 def read(self, fp):
                     try:
                         header = numpy.fromfile(fp, BASIC_STRUCTURE,1)
                         self.size = int(header['nSize'][0])
                         self.version = int(header['nVersion'][0])
                         self.dataBlock = int(header['nDataBlockId'][0])
                         self.utc = int(header['nUtime'][0])
                         self.miliSecond = int(header['nMilsec'][0])
                         self.timeZone = int(header['nTimezone'][0])
                         self.dstFlag = int(header['nDstflag'][0])
                         self.errorCount = int(header['nErrorCount'][0])
                     except Exception, e:
                         print "BasicHeader: "
                         print e
                         return 0
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
                     header = numpy.array(headerTuple, BASIC_STRUCTURE)
                     header.tofile(fp)
                     return 1
                 def get_ltc(self):
                     return self.utc - self.timeZone*60
                 def set_ltc(self, value):
                     self.utc = value + self.timeZone*60
                 def get_datatime(self):
                     return datetime.datetime.utcfromtimestamp(self.ltc)
                 ltc = property(get_ltc, set_ltc)
                 datatime = property(get_datatime)
             class SystemHeader(Header):
                 size = None
                 nSamples = None
                 nProfiles = None
                 nChannels = None
                 adcResolution = None
                 pciDioBusWidth = None
                 def __init__(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWith=0):
                     self.size = 24
                     self.nSamples = nSamples
                     self.nProfiles = nProfiles
                     self.nChannels = nChannels
                     self.adcResolution = adcResolution
                     self.pciDioBusWidth = pciDioBusWith
                 def read(self, fp):
                     startFp = fp.tell()
                     try:
                         header = numpy.fromfile(fp,SYSTEM_STRUCTURE,1)
                         self.size = header['nSize'][0]
                         self.nSamples = header['nNumSamples'][0]
                         self.nProfiles = header['nNumProfiles'][0]
                         self.nChannels = header['nNumChannels'][0]
                         self.adcResolution = header['nADCResolution'][0]
                         self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
                     except Exception, e:
                         print "SystemHeader: " + e
                         return 0
                     endFp = self.size + startFp
                     if fp.tell() != endFp:
                         raise IOError, "System Header is not consistent"
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
                     header = numpy.array(headerTuple,SYSTEM_STRUCTURE)
                     header.tofile(fp)
                     return 1
             class RadarControllerHeader(Header):
                 size = None
                 expType = None
                 nTx = None
                 ipp = None
                 txA = None
                 txB = None
                 nWindows = None
                 numTaus = None
                 codeType = None
                 line6Function = None
                 line5Function = None
                 fClock = None
                 prePulseBefore = None
                 prePulserAfter = None
                 rangeIpp = None
                 rangeTxA = None
                 rangeTxB = None
                 __size = None
                 def __init__(self, expType=2, nTx=1,
                              ippKm=None, txA=0, txB=0,
                              nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
                              numTaus=0, line6Function=0, line5Function=0, fClock=None,
                              prePulseBefore=0, prePulseAfter=0,
                              codeType=0, nCode=0, nBaud=0, code=None,
                              flip1=0, flip2=0):
                     self.size = 116
                     self.expType = expType
                     self.nTx = nTx
                     self.ipp = ippKm
                     self.txA = txA
                     self.txB = txB
                     self.rangeIpp = ippKm
                     self.rangeTxA = txA
                     self.rangeTxB = txB
                     self.nWindows = nWindows
                     self.numTaus = numTaus
                     self.codeType = codeType
                     self.line6Function = line6Function
                     self.line5Function = line5Function
                     self.fClock = fClock
                     self.prePulseBefore = prePulseBefore
                     self.prePulserAfter = prePulseAfter
                     self.nHeights = nHeights
                     self.firstHeight = firstHeight
                     self.deltaHeight = deltaHeight
                     self.samplesWin = nHeights
                     self.nCode = nCode
                     self.nBaud = nBaud
                     self.code = code
                     self.flip1 = flip1
                     self.flip2 = flip2
                     self.code_size = int(numpy.ceil(self.nBaud/32.))*self.nCode*4
             #         self.dynamic = numpy.array([],numpy.dtype('byte'))
                     if self.fClock is None and self.deltaHeight is not None:
                         self.fClock = 0.15/(deltaHeight*1e-6)   #0.15Km / (height * 1u)
                 def read(self, fp):
                     startFp = fp.tell()
                     header = numpy.fromfile(fp,RADAR_STRUCTURE,1)
                     size = int(header['nSize'][0])
                     self.expType = int(header['nExpType'][0])
                     self.nTx = int(header['nNTx'][0])
                     self.ipp = float(header['fIpp'][0])
                     self.txA = float(header['fTxA'][0])
                     self.txB = float(header['fTxB'][0])
                     self.nWindows = int(header['nNumWindows'][0])
                     self.numTaus = int(header['nNumTaus'][0])
                     self.codeType = int(header['nCodeType'][0])
                     self.line6Function = int(header['nLine6Function'][0])
                     self.line5Function = int(header['nLine5Function'][0])
                     self.fClock = float(header['fClock'][0])
                     self.prePulseBefore = int(header['nPrePulseBefore'][0])
                     self.prePulserAfter = int(header['nPrePulseAfter'][0])
                     self.rangeIpp = header['sRangeIPP'][0]
                     self.rangeTxA = header['sRangeTxA'][0]
                     self.rangeTxB = header['sRangeTxB'][0]
                     samplingWindow = numpy.fromfile(fp,SAMPLING_STRUCTURE,self.nWindows)
                     self.nHeights = int(numpy.sum(samplingWindow['nsa']))
                     self.firstHeight = samplingWindow['h0']
                     self.deltaHeight = samplingWindow['dh']
                     self.samplesWin = samplingWindow['nsa']
                     self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
                     self.code_size = 0
                     if self.codeType != 0:
                         self.nCode = int(numpy.fromfile(fp,'<u4',1))
                         self.nBaud = int(numpy.fromfile(fp,'<u4',1))
                         code = numpy.empty([self.nCode,self.nBaud],dtype='i1')
                         for ic in range(self.nCode):
                             temp = numpy.fromfile(fp,'u4',int(numpy.ceil(self.nBaud/32.)))
                             for ib in range(self.nBaud-1,-1,-1):
                                 code[ic,ib] = temp[ib/32]%2
                                 temp[ib/32] = temp[ib/32]/2
                         self.code = 2.0*code - 1.0
                         self.code_size = int(numpy.ceil(self.nBaud/32.))*self.nCode*4
             #             if self.line5Function == RCfunction.FLIP:
             #                 self.flip1 = numpy.fromfile(fp,'<u4',1)
             #
             #             if self.line6Function == RCfunction.FLIP:
             #                 self.flip2 = numpy.fromfile(fp,'<u4',1)
                     endFp = size + startFp
                     if fp.tell() != endFp:
                         raise IOError, "Radar Controller Header is not consistent"
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,
                                    self.expType,
                                    self.nTx,
                                    self.ipp,
                                    self.txA,
                                    self.txB,
                                    self.nWindows,
                                    self.numTaus,
                                    self.codeType,
                                    self.line6Function,
                                    self.line5Function,
                                    self.fClock,
                                    self.prePulseBefore,
                                    self.prePulserAfter,
                                    self.rangeIpp,
                                    self.rangeTxA,
                                    self.rangeTxB)
                     header = numpy.array(headerTuple,RADAR_STRUCTURE)
                     header.tofile(fp)
                     sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
                     samplingWindow = numpy.array(sampleWindowTuple,SAMPLING_STRUCTURE)
                     samplingWindow.tofile(fp)
                     if self.numTaus > 0:
                         self.Taus.tofile(fp)
                     if self.codeType !=0:
                         nCode = numpy.array(self.nCode, '<u4')
                         nCode.tofile(fp)
                         nBaud = numpy.array(self.nBaud, '<u4')
                         nBaud.tofile(fp)
                         code1 = (self.code + 1.0)/2.
                         for ic in range(self.nCode):
                             tempx = numpy.zeros(numpy.ceil(self.nBaud/32.))
                             start = 0
                             end = 32
                             for i in range(len(tempx)):
                                 code_selected = code1[ic,start:end]
                                 for j in range(len(code_selected)-1,-1,-1):
                                     if code_selected[j] == 1:
                                         tempx[i] = tempx[i] + 2**(len(code_selected)-1-j)
                                 start = start + 32
                                 end = end + 32
                             tempx = tempx.astype('u4')
                             tempx.tofile(fp)
             #         if self.line5Function == RCfunction.FLIP:
             #             self.flip1.tofile(fp)
             #
             #         if self.line6Function == RCfunction.FLIP:
             #             self.flip2.tofile(fp)
                     return 1
                 def get_ippSeconds(self):
                     '''
                     '''
                     ippSeconds = 2.0 * 1000 * self.ipp / SPEED_OF_LIGHT
                     return ippSeconds
                 def set_ippSeconds(self, ippSeconds):
                     '''
                     '''
                     self.ipp = ippSeconds * SPEED_OF_LIGHT / (2.0*1000)
                     return
                 def get_size(self):
                     self.__size = 116 + 12*self.nWindows + 4*self.numTaus
                     if self.codeType != 0:
                         self.__size += 4 + 4 + 4*self.nCode*numpy.ceil(self.nBaud/32.)
                     return self.__size
                 def set_size(self, value):
                     self.__size = value
                     return
                 ippSeconds = property(get_ippSeconds, set_ippSeconds)
                 size = property(get_size, set_size)
             class ProcessingHeader(Header):
             #     size = None
                 dtype = None
                 blockSize = None
                 profilesPerBlock = None
                 dataBlocksPerFile = None
                 nWindows = None
                 processFlags = None
                 nCohInt = None
                 nIncohInt = None
                 totalSpectra = None
                 flag_dc = None
                 flag_cspc = None
                 def __init__(self):
             #         self.size = 0
                     self.dtype = 0
                     self.blockSize = 0
                     self.profilesPerBlock = 0
                     self.dataBlocksPerFile = 0
                     self.nWindows = 0
                     self.processFlags = 0
                     self.nCohInt = 0
                     self.nIncohInt = 0
                     self.totalSpectra = 0
                     self.nHeights = 0
                     self.firstHeight = 0
                     self.deltaHeight = 0
                     self.samplesWin = 0
                     self.spectraComb = 0
                     self.nCode = None
                     self.code = None
                     self.nBaud = None
                     self.shif_fft = False
                     self.flag_dc = False
                     self.flag_cspc = False
                     self.flag_decode = False
                     self.flag_deflip = False
                 def read(self, fp):
                     startFp = fp.tell()
                     header = numpy.fromfile(fp,PROCESSING_STRUCTURE,1)
                     size = int(header['nSize'][0])
                     self.dtype = int(header['nDataType'][0])
                     self.blockSize = int(header['nSizeOfDataBlock'][0])
                     self.profilesPerBlock = int(header['nProfilesperBlock'][0])
                     self.dataBlocksPerFile = int(header['nDataBlocksperFile'][0])
                     self.nWindows = int(header['nNumWindows'][0])
                     self.processFlags = header['nProcessFlags']
                     self.nCohInt = int(header['nCoherentIntegrations'][0])
                     self.nIncohInt = int(header['nIncoherentIntegrations'][0])
                     self.totalSpectra = int(header['nTotalSpectra'][0])
                     samplingWindow = numpy.fromfile(fp,SAMPLING_STRUCTURE,self.nWindows)
                     self.nHeights = int(numpy.sum(samplingWindow['nsa']))
                     self.firstHeight = float(samplingWindow['h0'][0])
                     self.deltaHeight = float(samplingWindow['dh'][0])
                     self.samplesWin = samplingWindow['nsa'][0]
                     self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
                     if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
                         self.nCode = int(numpy.fromfile(fp,'<u4',1))
                         self.nBaud = int(numpy.fromfile(fp,'<u4',1))
                         self.code = numpy.fromfile(fp,'<f4',self.nCode*self.nBaud).reshape(self.nCode,self.nBaud)
                     if ((self.processFlags & PROCFLAG.EXP_NAME_ESP) == PROCFLAG.EXP_NAME_ESP):
                         exp_name_len = int(numpy.fromfile(fp,'<u4',1))
                         exp_name = numpy.fromfile(fp,'u1',exp_name_len+1)
                     if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
                         self.shif_fft = True
                     else:
                         self.shif_fft = False
                     if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
                         self.flag_dc = True
                     else:
                         self.flag_dc = False
                     if ((self.processFlags & PROCFLAG.DECODE_DATA) == PROCFLAG.DECODE_DATA):
                         self.flag_decode = True
                     else:
                         self.flag_decode = False
                     if ((self.processFlags & PROCFLAG.DEFLIP_DATA) == PROCFLAG.DEFLIP_DATA):
                         self.flag_deflip = True
                     else:
                         self.flag_deflip = False
                     nChannels = 0
                     nPairs = 0
                     pairList = []
                     for i in range( 0, self.totalSpectra*2, 2 ):
                         if self.spectraComb[i] == self.spectraComb[i+1]:
                             nChannels = nChannels + 1   #par de canales iguales
                         else:
                             nPairs = nPairs + 1 #par de canales diferentes
                             pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
                     self.flag_cspc = False
                     if nPairs > 0:
                         self.flag_cspc = True
                     endFp = size + startFp
                     if fp.tell() != endFp:
                         raise IOError, "Processing Header is not consistent"
                     return 1
                 def write(self, fp):
                     #Clear DEFINE_PROCESS_CODE
             #         self.processFlags = self.processFlags & (~PROCFLAG.DEFINE_PROCESS_CODE)
                     headerTuple = (self.size,
                                    self.dtype,
                                    self.blockSize,
                                    self.profilesPerBlock,
                                    self.dataBlocksPerFile,
                                    self.nWindows,
                                    self.processFlags,
                                    self.nCohInt,
                                    self.nIncohInt,
                                    self.totalSpectra)
                     header = numpy.array(headerTuple,PROCESSING_STRUCTURE)
                     header.tofile(fp)
                     if self.nWindows != 0:
                         sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
                         samplingWindow = numpy.array(sampleWindowTuple,SAMPLING_STRUCTURE)
                         samplingWindow.tofile(fp)
                     if self.totalSpectra != 0:
             #             spectraComb = numpy.array([],numpy.dtype('u1'))
                         spectraComb = self.spectraComb
                         spectraComb.tofile(fp)
                     if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
                         nCode = numpy.array([self.nCode], numpy.dtype('u4')) #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
                         nCode.tofile(fp)
                         nBaud = numpy.array([self.nBaud], numpy.dtype('u4'))
                         nBaud.tofile(fp)
                         code = self.code.reshape(self.nCode*self.nBaud)
                         code = code.astype(numpy.dtype('<f4'))
                         code.tofile(fp)
                     return 1
                 def get_size(self):
                     self.__size = 40 + 12*self.nWindows + 2*self.totalSpectra
                     if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
             #             self.__size += 4 + 4 + 4*self.nCode*numpy.ceil(self.nBaud/32.)
                         self.__size += 4 + 4 + 4 * self.nCode * self.nBaud
                     return self.__size
                 def set_size(self, value):
                     self.__size = value
                     return
                 size = property(get_size, set_size)
             class RCfunction:
                 NONE=0
                 FLIP=1
                 CODE=2
                 SAMPLING=3
                 LIN6DIV256=4
                 SYNCHRO=5
             class nCodeType:
                 NONE=0
                 USERDEFINE=1
                 BARKER2=2
                 BARKER3=3
                 BARKER4=4
                 BARKER5=5
                 BARKER7=6
                 BARKER11=7
                 BARKER13=8
                 AC128=9
                 COMPLEMENTARYCODE2=10
                 COMPLEMENTARYCODE4=11
                 COMPLEMENTARYCODE8=12
                 COMPLEMENTARYCODE16=13
                 COMPLEMENTARYCODE32=14
                 COMPLEMENTARYCODE64=15
                 COMPLEMENTARYCODE128=16
                 CODE_BINARY28=17
             class PROCFLAG:
                 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
                 DECODE_DATA = numpy.uint32(0x00000002)
                 SPECTRA_CALC = numpy.uint32(0x00000004)
                 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
                 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
                 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
                 DATATYPE_CHAR = numpy.uint32(0x00000040)
                 DATATYPE_SHORT = numpy.uint32(0x00000080)
                 DATATYPE_LONG = numpy.uint32(0x00000100)
                 DATATYPE_INT64 = numpy.uint32(0x00000200)
                 DATATYPE_FLOAT = numpy.uint32(0x00000400)
                 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
                 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
                 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
                 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
                 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
                 DEFLIP_DATA = numpy.uint32(0x00010000)
                 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
                 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
                 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
                 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
                 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
                 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
                 EXP_NAME_ESP = numpy.uint32(0x00200000)
                 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
                 OPERATION_MASK = numpy.uint32(0x0000003F)
                 DATATYPE_MASK = numpy.uint32(0x00000FC0)
                 DATAARRANGE_MASK = numpy.uint32(0x00007000)
                 ACQ_SYS_MASK = numpy.uint32(0x001C0000)
             dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
             dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
             dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
             dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
             dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
             dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
             NUMPY_DTYPE_LIST = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
             PROCFLAG_DTYPE_LIST =  [PROCFLAG.DATATYPE_CHAR,
                                    PROCFLAG.DATATYPE_SHORT,
                                    PROCFLAG.DATATYPE_LONG,
                                    PROCFLAG.DATATYPE_INT64,
                                    PROCFLAG.DATATYPE_FLOAT,
                                    PROCFLAG.DATATYPE_DOUBLE]
             DTYPE_WIDTH = [1, 2, 4, 8, 4, 8]
             def get_dtype_index(numpy_dtype):
                 index = None
                 for i in range(len(NUMPY_DTYPE_LIST)):
                     if numpy_dtype == NUMPY_DTYPE_LIST[i]:
                         index = i
                         break
                 return index
             def get_numpy_dtype(index):
                 return NUMPY_DTYPE_LIST[index]
             def get_procflag_dtype(index):
                 return PROCFLAG_DTYPE_LIST[index]
             def get_dtype_width(index):
                 return DTYPE_WIDTH[index]

schainpy/model/graphics/mpldriver.py +9 -9

             import numpy
             import datetime
             import sys
             import matplotlib
             if 'linux' in sys.platform:
                 matplotlib.use("TKAgg")
             if 'darwin' in sys.platform:
-                matplotlib.use('GTKAgg')
+                matplotlib.use('WXAgg')
             #Qt4Agg', 'GTK', 'GTKAgg', 'ps', 'agg', 'cairo', 'MacOSX', 'GTKCairo', 'WXAgg', 'template', 'TkAgg', 'GTK3Cairo', 'GTK3Agg', 'svg', 'WebAgg', 'CocoaAgg', 'emf', 'gdk', 'WX'
             import matplotlib.pyplot
             from mpl_toolkits.axes_grid1 import make_axes_locatable
             from matplotlib.ticker import *
             ###########################################
             #Actualizacion de las funciones del driver
             ###########################################
             def createFigure(id, wintitle, width, height, facecolor="w", show=True):
                 matplotlib.pyplot.ioff()
                 fig = matplotlib.pyplot.figure(num=id, facecolor=facecolor)
                 fig.canvas.manager.set_window_title(wintitle)
                 fig.canvas.manager.resize(width, height)
                 matplotlib.pyplot.ion()
                 if show:
                     matplotlib.pyplot.show()
                 return fig
             def closeFigure(show=False, fig=None):
                 matplotlib.pyplot.ioff()
-                matplotlib.pyplot.pause(0.1)
+            #     matplotlib.pyplot.pause(0.1)
                 if show:
                     matplotlib.pyplot.show()
                 if fig != None:
-                    matplotlib.pyplot.close(fig)
+                    matplotlib.pyplot.close(fig.number)
-                    matplotlib.pyplot.pause(0.1)
+            #         matplotlib.pyplot.pause(0.1)
-                    matplotlib.pyplot.ion()
+            #         matplotlib.pyplot.ion()
                     return
                 matplotlib.pyplot.close("all")
-                matplotlib.pyplot.pause(0.1)
+            #     matplotlib.pyplot.pause(0.1)
-                matplotlib.pyplot.ion()
+            #     matplotlib.pyplot.ion()
                 return
             def saveFigure(fig, filename):
-                matplotlib.pyplot.ioff()
+            #     matplotlib.pyplot.ioff()
                 fig.savefig(filename)
-                matplotlib.pyplot.ion()
+            #     matplotlib.pyplot.ion()
             def setWinTitle(fig, title):
                 fig.canvas.manager.set_window_title(title)
             def setTitle(fig, title):
                 fig.suptitle(title)
             def createAxes(fig, nrow, ncol, xpos, ypos, colspan, rowspan, polar=False):
                 matplotlib.pyplot.ioff()
                 matplotlib.pyplot.figure(fig.number)
                 axes = matplotlib.pyplot.subplot2grid((nrow, ncol),
                                                     (xpos, ypos),
                                                     colspan=colspan,
                                                     rowspan=rowspan,
                                                     polar=polar)
                 matplotlib.pyplot.ion()
                 return axes
             def setAxesText(ax, text):
                 ax.annotate(text,
                             xy = (.1, .99),
                             xycoords = 'figure fraction',
                             horizontalalignment = 'left',
                             verticalalignment = 'top',
                             fontsize = 10)
             def printLabels(ax, xlabel, ylabel, title):
                 ax.set_xlabel(xlabel, size=11)
                 ax.set_ylabel(ylabel, size=11)
                 ax.set_title(title, size=8)
             def createPline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='',
                             ticksize=9, xtick_visible=True, ytick_visible=True,
                             nxticks=4, nyticks=10,
                             grid=None,color='blue'):
                 """
                 Input:
                     grid    :    None, 'both', 'x', 'y'
                 """
                 matplotlib.pyplot.ioff()
                 ax.set_xlim([xmin,xmax])
                 ax.set_ylim([ymin,ymax])
                 printLabels(ax, xlabel, ylabel, title)
                 ######################################################
                 if (xmax-xmin)<=1:
                     xtickspos = numpy.linspace(xmin,xmax,nxticks)
                     xtickspos = numpy.array([float("%.1f"%i) for i in xtickspos])
                     ax.set_xticks(xtickspos)
                 else:
                     xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
             #         xtickspos = numpy.arange(nxticks)*float(xmax-xmin)/float(nxticks) + int(xmin)
                     ax.set_xticks(xtickspos)
                 for tick in ax.get_xticklabels():
                     tick.set_visible(xtick_visible)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 ######################################################
                 for tick in ax.get_yticklabels():
                     tick.set_visible(ytick_visible)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 ax.plot(x, y, color=color)
                 iplot = ax.lines[-1]
                 ######################################################
                 if '0.' in matplotlib.__version__[0:2]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if grid != None:
                     ax.grid(b=True, which='major', axis=grid)
                 matplotlib.pyplot.tight_layout()
                 matplotlib.pyplot.ion()
                 return iplot
             def set_linedata(ax, x, y, idline):
                 ax.lines[idline].set_data(x,y)
             def pline(iplot, x, y, xlabel='', ylabel='', title=''):
                 ax = iplot.get_axes()
                 printLabels(ax, xlabel, ylabel, title)
                 set_linedata(ax, x, y, idline=0)
             def addpline(ax, x, y, color, linestyle, lw):
                 ax.plot(x,y,color=color,linestyle=linestyle,lw=lw)
             def createPcolor(ax, x, y, z, xmin, xmax, ymin, ymax, zmin, zmax,
                              xlabel='', ylabel='', title='', ticksize = 9,
                              colormap='jet',cblabel='', cbsize="5%",
                              XAxisAsTime=False):
                 matplotlib.pyplot.ioff()
                 divider = make_axes_locatable(ax)
                 ax_cb = divider.new_horizontal(size=cbsize, pad=0.05)
                 fig = ax.get_figure()
                 fig.add_axes(ax_cb)
                 ax.set_xlim([xmin,xmax])
                 ax.set_ylim([ymin,ymax])
                 printLabels(ax, xlabel, ylabel, title)
                 imesh = ax.pcolormesh(x,y,z.T, vmin=zmin, vmax=zmax, cmap=matplotlib.pyplot.get_cmap(colormap))
                 cb =  matplotlib.pyplot.colorbar(imesh, cax=ax_cb)
                 cb.set_label(cblabel)
             #    for tl in ax_cb.get_yticklabels():
             #        tl.set_visible(True)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in cb.ax.get_yticklabels():
                     tick.set_fontsize(ticksize)
                 ax_cb.yaxis.tick_right()
                 if '0.' in matplotlib.__version__[0:2]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return imesh
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return imesh
                 matplotlib.pyplot.tight_layout()
                 if XAxisAsTime:
                     func = lambda x, pos: ('%s') %(datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
                     ax.xaxis.set_major_formatter(FuncFormatter(func))
                     ax.xaxis.set_major_locator(LinearLocator(7))
                 matplotlib.pyplot.ion()
                 return imesh
             def pcolor(imesh, z, xlabel='', ylabel='', title=''):
                 z = z.T
                 ax = imesh.get_axes()
                 printLabels(ax, xlabel, ylabel, title)
                 imesh.set_array(z.ravel())
             def addpcolor(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title='', colormap='jet'):
                 printLabels(ax, xlabel, ylabel, title)
                 ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax, cmap=matplotlib.pyplot.get_cmap(colormap))
             def addpcolorbuffer(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title='', colormap='jet'):
                 printLabels(ax, xlabel, ylabel, title)
                 ax.collections.remove(ax.collections[0])
                 ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax, cmap=matplotlib.pyplot.get_cmap(colormap))
             def createPmultiline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='', legendlabels=None,
                             ticksize=9, xtick_visible=True, ytick_visible=True,
                             nxticks=4, nyticks=10,
                             grid=None):
                 """
                 Input:
                     grid    :    None, 'both', 'x', 'y'
                 """
                 matplotlib.pyplot.ioff()
                 lines = ax.plot(x.T, y)
                 leg = ax.legend(lines, legendlabels, loc='upper right')
                 leg.get_frame().set_alpha(0.5)
                 ax.set_xlim([xmin,xmax])
                 ax.set_ylim([ymin,ymax])
                 printLabels(ax, xlabel, ylabel, title)
                 xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
                 ax.set_xticks(xtickspos)
                 for tick in ax.get_xticklabels():
                     tick.set_visible(xtick_visible)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in ax.get_yticklabels():
                     tick.set_visible(ytick_visible)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 iplot = ax.lines[-1]
                 if '0.' in matplotlib.__version__[0:2]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if grid != None:
                     ax.grid(b=True, which='major', axis=grid)
                 matplotlib.pyplot.tight_layout()
                 matplotlib.pyplot.ion()
                 return iplot
             def pmultiline(iplot, x, y, xlabel='', ylabel='', title=''):
                 ax = iplot.get_axes()
                 printLabels(ax, xlabel, ylabel, title)
                 for i in range(len(ax.lines)):
                     line = ax.lines[i]
                     line.set_data(x[i,:],y)
             def createPmultilineYAxis(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='', legendlabels=None,
                             ticksize=9, xtick_visible=True, ytick_visible=True,
                             nxticks=4, nyticks=10, marker='.', markersize=10, linestyle="None",
                             grid=None, XAxisAsTime=False):
                 """
                 Input:
                     grid    :    None, 'both', 'x', 'y'
                 """
                 matplotlib.pyplot.ioff()
             #    lines = ax.plot(x, y.T, marker=marker,markersize=markersize,linestyle=linestyle)
                 lines = ax.plot(x, y.T, linestyle=linestyle, marker=marker, markersize=markersize)
                 leg = ax.legend(lines, legendlabels, loc='upper left', bbox_to_anchor=(1.01, 1.00), numpoints=1, handlelength=1.5, \
                                 handletextpad=0.5, borderpad=0.5, labelspacing=0.5, borderaxespad=0.)
                 for label in leg.get_texts(): label.set_fontsize(9)
                 ax.set_xlim([xmin,xmax])
                 ax.set_ylim([ymin,ymax])
                 printLabels(ax, xlabel, ylabel, title)
             #    xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
             #    ax.set_xticks(xtickspos)
                 for tick in ax.get_xticklabels():
                     tick.set_visible(xtick_visible)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in ax.get_yticklabels():
                     tick.set_visible(ytick_visible)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 iplot = ax.lines[-1]
                 if '0.' in matplotlib.__version__[0:2]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if grid != None:
                     ax.grid(b=True, which='major', axis=grid)
                 matplotlib.pyplot.tight_layout()
                 if XAxisAsTime:
                     func = lambda x, pos: ('%s') %(datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
                     ax.xaxis.set_major_formatter(FuncFormatter(func))
                     ax.xaxis.set_major_locator(LinearLocator(7))
                 matplotlib.pyplot.ion()
                 return iplot
             def pmultilineyaxis(iplot, x, y, xlabel='', ylabel='', title=''):
                 ax = iplot.get_axes()
                 printLabels(ax, xlabel, ylabel, title)
                 for i in range(len(ax.lines)):
                     line = ax.lines[i]
                     line.set_data(x,y[i,:])
             def createPolar(ax, x, y,
                             xlabel='', ylabel='', title='', ticksize = 9,
                              colormap='jet',cblabel='', cbsize="5%",
                              XAxisAsTime=False):
                 matplotlib.pyplot.ioff()
                 ax.plot(x,y,'bo', markersize=5)
             #     ax.set_rmax(90)
                 ax.set_ylim(0,90)
                 ax.set_yticks(numpy.arange(0,90,20))
             #     ax.text(0, -110, ylabel, rotation='vertical', va ='center', ha = 'center' ,size='11')
             #     ax.text(0, 50, ylabel, rotation='vertical', va ='center', ha = 'left' ,size='11')
             #     ax.text(100, 100, 'example', ha='left', va='center', rotation='vertical')
                 ax.yaxis.labelpad = 230
                 printLabels(ax, xlabel, ylabel, title)
                 iplot = ax.lines[-1]
                 if '0.' in matplotlib.__version__[0:2]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
             #     if grid != None:
             #         ax.grid(b=True, which='major', axis=grid)
                 matplotlib.pyplot.tight_layout()
                 matplotlib.pyplot.ion()
                 return iplot
             def polar(iplot, x, y, xlabel='', ylabel='', title=''):
                 ax = iplot.get_axes()
             #     ax.text(0, -110, ylabel, rotation='vertical', va ='center', ha = 'center',size='11')
                 printLabels(ax, xlabel, ylabel, title)
                 set_linedata(ax, x, y, idline=0)
             def draw(fig):
                 if type(fig) == 'int':
                     raise ValueError, "Error drawing: Fig parameter should be a matplotlib figure object figure"
                 fig.canvas.draw()
             def pause(interval=0.000001):
                 matplotlib.pyplot.pause(interval)
   No newline at end of file

setup.py +1 0

             '''
             Created on Jul 16, 2014
             @author: roj-idl71
             '''
             from schainpy import __version__
             from setuptools import setup, Extension
             setup(name="schainpy",
                     version=__version__,
                     description="Python tools to read, write and process Jicamarca data",
                     author="Miguel Urco",
                     author_email="miguel.urco@jro.igp.gob.pe",
                     url="http://jro.igp.gob.pe",
                     packages = {'schainpy',
                                 'schainpy.model',
                                 'schainpy.model.data',
                                 'schainpy.model.graphics',
                                 'schainpy.model.io',
                                 'schainpy.model.proc',
                                 'schainpy.model.utils',
                                 'schainpy.gui',
                                 'schainpy.gui.figures',
                                 'schainpy.gui.viewcontroller',
                                 'schainpy.gui.viewer',
                                 'schainpy.gui.viewer.windows'},
                     py_modules=['schainpy.serializer.DataTranslate',
                                 'schainpy.serializer.JROSerializer'],
                     package_data={'schainpy.gui.figures': ['*.png']},
                     include_package_data=True,
                     scripts =['schainpy/gui/schainGUI'],
                     install_requires=["numpy >= 1.6.0",
                                       "scipy >= 0.9.0",
                                       "h5py >= 2.0.1",
+                                      "wxpython >= 2.8",
                                       "matplotlib >= 1.0.0"
                                       ],
                   )

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